zattera-js 0.1.0

package/dist/node/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../src/client/index.ts"],"sourcesContent":["import type {\n  ZatteraClientConfig,\n  JsonRpcRequest,\n  JsonRpcResponse,\n  DynamicGlobalProperties,\n  ChainConfig,\n  WitnessSchedule,\n  HardforkProperties,\n  RewardFund,\n  PriceFeed,\n  FeedHistory,\n  Account,\n  Witness,\n  Comment,\n  SignedBlock,\n  SignedTransaction,\n  ListAccountsParams,\n  FindAccountsParams,\n  ListWitnessesParams,\n  GetAccountHistoryParams,\n  GetOpsInBlockParams,\n  DiscussionQuery,\n  GetFollowersParams,\n  GetFollowingParams,\n  BroadcastTransactionResult,\n  VerifyAuthorityResult,\n  GetTransactionResult,\n  AccountHistoryEntry,\n  Ticker,\n  Volume,\n  TradeHistory,\n  MarketHistory,\n  OrderBook,\n  LimitOrder,\n  ActiveVote,\n  AccountName,\n  PublicKey,\n  TransactionId,\n  OwnerHistory,\n  AccountRecoveryRequest,\n  Escrow,\n  VestingDelegation,\n  ConversionRequest,\n  Vote,\n  WitnessVote,\n} from '../types/index.js';\nimport { generateChainId } from '../utils/chain-id.js';\n\n/**\n * Zattera RPC Client\n *\n * Provides type-safe access to all Zattera blockchain RPC APIs\n * following JSON-RPC 2.0 specification\n */\nexport class ZatteraClient {\n  private endpoint: string;\n  private chainId: string;\n  private timeout: number;\n  private retries: number;\n  private requestId: number;\n\n  constructor(config: ZatteraClientConfig) {\n    this.endpoint = config.endpoint;\n    this.chainId = generateChainId(config.networkName || 'zattera');\n    this.timeout = config.timeout ?? 30000;\n    this.retries = config.retries ?? 3;\n    this.requestId = 0;\n  }\n\n  private getNextId(): number {\n    return ++this.requestId;\n  }\n\n  /**\n   * Get the configured chain ID\n   */\n  getChainId(): string {\n    return this.chainId;\n  }\n\n  /**\n   * Internal method to make JSON-RPC 2.0 requests with retry logic\n   */\n  private async request<T>(\n    method: string,\n    params: unknown[] | Record<string, unknown> = {}\n  ): Promise<T> {\n    const request: JsonRpcRequest = {\n      jsonrpc: '2.0',\n      method,\n      params,\n      id: this.getNextId(),\n    };\n\n    let lastError: Error | null = null;\n\n    for (let attempt = 0; attempt <= this.retries; attempt++) {\n      try {\n        const controller = new AbortController();\n        const timeoutId = setTimeout(() => controller.abort(), this.timeout);\n\n        const response = await fetch(this.endpoint, {\n          method: 'POST',\n          headers: {\n            'Content-Type': 'application/json',\n          },\n          body: JSON.stringify(request),\n          signal: controller.signal,\n        });\n\n        clearTimeout(timeoutId);\n\n        if (!response.ok) {\n          throw new Error(`HTTP error! status: ${response.status}`);\n        }\n\n        const data = (await response.json()) as JsonRpcResponse<T>;\n\n        if (data.error) {\n          throw new Error(\n            `RPC error ${data.error.code}: ${data.error.message}`\n          );\n        }\n\n        if (data.result === undefined) {\n          throw new Error('No result in RPC response');\n        }\n\n        return data.result;\n      } catch (error) {\n        lastError = error instanceof Error ? error : new Error(String(error));\n\n        if (attempt < this.retries) {\n          // Exponential backoff: 1s, 2s, 4s, etc.\n          await new Promise((resolve) =>\n            setTimeout(resolve, 1000 * Math.pow(2, attempt))\n          );\n        }\n      }\n    }\n\n    throw lastError ?? new Error('Request failed');\n  }\n\n  /**\n   * Make batch JSON-RPC requests\n   */\n  async batch<T = unknown>(\n    requests: Array<{ method: string; params?: unknown[] | Record<string, unknown> }>\n  ): Promise<T[]> {\n    const batchRequest = requests.map((req) => ({\n      jsonrpc: '2.0' as const,\n      method: req.method,\n      params: req.params ?? {},\n      id: this.getNextId(),\n    }));\n\n    let lastError: Error | null = null;\n\n    for (let attempt = 0; attempt <= this.retries; attempt++) {\n      try {\n        const controller = new AbortController();\n        const timeoutId = setTimeout(() => controller.abort(), this.timeout);\n\n        const response = await fetch(this.endpoint, {\n          method: 'POST',\n          headers: {\n            'Content-Type': 'application/json',\n          },\n          body: JSON.stringify(batchRequest),\n          signal: controller.signal,\n        });\n\n        clearTimeout(timeoutId);\n\n        if (!response.ok) {\n          throw new Error(`HTTP error! status: ${response.status}`);\n        }\n\n        const data = (await response.json()) as JsonRpcResponse<T>[];\n\n        return data.map((item) => {\n          if (item.error) {\n            throw new Error(\n              `RPC error ${item.error.code}: ${item.error.message}`\n            );\n          }\n          if (item.result === undefined) {\n            throw new Error('No result in RPC response');\n          }\n          return item.result;\n        });\n      } catch (error) {\n        lastError =\n          error instanceof Error ? error : new Error(String(error));\n\n        if (attempt < this.retries) {\n          await new Promise((resolve) =>\n            setTimeout(resolve, 1000 * Math.pow(2, attempt))\n          );\n        }\n      }\n    }\n\n    throw lastError ?? new Error('Batch request failed');\n  }\n\n  // ============================================================================\n  // Generic RPC Call\n  // ============================================================================\n\n  /**\n   * Generic RPC call method for custom or new API methods\n   */\n  async call<T>(method: string, params: unknown[] | Record<string, unknown> = {}): Promise<T> {\n    return this.request<T>(method, params);\n  }\n\n  // ============================================================================\n  // Database API - Global Properties\n  // ============================================================================\n\n  /**\n   * Get compile-time chain configuration constants\n   */\n  async getConfig(): Promise<ChainConfig> {\n    return this.request<ChainConfig>('database_api.get_config', {});\n  }\n\n  /**\n   * Get current dynamic global properties (head block, supply, etc.)\n   */\n  async getDynamicGlobalProperties(): Promise<DynamicGlobalProperties> {\n    return this.request<DynamicGlobalProperties>(\n      'database_api.get_dynamic_global_properties',\n      {}\n    );\n  }\n\n  /**\n   * Get active witness schedule\n   */\n  async getWitnessSchedule(): Promise<WitnessSchedule> {\n    return this.request<WitnessSchedule>(\n      'database_api.get_witness_schedule',\n      {}\n    );\n  }\n\n  /**\n   * Get hardfork properties and version information\n   */\n  async getHardforkProperties(): Promise<HardforkProperties> {\n    return this.request<HardforkProperties>(\n      'database_api.get_hardfork_properties',\n      {}\n    );\n  }\n\n  /**\n   * Get reward fund details\n   */\n  async getRewardFunds(): Promise<RewardFund[]> {\n    const result = await this.request<{ funds: RewardFund[] }>('database_api.get_reward_funds', {});\n    return result.funds;\n  }\n\n  /**\n   * Get current median price feed\n   */\n  async getCurrentPriceFeed(): Promise<PriceFeed> {\n    return this.request<PriceFeed>(\n      'database_api.get_current_price_feed',\n      {}\n    );\n  }\n\n  /**\n   * Get price feed history\n   */\n  async getFeedHistory(): Promise<FeedHistory> {\n    return this.request<FeedHistory>('database_api.get_feed_history', {});\n  }\n\n  // ============================================================================\n  // Database API - Witnesses\n  // ============================================================================\n\n  /**\n   * List witnesses by specified order\n   */\n  async listWitnesses(params: ListWitnessesParams): Promise<Witness[]> {\n    const result = await this.request<{ witnesses: Witness[] }>('database_api.list_witnesses', params);\n    return result.witnesses;\n  }\n\n  /**\n   * Find specific witnesses by account names\n   */\n  async findWitnesses(owners: AccountName[]): Promise<Witness[]> {\n    const result = await this.request<{ witnesses: Witness[] }>('database_api.find_witnesses', {\n      owners,\n    });\n    return result.witnesses;\n  }\n\n  /**\n   * List witness votes\n   */\n  async listWitnessVotes(\n    start: [AccountName, AccountName] | null,\n    limit: number,\n    order: string\n  ): Promise<WitnessVote[]> {\n    return this.request<WitnessVote[]>('database_api.list_witness_votes', {\n      start,\n      limit,\n      order,\n    });\n  }\n\n  /**\n   * Get currently active witnesses\n   */\n  async getActiveWitnesses(): Promise<AccountName[]> {\n    const result = await this.request<{ witnesses: AccountName[] }>(\n      'database_api.get_active_witnesses',\n      {}\n    );\n    return result.witnesses;\n  }\n\n  // ============================================================================\n  // Database API - Accounts\n  // ============================================================================\n\n  /**\n   * List accounts by specified order\n   */\n  async listAccounts(params: ListAccountsParams): Promise<Account[]> {\n    const result = await this.request<{ accounts: Account[] }>('database_api.list_accounts', params);\n    return result.accounts;\n  }\n\n  /**\n   * Find specific accounts by names\n   */\n  async findAccounts(params: FindAccountsParams): Promise<Account[]> {\n    const result = await this.request<{ accounts: Account[] }>('database_api.find_accounts', params);\n    return result.accounts;\n  }\n\n  /**\n   * List account owner authority change history\n   */\n  async listOwnerHistories(\n    start: [AccountName, string] | null,\n    limit: number\n  ): Promise<OwnerHistory[]> {\n    return this.request<OwnerHistory[]>(\n      'database_api.list_owner_histories',\n      { start, limit }\n    );\n  }\n\n  /**\n   * Find owner history for specific account\n   */\n  async findOwnerHistories(owner: AccountName): Promise<OwnerHistory[]> {\n    return this.request<OwnerHistory[]>(\n      'database_api.find_owner_histories',\n      { owner }\n    );\n  }\n\n  /**\n   * List account recovery requests\n   */\n  async listAccountRecoveryRequests(\n    start: AccountName | null,\n    limit: number,\n    order: string\n  ): Promise<AccountRecoveryRequest[]> {\n    return this.request<AccountRecoveryRequest[]>(\n      'database_api.list_account_recovery_requests',\n      { start, limit, order }\n    );\n  }\n\n  /**\n   * Find account recovery requests\n   */\n  async findAccountRecoveryRequests(\n    accounts: AccountName[]\n  ): Promise<AccountRecoveryRequest[]> {\n    return this.request<AccountRecoveryRequest[]>(\n      'database_api.find_account_recovery_requests',\n      { accounts }\n    );\n  }\n\n  /**\n   * List escrows\n   */\n  async listEscrows(\n    start: [AccountName, number] | null,\n    limit: number,\n    order: string\n  ): Promise<Escrow[]> {\n    return this.request<Escrow[]>('database_api.list_escrows', {\n      start,\n      limit,\n      order,\n    });\n  }\n\n  /**\n   * Find escrows\n   */\n  async findEscrows(from: AccountName): Promise<Escrow[]> {\n    return this.request<Escrow[]>('database_api.find_escrows', { from });\n  }\n\n  /**\n   * List vesting delegations\n   */\n  async listVestingDelegations(\n    start: [AccountName, AccountName] | null,\n    limit: number,\n    order: string\n  ): Promise<VestingDelegation[]> {\n    return this.request<VestingDelegation[]>(\n      'database_api.list_vesting_delegations',\n      { start, limit, order }\n    );\n  }\n\n  /**\n   * Find vesting delegations\n   */\n  async findVestingDelegations(\n    account: AccountName\n  ): Promise<VestingDelegation[]> {\n    return this.request<VestingDelegation[]>(\n      'database_api.find_vesting_delegations',\n      { account }\n    );\n  }\n\n  /**\n   * List SBD conversion requests\n   */\n  async listDollarConversionRequests(\n    start: [AccountName, number] | null,\n    limit: number,\n    order: string\n  ): Promise<ConversionRequest[]> {\n    return this.request<ConversionRequest[]>(\n      'database_api.list_dollar_conversion_requests',\n      { start, limit, order }\n    );\n  }\n\n  /**\n   * Find SBD conversion requests\n   */\n  async findDollarConversionRequests(\n    account: AccountName\n  ): Promise<ConversionRequest[]> {\n    return this.request<ConversionRequest[]>(\n      'database_api.find_dollar_conversion_requests',\n      { account }\n    );\n  }\n\n  // ============================================================================\n  // Database API - Comments\n  // ============================================================================\n\n  /**\n   * List comments by specified order\n   */\n  async listComments(\n    start: [AccountName, string] | null,\n    limit: number,\n    order: string\n  ): Promise<Comment[]> {\n    return this.request<Comment[]>('database_api.list_comments', {\n      start,\n      limit,\n      order,\n    });\n  }\n\n  /**\n   * Find specific comments\n   */\n  async findComments(\n    comments: Array<[AccountName, string]>\n  ): Promise<Comment[]> {\n    return this.request<Comment[]>('database_api.find_comments', {\n      comments,\n    });\n  }\n\n  /**\n   * List votes\n   */\n  async listVotes(\n    start: [AccountName, AccountName, string] | null,\n    limit: number,\n    order: string\n  ): Promise<Vote[]> {\n    return this.request<Vote[]>('database_api.list_votes', {\n      start,\n      limit,\n      order,\n    });\n  }\n\n  /**\n   * Find specific votes\n   */\n  async findVotes(\n    author: AccountName,\n    permlink: string\n  ): Promise<Vote[]> {\n    return this.request<Vote[]>('database_api.find_votes', {\n      author,\n      permlink,\n    });\n  }\n\n  // ============================================================================\n  // Database API - Market\n  // ============================================================================\n\n  /**\n   * List limit orders\n   */\n  async listLimitOrders(\n    start: [AccountName, number] | null,\n    limit: number,\n    order: string\n  ): Promise<LimitOrder[]> {\n    return this.request<LimitOrder[]>('database_api.list_limit_orders', {\n      start,\n      limit,\n      order,\n    });\n  }\n\n  /**\n   * Find limit orders\n   */\n  async findLimitOrders(account: AccountName): Promise<LimitOrder[]> {\n    return this.request<LimitOrder[]>('database_api.find_limit_orders', {\n      account,\n    });\n  }\n\n  /**\n   * Get current order book\n   */\n  async getOrderBook(limit: number = 50): Promise<OrderBook> {\n    return this.request<OrderBook>('database_api.get_order_book', {\n      limit,\n    });\n  }\n\n  // ============================================================================\n  // Database API - Authority & Validation\n  // ============================================================================\n\n  /**\n   * Get transaction as hex string\n   */\n  async getTransactionHex(trx: SignedTransaction): Promise<string> {\n    return this.request<string>('database_api.get_transaction_hex', { trx });\n  }\n\n  /**\n   * Get required signatures for transaction\n   */\n  async getRequiredSignatures(\n    trx: SignedTransaction,\n    availableKeys: PublicKey[]\n  ): Promise<PublicKey[]> {\n    return this.request<PublicKey[]>(\n      'database_api.get_required_signatures',\n      { trx, available_keys: availableKeys }\n    );\n  }\n\n  /**\n   * Get all potential signatures for transaction\n   */\n  async getPotentialSignatures(\n    trx: SignedTransaction\n  ): Promise<PublicKey[]> {\n    return this.request<PublicKey[]>(\n      'database_api.get_potential_signatures',\n      { trx }\n    );\n  }\n\n  /**\n   * Verify transaction has required authority\n   */\n  async verifyAuthority(trx: SignedTransaction): Promise<VerifyAuthorityResult> {\n    return this.request<VerifyAuthorityResult>(\n      'database_api.verify_authority',\n      { trx }\n    );\n  }\n\n  /**\n   * Verify account has authority from signers\n   */\n  async verifyAccountAuthority(\n    account: AccountName,\n    signers: PublicKey[]\n  ): Promise<VerifyAuthorityResult> {\n    return this.request<VerifyAuthorityResult>(\n      'database_api.verify_account_authority',\n      { account, signers }\n    );\n  }\n\n  /**\n   * Verify arbitrary signatures\n   */\n  async verifySignatures(\n    hash: string,\n    signatures: string[],\n    requiredOwner: AccountName[],\n    requiredActive: AccountName[],\n    requiredPosting: AccountName[],\n    requiredOther: PublicKey[]\n  ): Promise<VerifyAuthorityResult> {\n    return this.request<VerifyAuthorityResult>(\n      'database_api.verify_signatures',\n      {\n        hash,\n        signatures,\n        required_owner: requiredOwner,\n        required_active: requiredActive,\n        required_posting: requiredPosting,\n        required_other: requiredOther,\n      }\n    );\n  }\n\n  // ============================================================================\n  // Network Broadcast API\n  // ============================================================================\n\n  /**\n   * Broadcast transaction to the network\n   */\n  async broadcastTransaction(\n    trx: SignedTransaction,\n    maxBlockAge: number = -1\n  ): Promise<BroadcastTransactionResult> {\n    return this.request<BroadcastTransactionResult>(\n      'network_broadcast_api.broadcast_transaction',\n      { trx, max_block_age: maxBlockAge }\n    );\n  }\n\n  /**\n   * Broadcast block to the network\n   */\n  async broadcastBlock(block: SignedBlock): Promise<void> {\n    return this.request<void>('network_broadcast_api.broadcast_block', {\n      block,\n    });\n  }\n\n  // ============================================================================\n  // Block API\n  // ============================================================================\n\n  /**\n   * Get block header by block number\n   */\n  async getBlockHeader(blockNum: number): Promise<SignedBlock> {\n    const result = await this.request<{ header: SignedBlock }>('block_api.get_block_header', {\n      block_num: blockNum,\n    });\n    return result.header;\n  }\n\n  /**\n   * Get full block by block number\n   */\n  async getBlock(blockNum: number): Promise<SignedBlock> {\n    const result = await this.request<{ block: SignedBlock }>('block_api.get_block', {\n      block_num: blockNum,\n    });\n    return result.block;\n  }\n\n  // ============================================================================\n  // Account History API\n  // ============================================================================\n\n  /**\n   * Get operations in a specific block\n   */\n  async getOpsInBlock(params: GetOpsInBlockParams): Promise<unknown[]> {\n    return this.request<unknown[]>('account_history_api.get_ops_in_block', params);\n  }\n\n  /**\n   * Get transaction by ID\n   */\n  async getTransaction(id: TransactionId): Promise<GetTransactionResult> {\n    return this.request<GetTransactionResult>(\n      'account_history.get_transaction',\n      { id }\n    );\n  }\n\n  /**\n   * Get account operation history\n   */\n  async getAccountHistory(\n    params: GetAccountHistoryParams\n  ): Promise<Record<number, AccountHistoryEntry>> {\n    return this.request<Record<number, AccountHistoryEntry>>(\n      'account_history.get_account_history',\n      params\n    );\n  }\n\n  /**\n   * Enumerate virtual operations in block range\n   */\n  async enumVirtualOps(\n    blockRangeBegin: number,\n    blockRangeEnd: number\n  ): Promise<unknown[]> {\n    return this.request<unknown[]>('account_history_api.enum_virtual_ops', {\n      block_range_begin: blockRangeBegin,\n      block_range_end: blockRangeEnd,\n    });\n  }\n\n  // ============================================================================\n  // Tags/Discussion API\n  // ============================================================================\n\n  /**\n   * Get trending tags\n   */\n  async getTrendingTags(\n    startTag: string = '',\n    limit: number = 100\n  ): Promise<unknown[]> {\n    const result = await this.request<{ tags: unknown[] }>('tags_api.get_trending_tags', {\n      start_tag: startTag,\n      limit,\n    });\n    return result.tags;\n  }\n\n  /**\n   * Get tags used by author\n   */\n  async getTagsUsedByAuthor(author: AccountName): Promise<unknown[]> {\n    return this.request<unknown[]>('tags_api.get_tags_used_by_author', {\n      author,\n    });\n  }\n\n  /**\n   * Get single discussion/post\n   */\n  async getDiscussion(\n    author: AccountName,\n    permlink: string\n  ): Promise<Comment> {\n    return this.request<Comment>('tags_api.get_discussion', {\n      author,\n      permlink,\n    });\n  }\n\n  /**\n   * Get replies to a post\n   */\n  async getContentReplies(\n    author: AccountName,\n    permlink: string\n  ): Promise<Comment[]> {\n    const result = await this.request<{ discussions: Comment[] }>('tags_api.get_content_replies', {\n      author,\n      permlink,\n    });\n    return result.discussions;\n  }\n\n  /**\n   * Get discussions by trending\n   */\n  async getDiscussionsByTrending(\n    query: DiscussionQuery\n  ): Promise<Comment[]> {\n    return this.request<Comment[]>('tags_api.get_discussions_by_trending', query);\n  }\n\n  /**\n   * Get discussions by creation time\n   */\n  async getDiscussionsByCreated(query: DiscussionQuery): Promise<Comment[]> {\n    return this.request<Comment[]>('tags_api.get_discussions_by_created', query);\n  }\n\n  /**\n   * Get discussions by activity\n   */\n  async getDiscussionsByActive(query: DiscussionQuery): Promise<Comment[]> {\n    return this.request<Comment[]>('tags_api.get_discussions_by_active', query);\n  }\n\n  /**\n   * Get discussions by cashout time\n   */\n  async getDiscussionsByCashout(query: DiscussionQuery): Promise<Comment[]> {\n    return this.request<Comment[]>('tags_api.get_discussions_by_cashout', query);\n  }\n\n  /**\n   * Get discussions by votes\n   */\n  async getDiscussionsByVotes(query: DiscussionQuery): Promise<Comment[]> {\n    return this.request<Comment[]>('tags_api.get_discussions_by_votes', query);\n  }\n\n  /**\n   * Get discussions by children count\n   */\n  async getDiscussionsByChildren(query: DiscussionQuery): Promise<Comment[]> {\n    return this.request<Comment[]>('tags_api.get_discussions_by_children', query);\n  }\n\n  /**\n   * Get hot discussions\n   */\n  async getDiscussionsByHot(query: DiscussionQuery): Promise<Comment[]> {\n    return this.request<Comment[]>('tags_api.get_discussions_by_hot', query);\n  }\n\n  /**\n   * Get discussions from follower feed\n   */\n  async getDiscussionsByFeed(query: DiscussionQuery): Promise<Comment[]> {\n    return this.request<Comment[]>('tags_api.get_discussions_by_feed', query);\n  }\n\n  /**\n   * Get discussions from blog\n   */\n  async getDiscussionsByBlog(query: DiscussionQuery): Promise<Comment[]> {\n    return this.request<Comment[]>('tags_api.get_discussions_by_blog', query);\n  }\n\n  /**\n   * Get discussions by comment count\n   */\n  async getDiscussionsByComments(query: DiscussionQuery): Promise<Comment[]> {\n    return this.request<Comment[]>('tags_api.get_discussions_by_comments', query);\n  }\n\n  /**\n   * Get promoted discussions\n   */\n  async getDiscussionsByPromoted(query: DiscussionQuery): Promise<Comment[]> {\n    return this.request<Comment[]>('tags_api.get_discussions_by_promoted', query);\n  }\n\n  /**\n   * Get active votes on a post\n   */\n  async getActiveVotes(\n    author: AccountName,\n    permlink: string\n  ): Promise<ActiveVote[]> {\n    return this.request<ActiveVote[]>('tags_api.get_active_votes', {\n      author,\n      permlink,\n    });\n  }\n\n  // ============================================================================\n  // Follow API\n  // ============================================================================\n\n  /**\n   * Get followers of an account\n   */\n  async getFollowers(params: GetFollowersParams): Promise<unknown[]> {\n    const result = await this.request<{ followers: unknown[] }>('follow_api.get_followers', params);\n    return result.followers;\n  }\n\n  /**\n   * Get accounts that an account is following\n   */\n  async getFollowing(params: GetFollowingParams): Promise<unknown[]> {\n    const result = await this.request<{ following: unknown[] }>('follow_api.get_following', params);\n    return result.following;\n  }\n\n  /**\n   * Get follower and following counts\n   */\n  async getFollowCount(account: AccountName): Promise<{\n    account: AccountName;\n    follower_count: number;\n    following_count: number;\n  }> {\n    return this.request('follow_api.get_follow_count', { account });\n  }\n\n  /**\n   * Get feed entries\n   */\n  async getFeedEntries(\n    account: AccountName,\n    startEntryId: number = 0,\n    limit: number = 100\n  ): Promise<unknown[]> {\n    return this.request<unknown[]>('follow_api.get_feed_entries', {\n      account,\n      start_entry_id: startEntryId,\n      limit,\n    });\n  }\n\n  /**\n   * Get feed with full comments\n   */\n  async getFeed(\n    account: AccountName,\n    startEntryId: number = 0,\n    limit: number = 100\n  ): Promise<Comment[]> {\n    return this.request<Comment[]>('follow_api.get_feed', {\n      account,\n      start_entry_id: startEntryId,\n      limit,\n    });\n  }\n\n  /**\n   * Get blog entries\n   */\n  async getBlogEntries(\n    account: AccountName,\n    startEntryId: number = 0,\n    limit: number = 100\n  ): Promise<unknown[]> {\n    return this.request<unknown[]>('follow_api.get_blog_entries', {\n      account,\n      start_entry_id: startEntryId,\n      limit,\n    });\n  }\n\n  /**\n   * Get blog with full comments\n   */\n  async getBlog(\n    account: AccountName,\n    startEntryId: number = 0,\n    limit: number = 100\n  ): Promise<Comment[]> {\n    return this.request<Comment[]>('follow_api.get_blog', {\n      account,\n      start_entry_id: startEntryId,\n      limit,\n    });\n  }\n\n  /**\n   * Get account reputation scores\n   */\n  async getAccountReputations(\n    accountLowerBound: AccountName = '',\n    limit: number = 100\n  ): Promise<unknown[]> {\n    return this.request<unknown[]>('follow_api.get_account_reputations', {\n      account_lower_bound: accountLowerBound,\n      limit,\n    });\n  }\n\n  /**\n   * Get accounts that reblogged a post\n   */\n  async getRebloggedBy(\n    author: AccountName,\n    permlink: string\n  ): Promise<AccountName[]> {\n    return this.request<AccountName[]>('follow_api.get_reblogged_by', {\n      author,\n      permlink,\n    });\n  }\n\n  /**\n   * Get blog author statistics\n   */\n  async getBlogAuthors(blogAccount: AccountName): Promise<unknown[]> {\n    return this.request<unknown[]>('follow_api.get_blog_authors', {\n      blog_account: blogAccount,\n    });\n  }\n\n  // ============================================================================\n  // Market History API\n  // ============================================================================\n\n  /**\n   * Get market ticker\n   */\n  async getTicker(): Promise<Ticker> {\n    return this.request<Ticker>('market_history_api.get_ticker', {});\n  }\n\n  /**\n   * Get market volume\n   */\n  async getVolume(): Promise<Volume> {\n    return this.request<Volume>('market_history_api.get_volume', {});\n  }\n\n  /**\n   * Get market order book\n   */\n  async getMarketOrderBook(limit: number = 50): Promise<OrderBook> {\n    return this.request<OrderBook>('market_history_api.get_order_book', {\n      limit,\n    });\n  }\n\n  /**\n   * Get trade history\n   */\n  async getTradeHistory(\n    start: string,\n    end: string,\n    limit: number = 100\n  ): Promise<TradeHistory[]> {\n    return this.request<TradeHistory[]>('market_history_api.get_trade_history', {\n      start,\n      end,\n      limit,\n    });\n  }\n\n  /**\n   * Get recent trades\n   */\n  async getRecentTrades(limit: number = 100): Promise<TradeHistory[]> {\n    return this.request<TradeHistory[]>('market_history_api.get_recent_trades', {\n      limit,\n    });\n  }\n\n  /**\n   * Get market history buckets\n   */\n  async getMarketHistory(\n    bucketSeconds: number,\n    start: string,\n    end: string\n  ): Promise<MarketHistory[]> {\n    return this.request<MarketHistory[]>(\n      'market_history_api.get_market_history',\n      {\n        bucket_seconds: bucketSeconds,\n        start,\n        end,\n      }\n    );\n  }\n\n  /**\n   * Get available bucket sizes\n   */\n  async getMarketHistoryBuckets(): Promise<number[]> {\n    const result = await this.request<{ bucket_sizes: number[] }>(\n      'market_history_api.get_market_history_buckets',\n      {}\n    );\n    return result.bucket_sizes;\n  }\n\n  // ============================================================================\n  // Account By Key API\n  // ============================================================================\n\n  /**\n   * Get accounts that can sign with given public keys\n   */\n  async getKeyReferences(keys: PublicKey[]): Promise<AccountName[][]> {\n    return this.request<AccountName[][]>('account_by_key_api.get_key_references', {\n      keys,\n    });\n  }\n\n  // ============================================================================\n  // JSON-RPC Meta API\n  // ============================================================================\n\n  /**\n   * Get list of all available RPC methods\n   */\n  async getMethods(): Promise<string[]> {\n    return this.request<string[]>('jsonrpc.get_methods', {});\n  }\n\n  /**\n   * Get signature (parameters and return type) for an RPC method\n   */\n  async getSignature(method: string): Promise<unknown> {\n    return this.request<unknown>('jsonrpc.get_signature', { method });\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/node/index.js

@@ -0,0 +1,30 @@
+import { ZatteraClient } from "./client/index.js";
+import { generateChainId } from "./utils/chain-id.js";
+import { Auth, createTransaction, signTransaction, verifyTransactionSignatures } from "./auth/index.js";
+import { JsonRpcErrorCode, ListOrder } from "./types/index.js";
+import { PrivateKey, PublicKey, Signature, generateKeys, isPublicKey, isWif } from "./auth/keys.js";
+import { TransactionSerializer, serializeSignedTransaction, serializeTransaction } from "./auth/serializer.js";
+import { decodeMemo, decodeMemoWithKey, encodeMemo } from "./auth/memo.js";
+export {
+  Auth,
+  JsonRpcErrorCode,
+  ListOrder,
+  PrivateKey,
+  PublicKey,
+  Signature,
+  TransactionSerializer,
+  ZatteraClient,
+  createTransaction,
+  decodeMemo,
+  decodeMemoWithKey,
+  encodeMemo,
+  generateChainId,
+  generateKeys,
+  isPublicKey,
+  isWif,
+  serializeSignedTransaction,
+  serializeTransaction,
+  signTransaction,
+  verifyTransactionSignatures
+};
+//# sourceMappingURL=index.js.map

package/dist/node/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}

package/dist/node/node_modules/@noble/ciphers/aes.js

@@ -0,0 +1,254 @@
+import { wrapCipher, isAligned32, copyBytes, u32, getOutput, complexOverlapBytes, clean, abytes } from "./utils.js";
+const BLOCK_SIZE = 16;
+const POLY = 283;
+function validateKeyLength(key) {
+  if (![16, 24, 32].includes(key.length))
+    throw new Error('"aes key" expected Uint8Array of length 16/24/32, got length=' + key.length);
+}
+function mul2(n) {
+  return n << 1 ^ POLY & -(n >> 7);
+}
+function mul(a, b) {
+  let res = 0;
+  for (; b > 0; b >>= 1) {
+    res ^= a & -(b & 1);
+    a = mul2(a);
+  }
+  return res;
+}
+const sbox = /* @__PURE__ */ (() => {
+  const t = new Uint8Array(256);
+  for (let i = 0, x = 1; i < 256; i++, x ^= mul2(x))
+    t[i] = x;
+  const box = new Uint8Array(256);
+  box[0] = 99;
+  for (let i = 0; i < 255; i++) {
+    let x = t[255 - i];
+    x |= x << 8;
+    box[t[i]] = (x ^ x >> 4 ^ x >> 5 ^ x >> 6 ^ x >> 7 ^ 99) & 255;
+  }
+  clean(t);
+  return box;
+})();
+const invSbox = /* @__PURE__ */ sbox.map((_, j) => sbox.indexOf(j));
+const rotr32_8 = (n) => n << 24 | n >>> 8;
+const rotl32_8 = (n) => n << 8 | n >>> 24;
+function genTtable(sbox2, fn) {
+  if (sbox2.length !== 256)
+    throw new Error("Wrong sbox length");
+  const T0 = new Uint32Array(256).map((_, j) => fn(sbox2[j]));
+  const T1 = T0.map(rotl32_8);
+  const T2 = T1.map(rotl32_8);
+  const T3 = T2.map(rotl32_8);
+  const T01 = new Uint32Array(256 * 256);
+  const T23 = new Uint32Array(256 * 256);
+  const sbox22 = new Uint16Array(256 * 256);
+  for (let i = 0; i < 256; i++) {
+    for (let j = 0; j < 256; j++) {
+      const idx = i * 256 + j;
+      T01[idx] = T0[i] ^ T1[j];
+      T23[idx] = T2[i] ^ T3[j];
+      sbox22[idx] = sbox2[i] << 8 | sbox2[j];
+    }
+  }
+  return { sbox: sbox2, sbox2: sbox22, T0, T1, T2, T3, T01, T23 };
+}
+const tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => mul(s, 3) << 24 | s << 16 | s << 8 | mul(s, 2));
+const tableDecoding = /* @__PURE__ */ genTtable(invSbox, (s) => mul(s, 11) << 24 | mul(s, 13) << 16 | mul(s, 9) << 8 | mul(s, 14));
+const xPowers = /* @__PURE__ */ (() => {
+  const p = new Uint8Array(16);
+  for (let i = 0, x = 1; i < 16; i++, x = mul2(x))
+    p[i] = x;
+  return p;
+})();
+function expandKeyLE(key) {
+  abytes(key);
+  const len = key.length;
+  validateKeyLength(key);
+  const { sbox2 } = tableEncoding;
+  const toClean = [];
+  if (!isAligned32(key))
+    toClean.push(key = copyBytes(key));
+  const k32 = u32(key);
+  const Nk = k32.length;
+  const subByte = (n) => applySbox(sbox2, n, n, n, n);
+  const xk = new Uint32Array(len + 28);
+  xk.set(k32);
+  for (let i = Nk; i < xk.length; i++) {
+    let t = xk[i - 1];
+    if (i % Nk === 0)
+      t = subByte(rotr32_8(t)) ^ xPowers[i / Nk - 1];
+    else if (Nk > 6 && i % Nk === 4)
+      t = subByte(t);
+    xk[i] = xk[i - Nk] ^ t;
+  }
+  clean(...toClean);
+  return xk;
+}
+function expandKeyDecLE(key) {
+  const encKey = expandKeyLE(key);
+  const xk = encKey.slice();
+  const Nk = encKey.length;
+  const { sbox2 } = tableEncoding;
+  const { T0, T1, T2, T3 } = tableDecoding;
+  for (let i = 0; i < Nk; i += 4) {
+    for (let j = 0; j < 4; j++)
+      xk[i + j] = encKey[Nk - i - 4 + j];
+  }
+  clean(encKey);
+  for (let i = 4; i < Nk - 4; i++) {
+    const x = xk[i];
+    const w = applySbox(sbox2, x, x, x, x);
+    xk[i] = T0[w & 255] ^ T1[w >>> 8 & 255] ^ T2[w >>> 16 & 255] ^ T3[w >>> 24];
+  }
+  return xk;
+}
+function apply0123(T01, T23, s0, s1, s2, s3) {
+  return T01[s0 << 8 & 65280 | s1 >>> 8 & 255] ^ T23[s2 >>> 8 & 65280 | s3 >>> 24 & 255];
+}
+function applySbox(sbox2, s0, s1, s2, s3) {
+  return sbox2[s0 & 255 | s1 & 65280] | sbox2[s2 >>> 16 & 255 | s3 >>> 16 & 65280] << 16;
+}
+function encrypt(xk, s0, s1, s2, s3) {
+  const { sbox2, T01, T23 } = tableEncoding;
+  let k = 0;
+  s0 ^= xk[k++], s1 ^= xk[k++], s2 ^= xk[k++], s3 ^= xk[k++];
+  const rounds = xk.length / 4 - 2;
+  for (let i = 0; i < rounds; i++) {
+    const t02 = xk[k++] ^ apply0123(T01, T23, s0, s1, s2, s3);
+    const t12 = xk[k++] ^ apply0123(T01, T23, s1, s2, s3, s0);
+    const t22 = xk[k++] ^ apply0123(T01, T23, s2, s3, s0, s1);
+    const t32 = xk[k++] ^ apply0123(T01, T23, s3, s0, s1, s2);
+    s0 = t02, s1 = t12, s2 = t22, s3 = t32;
+  }
+  const t0 = xk[k++] ^ applySbox(sbox2, s0, s1, s2, s3);
+  const t1 = xk[k++] ^ applySbox(sbox2, s1, s2, s3, s0);
+  const t2 = xk[k++] ^ applySbox(sbox2, s2, s3, s0, s1);
+  const t3 = xk[k++] ^ applySbox(sbox2, s3, s0, s1, s2);
+  return { s0: t0, s1: t1, s2: t2, s3: t3 };
+}
+function decrypt(xk, s0, s1, s2, s3) {
+  const { sbox2, T01, T23 } = tableDecoding;
+  let k = 0;
+  s0 ^= xk[k++], s1 ^= xk[k++], s2 ^= xk[k++], s3 ^= xk[k++];
+  const rounds = xk.length / 4 - 2;
+  for (let i = 0; i < rounds; i++) {
+    const t02 = xk[k++] ^ apply0123(T01, T23, s0, s3, s2, s1);
+    const t12 = xk[k++] ^ apply0123(T01, T23, s1, s0, s3, s2);
+    const t22 = xk[k++] ^ apply0123(T01, T23, s2, s1, s0, s3);
+    const t32 = xk[k++] ^ apply0123(T01, T23, s3, s2, s1, s0);
+    s0 = t02, s1 = t12, s2 = t22, s3 = t32;
+  }
+  const t0 = xk[k++] ^ applySbox(sbox2, s0, s3, s2, s1);
+  const t1 = xk[k++] ^ applySbox(sbox2, s1, s0, s3, s2);
+  const t2 = xk[k++] ^ applySbox(sbox2, s2, s1, s0, s3);
+  const t3 = xk[k++] ^ applySbox(sbox2, s3, s2, s1, s0);
+  return { s0: t0, s1: t1, s2: t2, s3: t3 };
+}
+function validateBlockDecrypt(data) {
+  abytes(data);
+  if (data.length % BLOCK_SIZE !== 0) {
+    throw new Error("aes-(cbc/ecb).decrypt ciphertext should consist of blocks with size " + BLOCK_SIZE);
+  }
+}
+function validateBlockEncrypt(plaintext, pcks5, dst) {
+  abytes(plaintext);
+  let outLen = plaintext.length;
+  const remaining = outLen % BLOCK_SIZE;
+  if (!pcks5 && remaining !== 0)
+    throw new Error("aec/(cbc-ecb): unpadded plaintext with disabled padding");
+  if (!isAligned32(plaintext))
+    plaintext = copyBytes(plaintext);
+  const b = u32(plaintext);
+  if (pcks5) {
+    let left = BLOCK_SIZE - remaining;
+    if (!left)
+      left = BLOCK_SIZE;
+    outLen = outLen + left;
+  }
+  dst = getOutput(outLen, dst);
+  complexOverlapBytes(plaintext, dst);
+  const o = u32(dst);
+  return { b, o, out: dst };
+}
+function validatePCKS(data, pcks5) {
+  if (!pcks5)
+    return data;
+  const len = data.length;
+  if (!len)
+    throw new Error("aes/pcks5: empty ciphertext not allowed");
+  const lastByte = data[len - 1];
+  if (lastByte <= 0 || lastByte > 16)
+    throw new Error("aes/pcks5: wrong padding");
+  const out = data.subarray(0, -lastByte);
+  for (let i = 0; i < lastByte; i++)
+    if (data[len - i - 1] !== lastByte)
+      throw new Error("aes/pcks5: wrong padding");
+  return out;
+}
+function padPCKS(left) {
+  const tmp = new Uint8Array(16);
+  const tmp32 = u32(tmp);
+  tmp.set(left);
+  const paddingByte = BLOCK_SIZE - left.length;
+  for (let i = BLOCK_SIZE - paddingByte; i < BLOCK_SIZE; i++)
+    tmp[i] = paddingByte;
+  return tmp32;
+}
+const cbc = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 16 }, function aescbc(key, iv, opts = {}) {
+  const pcks5 = !opts.disablePadding;
+  return {
+    encrypt(plaintext, dst) {
+      const xk = expandKeyLE(key);
+      const { b, o, out: _out } = validateBlockEncrypt(plaintext, pcks5, dst);
+      let _iv = iv;
+      const toClean = [xk];
+      if (!isAligned32(_iv))
+        toClean.push(_iv = copyBytes(_iv));
+      const n32 = u32(_iv);
+      let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];
+      let i = 0;
+      for (; i + 4 <= b.length; ) {
+        s0 ^= b[i + 0], s1 ^= b[i + 1], s2 ^= b[i + 2], s3 ^= b[i + 3];
+        ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));
+        o[i++] = s0, o[i++] = s1, o[i++] = s2, o[i++] = s3;
+      }
+      if (pcks5) {
+        const tmp32 = padPCKS(plaintext.subarray(i * 4));
+        s0 ^= tmp32[0], s1 ^= tmp32[1], s2 ^= tmp32[2], s3 ^= tmp32[3];
+        ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));
+        o[i++] = s0, o[i++] = s1, o[i++] = s2, o[i++] = s3;
+      }
+      clean(...toClean);
+      return _out;
+    },
+    decrypt(ciphertext, dst) {
+      validateBlockDecrypt(ciphertext);
+      const xk = expandKeyDecLE(key);
+      let _iv = iv;
+      const toClean = [xk];
+      if (!isAligned32(_iv))
+        toClean.push(_iv = copyBytes(_iv));
+      const n32 = u32(_iv);
+      dst = getOutput(ciphertext.length, dst);
+      if (!isAligned32(ciphertext))
+        toClean.push(ciphertext = copyBytes(ciphertext));
+      complexOverlapBytes(ciphertext, dst);
+      const b = u32(ciphertext);
+      const o = u32(dst);
+      let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];
+      for (let i = 0; i + 4 <= b.length; ) {
+        const ps0 = s0, ps1 = s1, ps2 = s2, ps3 = s3;
+        s0 = b[i + 0], s1 = b[i + 1], s2 = b[i + 2], s3 = b[i + 3];
+        const { s0: o0, s1: o1, s2: o2, s3: o3 } = decrypt(xk, s0, s1, s2, s3);
+        o[i++] = o0 ^ ps0, o[i++] = o1 ^ ps1, o[i++] = o2 ^ ps2, o[i++] = o3 ^ ps3;
+      }
+      clean(...toClean);
+      return validatePCKS(dst, pcks5);
+    }
+  };
+});
+export {
+  cbc
+};
+//# sourceMappingURL=aes.js.map

package/dist/node/node_modules/@noble/ciphers/aes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aes.js","sources":["../../../../../node_modules/@noble/ciphers/aes.js"],"sourcesContent":["/**\n * [AES](https://en.wikipedia.org/wiki/Advanced_Encryption_Standard)\n * a.k.a. Advanced Encryption Standard\n * is a variant of Rijndael block cipher, standardized by NIST in 2001.\n * We provide the fastest available pure JS implementation.\n *\n * `cipher = encrypt(block, key)`\n *\n * Data is split into 128-bit blocks. Encrypted in 10/12/14 rounds (128/192/256 bits). In every round:\n * 1. **S-box**, table substitution\n * 2. **Shift rows**, cyclic shift left of all rows of data array\n * 3. **Mix columns**, multiplying every column by fixed polynomial\n * 4. **Add round key**, round_key xor i-th column of array\n *\n * Check out [FIPS-197](https://csrc.nist.gov/files/pubs/fips/197/final/docs/fips-197.pdf),\n * [NIST 800-38G](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38G.pdf)\n * and [original proposal](https://csrc.nist.gov/csrc/media/projects/cryptographic-standards-and-guidelines/documents/aes-development/rijndael-ammended.pdf)\n * @module\n */\nimport { ghash, polyval } from \"./_polyval.js\";\n// prettier-ignore\nimport { abytes, anumber, clean, complexOverlapBytes, concatBytes, copyBytes, createView, equalBytes, getOutput, isAligned32, overlapBytes, u32, u64Lengths, u8, wrapCipher } from \"./utils.js\";\nconst BLOCK_SIZE = 16;\nconst BLOCK_SIZE32 = 4;\nconst EMPTY_BLOCK = /* @__PURE__ */ new Uint8Array(BLOCK_SIZE);\nconst ONE_BLOCK = /* @__PURE__ */ Uint8Array.from([\n    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,\n]);\nconst POLY = 0x11b; // 1 + x + x**3 + x**4 + x**8\nfunction validateKeyLength(key) {\n    if (![16, 24, 32].includes(key.length))\n        throw new Error('\"aes key\" expected Uint8Array of length 16/24/32, got length=' + key.length);\n}\n// TODO: remove multiplication, binary ops only\nfunction mul2(n) {\n    return (n << 1) ^ (POLY & -(n >> 7));\n}\nfunction mul(a, b) {\n    let res = 0;\n    for (; b > 0; b >>= 1) {\n        // Montgomery ladder\n        res ^= a & -(b & 1); // if (b&1) res ^=a (but const-time).\n        a = mul2(a); // a = 2*a\n    }\n    return res;\n}\n// Increments bigint with wrap around\n// NOTE: we cannot use u32 here since it may overflow on carry!\nconst incBytes = (data, isLE, carry = 1) => {\n    if (!Number.isSafeInteger(carry))\n        throw new Error('incBytes: wrong carry ' + carry);\n    abytes(data);\n    for (let i = 0; i < data.length; i++) {\n        const pos = !isLE ? data.length - 1 - i : i;\n        carry = (carry + (data[pos] & 0xff)) | 0;\n        data[pos] = carry & 0xff;\n        carry >>>= 8;\n    }\n};\n// AES S-box is generated using finite field inversion,\n// an affine transform, and xor of a constant 0x63.\nconst sbox = /* @__PURE__ */ (() => {\n    const t = new Uint8Array(256);\n    for (let i = 0, x = 1; i < 256; i++, x ^= mul2(x))\n        t[i] = x;\n    const box = new Uint8Array(256);\n    box[0] = 0x63; // first elm\n    for (let i = 0; i < 255; i++) {\n        let x = t[255 - i];\n        x |= x << 8;\n        box[t[i]] = (x ^ (x >> 4) ^ (x >> 5) ^ (x >> 6) ^ (x >> 7) ^ 0x63) & 0xff;\n    }\n    clean(t);\n    return box;\n})();\n// Inverted S-box\nconst invSbox = /* @__PURE__ */ sbox.map((_, j) => sbox.indexOf(j));\n// Rotate u32 by 8\nconst rotr32_8 = (n) => (n << 24) | (n >>> 8);\nconst rotl32_8 = (n) => (n << 8) | (n >>> 24);\n// The byte swap operation for uint32 (LE<->BE)\nconst byteSwap = (word) => ((word << 24) & 0xff000000) |\n    ((word << 8) & 0xff0000) |\n    ((word >>> 8) & 0xff00) |\n    ((word >>> 24) & 0xff);\n// T-table is optimization suggested in 5.2 of original proposal (missed from FIPS-197). Changes:\n// - LE instead of BE\n// - bigger tables: T0 and T1 are merged into T01 table and T2 & T3 into T23;\n//   so index is u16, instead of u8. This speeds up things, unexpectedly\nfunction genTtable(sbox, fn) {\n    if (sbox.length !== 256)\n        throw new Error('Wrong sbox length');\n    const T0 = new Uint32Array(256).map((_, j) => fn(sbox[j]));\n    const T1 = T0.map(rotl32_8);\n    const T2 = T1.map(rotl32_8);\n    const T3 = T2.map(rotl32_8);\n    const T01 = new Uint32Array(256 * 256);\n    const T23 = new Uint32Array(256 * 256);\n    const sbox2 = new Uint16Array(256 * 256);\n    for (let i = 0; i < 256; i++) {\n        for (let j = 0; j < 256; j++) {\n            const idx = i * 256 + j;\n            T01[idx] = T0[i] ^ T1[j];\n            T23[idx] = T2[i] ^ T3[j];\n            sbox2[idx] = (sbox[i] << 8) | sbox[j];\n        }\n    }\n    return { sbox, sbox2, T0, T1, T2, T3, T01, T23 };\n}\nconst tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => (mul(s, 3) << 24) | (s << 16) | (s << 8) | mul(s, 2));\nconst tableDecoding = /* @__PURE__ */ genTtable(invSbox, (s) => (mul(s, 11) << 24) | (mul(s, 13) << 16) | (mul(s, 9) << 8) | mul(s, 14));\nconst xPowers = /* @__PURE__ */ (() => {\n    const p = new Uint8Array(16);\n    for (let i = 0, x = 1; i < 16; i++, x = mul2(x))\n        p[i] = x;\n    return p;\n})();\n/** Key expansion used in CTR. */\nfunction expandKeyLE(key) {\n    abytes(key);\n    const len = key.length;\n    validateKeyLength(key);\n    const { sbox2 } = tableEncoding;\n    const toClean = [];\n    if (!isAligned32(key))\n        toClean.push((key = copyBytes(key)));\n    const k32 = u32(key);\n    const Nk = k32.length;\n    const subByte = (n) => applySbox(sbox2, n, n, n, n);\n    const xk = new Uint32Array(len + 28); // expanded key\n    xk.set(k32);\n    // 4.3.1 Key expansion\n    for (let i = Nk; i < xk.length; i++) {\n        let t = xk[i - 1];\n        if (i % Nk === 0)\n            t = subByte(rotr32_8(t)) ^ xPowers[i / Nk - 1];\n        else if (Nk > 6 && i % Nk === 4)\n            t = subByte(t);\n        xk[i] = xk[i - Nk] ^ t;\n    }\n    clean(...toClean);\n    return xk;\n}\nfunction expandKeyDecLE(key) {\n    const encKey = expandKeyLE(key);\n    const xk = encKey.slice();\n    const Nk = encKey.length;\n    const { sbox2 } = tableEncoding;\n    const { T0, T1, T2, T3 } = tableDecoding;\n    // Inverse key by chunks of 4 (rounds)\n    for (let i = 0; i < Nk; i += 4) {\n        for (let j = 0; j < 4; j++)\n            xk[i + j] = encKey[Nk - i - 4 + j];\n    }\n    clean(encKey);\n    // apply InvMixColumn except first & last round\n    for (let i = 4; i < Nk - 4; i++) {\n        const x = xk[i];\n        const w = applySbox(sbox2, x, x, x, x);\n        xk[i] = T0[w & 0xff] ^ T1[(w >>> 8) & 0xff] ^ T2[(w >>> 16) & 0xff] ^ T3[w >>> 24];\n    }\n    return xk;\n}\n// Apply tables\nfunction apply0123(T01, T23, s0, s1, s2, s3) {\n    return (T01[((s0 << 8) & 0xff00) | ((s1 >>> 8) & 0xff)] ^\n        T23[((s2 >>> 8) & 0xff00) | ((s3 >>> 24) & 0xff)]);\n}\nfunction applySbox(sbox2, s0, s1, s2, s3) {\n    return (sbox2[(s0 & 0xff) | (s1 & 0xff00)] |\n        (sbox2[((s2 >>> 16) & 0xff) | ((s3 >>> 16) & 0xff00)] << 16));\n}\nfunction encrypt(xk, s0, s1, s2, s3) {\n    const { sbox2, T01, T23 } = tableEncoding;\n    let k = 0;\n    ((s0 ^= xk[k++]), (s1 ^= xk[k++]), (s2 ^= xk[k++]), (s3 ^= xk[k++]));\n    const rounds = xk.length / 4 - 2;\n    for (let i = 0; i < rounds; i++) {\n        const t0 = xk[k++] ^ apply0123(T01, T23, s0, s1, s2, s3);\n        const t1 = xk[k++] ^ apply0123(T01, T23, s1, s2, s3, s0);\n        const t2 = xk[k++] ^ apply0123(T01, T23, s2, s3, s0, s1);\n        const t3 = xk[k++] ^ apply0123(T01, T23, s3, s0, s1, s2);\n        ((s0 = t0), (s1 = t1), (s2 = t2), (s3 = t3));\n    }\n    // last round (without mixcolumns, so using SBOX2 table)\n    const t0 = xk[k++] ^ applySbox(sbox2, s0, s1, s2, s3);\n    const t1 = xk[k++] ^ applySbox(sbox2, s1, s2, s3, s0);\n    const t2 = xk[k++] ^ applySbox(sbox2, s2, s3, s0, s1);\n    const t3 = xk[k++] ^ applySbox(sbox2, s3, s0, s1, s2);\n    return { s0: t0, s1: t1, s2: t2, s3: t3 };\n}\n// Can't be merged with encrypt: arg positions for apply0123 / applySbox are different\nfunction decrypt(xk, s0, s1, s2, s3) {\n    const { sbox2, T01, T23 } = tableDecoding;\n    let k = 0;\n    ((s0 ^= xk[k++]), (s1 ^= xk[k++]), (s2 ^= xk[k++]), (s3 ^= xk[k++]));\n    const rounds = xk.length / 4 - 2;\n    for (let i = 0; i < rounds; i++) {\n        const t0 = xk[k++] ^ apply0123(T01, T23, s0, s3, s2, s1);\n        const t1 = xk[k++] ^ apply0123(T01, T23, s1, s0, s3, s2);\n        const t2 = xk[k++] ^ apply0123(T01, T23, s2, s1, s0, s3);\n        const t3 = xk[k++] ^ apply0123(T01, T23, s3, s2, s1, s0);\n        ((s0 = t0), (s1 = t1), (s2 = t2), (s3 = t3));\n    }\n    // Last round\n    const t0 = xk[k++] ^ applySbox(sbox2, s0, s3, s2, s1);\n    const t1 = xk[k++] ^ applySbox(sbox2, s1, s0, s3, s2);\n    const t2 = xk[k++] ^ applySbox(sbox2, s2, s1, s0, s3);\n    const t3 = xk[k++] ^ applySbox(sbox2, s3, s2, s1, s0);\n    return { s0: t0, s1: t1, s2: t2, s3: t3 };\n}\n// TODO: investigate merging with ctr32\nfunction ctrCounter(xk, nonce, src, dst) {\n    abytes(nonce, BLOCK_SIZE, 'nonce');\n    abytes(src);\n    const srcLen = src.length;\n    dst = getOutput(srcLen, dst);\n    complexOverlapBytes(src, dst);\n    const ctr = nonce;\n    const c32 = u32(ctr);\n    // Fill block (empty, ctr=0)\n    let { s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]);\n    const src32 = u32(src);\n    const dst32 = u32(dst);\n    // process blocks\n    for (let i = 0; i + 4 <= src32.length; i += 4) {\n        dst32[i + 0] = src32[i + 0] ^ s0;\n        dst32[i + 1] = src32[i + 1] ^ s1;\n        dst32[i + 2] = src32[i + 2] ^ s2;\n        dst32[i + 3] = src32[i + 3] ^ s3;\n        incBytes(ctr, false, 1); // Full 128 bit counter with wrap around\n        ({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]));\n    }\n    // leftovers (less than block)\n    // It's possible to handle > u32 fast, but is it worth it?\n    const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);\n    if (start < srcLen) {\n        const b32 = new Uint32Array([s0, s1, s2, s3]);\n        const buf = u8(b32);\n        for (let i = start, pos = 0; i < srcLen; i++, pos++)\n            dst[i] = src[i] ^ buf[pos];\n        clean(b32);\n    }\n    return dst;\n}\n// AES CTR with overflowing 32 bit counter\n// It's possible to do 32le significantly simpler (and probably faster) by using u32.\n// But, we need both, and perf bottleneck is in ghash anyway.\nfunction ctr32(xk, isLE, nonce, src, dst) {\n    abytes(nonce, BLOCK_SIZE, 'nonce');\n    abytes(src);\n    dst = getOutput(src.length, dst);\n    const ctr = nonce; // write new value to nonce, so it can be re-used\n    const c32 = u32(ctr);\n    const view = createView(ctr);\n    const src32 = u32(src);\n    const dst32 = u32(dst);\n    const ctrPos = isLE ? 0 : 12;\n    const srcLen = src.length;\n    // Fill block (empty, ctr=0)\n    let ctrNum = view.getUint32(ctrPos, isLE); // read current counter value\n    let { s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]);\n    // process blocks\n    for (let i = 0; i + 4 <= src32.length; i += 4) {\n        dst32[i + 0] = src32[i + 0] ^ s0;\n        dst32[i + 1] = src32[i + 1] ^ s1;\n        dst32[i + 2] = src32[i + 2] ^ s2;\n        dst32[i + 3] = src32[i + 3] ^ s3;\n        ctrNum = (ctrNum + 1) >>> 0; // u32 wrap\n        view.setUint32(ctrPos, ctrNum, isLE);\n        ({ s0, s1, s2, s3 } = encrypt(xk, c32[0], c32[1], c32[2], c32[3]));\n    }\n    // leftovers (less than a block)\n    const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);\n    if (start < srcLen) {\n        const b32 = new Uint32Array([s0, s1, s2, s3]);\n        const buf = u8(b32);\n        for (let i = start, pos = 0; i < srcLen; i++, pos++)\n            dst[i] = src[i] ^ buf[pos];\n        clean(b32);\n    }\n    return dst;\n}\n/**\n * **CTR** (Counter Mode): Turns a block cipher into a stream cipher using a counter and IV (nonce).\n * Efficient and parallelizable. Requires a unique nonce per encryption. Unauthenticated: needs MAC.\n */\nexport const ctr = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 16 }, function aesctr(key, nonce) {\n    function processCtr(buf, dst) {\n        abytes(buf);\n        if (dst !== undefined) {\n            abytes(dst);\n            if (!isAligned32(dst))\n                throw new Error('unaligned destination');\n        }\n        const xk = expandKeyLE(key);\n        const n = copyBytes(nonce); // align + avoid changing\n        const toClean = [xk, n];\n        if (!isAligned32(buf))\n            toClean.push((buf = copyBytes(buf)));\n        const out = ctrCounter(xk, n, buf, dst);\n        clean(...toClean);\n        return out;\n    }\n    return {\n        encrypt: (plaintext, dst) => processCtr(plaintext, dst),\n        decrypt: (ciphertext, dst) => processCtr(ciphertext, dst),\n    };\n});\nfunction validateBlockDecrypt(data) {\n    abytes(data);\n    if (data.length % BLOCK_SIZE !== 0) {\n        throw new Error('aes-(cbc/ecb).decrypt ciphertext should consist of blocks with size ' + BLOCK_SIZE);\n    }\n}\nfunction validateBlockEncrypt(plaintext, pcks5, dst) {\n    abytes(plaintext);\n    let outLen = plaintext.length;\n    const remaining = outLen % BLOCK_SIZE;\n    if (!pcks5 && remaining !== 0)\n        throw new Error('aec/(cbc-ecb): unpadded plaintext with disabled padding');\n    if (!isAligned32(plaintext))\n        plaintext = copyBytes(plaintext);\n    const b = u32(plaintext);\n    if (pcks5) {\n        let left = BLOCK_SIZE - remaining;\n        if (!left)\n            left = BLOCK_SIZE; // if no bytes left, create empty padding block\n        outLen = outLen + left;\n    }\n    dst = getOutput(outLen, dst);\n    complexOverlapBytes(plaintext, dst);\n    const o = u32(dst);\n    return { b, o, out: dst };\n}\nfunction validatePCKS(data, pcks5) {\n    if (!pcks5)\n        return data;\n    const len = data.length;\n    if (!len)\n        throw new Error('aes/pcks5: empty ciphertext not allowed');\n    const lastByte = data[len - 1];\n    if (lastByte <= 0 || lastByte > 16)\n        throw new Error('aes/pcks5: wrong padding');\n    const out = data.subarray(0, -lastByte);\n    for (let i = 0; i < lastByte; i++)\n        if (data[len - i - 1] !== lastByte)\n            throw new Error('aes/pcks5: wrong padding');\n    return out;\n}\nfunction padPCKS(left) {\n    const tmp = new Uint8Array(16);\n    const tmp32 = u32(tmp);\n    tmp.set(left);\n    const paddingByte = BLOCK_SIZE - left.length;\n    for (let i = BLOCK_SIZE - paddingByte; i < BLOCK_SIZE; i++)\n        tmp[i] = paddingByte;\n    return tmp32;\n}\n/**\n * **ECB** (Electronic Codebook): Deterministic encryption; identical plaintext blocks yield\n * identical ciphertexts. Not secure due to pattern leakage.\n * See [AES Penguin](https://words.filippo.io/the-ecb-penguin/).\n */\nexport const ecb = /* @__PURE__ */ wrapCipher({ blockSize: 16 }, function aesecb(key, opts = {}) {\n    const pcks5 = !opts.disablePadding;\n    return {\n        encrypt(plaintext, dst) {\n            const { b, o, out: _out } = validateBlockEncrypt(plaintext, pcks5, dst);\n            const xk = expandKeyLE(key);\n            let i = 0;\n            for (; i + 4 <= b.length;) {\n                const { s0, s1, s2, s3 } = encrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);\n                ((o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3));\n            }\n            if (pcks5) {\n                const tmp32 = padPCKS(plaintext.subarray(i * 4));\n                const { s0, s1, s2, s3 } = encrypt(xk, tmp32[0], tmp32[1], tmp32[2], tmp32[3]);\n                ((o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3));\n            }\n            clean(xk);\n            return _out;\n        },\n        decrypt(ciphertext, dst) {\n            validateBlockDecrypt(ciphertext);\n            const xk = expandKeyDecLE(key);\n            dst = getOutput(ciphertext.length, dst);\n            const toClean = [xk];\n            if (!isAligned32(ciphertext))\n                toClean.push((ciphertext = copyBytes(ciphertext)));\n            complexOverlapBytes(ciphertext, dst);\n            const b = u32(ciphertext);\n            const o = u32(dst);\n            for (let i = 0; i + 4 <= b.length;) {\n                const { s0, s1, s2, s3 } = decrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);\n                ((o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3));\n            }\n            clean(...toClean);\n            return validatePCKS(dst, pcks5);\n        },\n    };\n});\n/**\n * **CBC** (Cipher Block Chaining): Each plaintext block is XORed with the\n * previous block of ciphertext before encryption.\n * Hard to use: requires proper padding and an IV. Unauthenticated: needs MAC.\n */\nexport const cbc = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 16 }, function aescbc(key, iv, opts = {}) {\n    const pcks5 = !opts.disablePadding;\n    return {\n        encrypt(plaintext, dst) {\n            const xk = expandKeyLE(key);\n            const { b, o, out: _out } = validateBlockEncrypt(plaintext, pcks5, dst);\n            let _iv = iv;\n            const toClean = [xk];\n            if (!isAligned32(_iv))\n                toClean.push((_iv = copyBytes(_iv)));\n            const n32 = u32(_iv);\n            // prettier-ignore\n            let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];\n            let i = 0;\n            for (; i + 4 <= b.length;) {\n                ((s0 ^= b[i + 0]), (s1 ^= b[i + 1]), (s2 ^= b[i + 2]), (s3 ^= b[i + 3]));\n                ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n                ((o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3));\n            }\n            if (pcks5) {\n                const tmp32 = padPCKS(plaintext.subarray(i * 4));\n                ((s0 ^= tmp32[0]), (s1 ^= tmp32[1]), (s2 ^= tmp32[2]), (s3 ^= tmp32[3]));\n                ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n                ((o[i++] = s0), (o[i++] = s1), (o[i++] = s2), (o[i++] = s3));\n            }\n            clean(...toClean);\n            return _out;\n        },\n        decrypt(ciphertext, dst) {\n            validateBlockDecrypt(ciphertext);\n            const xk = expandKeyDecLE(key);\n            let _iv = iv;\n            const toClean = [xk];\n            if (!isAligned32(_iv))\n                toClean.push((_iv = copyBytes(_iv)));\n            const n32 = u32(_iv);\n            dst = getOutput(ciphertext.length, dst);\n            if (!isAligned32(ciphertext))\n                toClean.push((ciphertext = copyBytes(ciphertext)));\n            complexOverlapBytes(ciphertext, dst);\n            const b = u32(ciphertext);\n            const o = u32(dst);\n            // prettier-ignore\n            let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];\n            for (let i = 0; i + 4 <= b.length;) {\n                // prettier-ignore\n                const ps0 = s0, ps1 = s1, ps2 = s2, ps3 = s3;\n                ((s0 = b[i + 0]), (s1 = b[i + 1]), (s2 = b[i + 2]), (s3 = b[i + 3]));\n                const { s0: o0, s1: o1, s2: o2, s3: o3 } = decrypt(xk, s0, s1, s2, s3);\n                ((o[i++] = o0 ^ ps0), (o[i++] = o1 ^ ps1), (o[i++] = o2 ^ ps2), (o[i++] = o3 ^ ps3));\n            }\n            clean(...toClean);\n            return validatePCKS(dst, pcks5);\n        },\n    };\n});\n/**\n * CFB: Cipher Feedback Mode. The input for the block cipher is the previous cipher output.\n * Unauthenticated: needs MAC.\n */\nexport const cfb = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 16 }, function aescfb(key, iv) {\n    function processCfb(src, isEncrypt, dst) {\n        abytes(src);\n        const srcLen = src.length;\n        dst = getOutput(srcLen, dst);\n        if (overlapBytes(src, dst))\n            throw new Error('overlapping src and dst not supported.');\n        const xk = expandKeyLE(key);\n        let _iv = iv;\n        const toClean = [xk];\n        if (!isAligned32(_iv))\n            toClean.push((_iv = copyBytes(_iv)));\n        if (!isAligned32(src))\n            toClean.push((src = copyBytes(src)));\n        const src32 = u32(src);\n        const dst32 = u32(dst);\n        const next32 = isEncrypt ? dst32 : src32;\n        const n32 = u32(_iv);\n        // prettier-ignore\n        let s0 = n32[0], s1 = n32[1], s2 = n32[2], s3 = n32[3];\n        for (let i = 0; i + 4 <= src32.length;) {\n            const { s0: e0, s1: e1, s2: e2, s3: e3 } = encrypt(xk, s0, s1, s2, s3);\n            dst32[i + 0] = src32[i + 0] ^ e0;\n            dst32[i + 1] = src32[i + 1] ^ e1;\n            dst32[i + 2] = src32[i + 2] ^ e2;\n            dst32[i + 3] = src32[i + 3] ^ e3;\n            ((s0 = next32[i++]), (s1 = next32[i++]), (s2 = next32[i++]), (s3 = next32[i++]));\n        }\n        // leftovers (less than block)\n        const start = BLOCK_SIZE * Math.floor(src32.length / BLOCK_SIZE32);\n        if (start < srcLen) {\n            ({ s0, s1, s2, s3 } = encrypt(xk, s0, s1, s2, s3));\n            const buf = u8(new Uint32Array([s0, s1, s2, s3]));\n            for (let i = start, pos = 0; i < srcLen; i++, pos++)\n                dst[i] = src[i] ^ buf[pos];\n            clean(buf);\n        }\n        clean(...toClean);\n        return dst;\n    }\n    return {\n        encrypt: (plaintext, dst) => processCfb(plaintext, true, dst),\n        decrypt: (ciphertext, dst) => processCfb(ciphertext, false, dst),\n    };\n});\n// TODO: merge with chacha, however gcm has bitLen while chacha has byteLen\nfunction computeTag(fn, isLE, key, data, AAD) {\n    const aadLength = AAD ? AAD.length : 0;\n    const h = fn.create(key, data.length + aadLength);\n    if (AAD)\n        h.update(AAD);\n    const num = u64Lengths(8 * data.length, 8 * aadLength, isLE);\n    h.update(data);\n    h.update(num);\n    const res = h.digest();\n    clean(num);\n    return res;\n}\n/**\n * **GCM** (Galois/Counter Mode): Combines CTR mode with polynomial MAC. Efficient and widely used.\n * Not perfect:\n * a) conservative key wear-out is `2**32` (4B) msgs.\n * b) key wear-out under random nonces is even smaller: `2**23` (8M) messages for `2**-50` chance.\n * c) MAC can be forged: see Poly1305 documentation.\n */\nexport const gcm = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16, varSizeNonce: true }, function aesgcm(key, nonce, AAD) {\n    // NIST 800-38d doesn't enforce minimum nonce length.\n    // We enforce 8 bytes for compat with openssl.\n    // 12 bytes are recommended. More than 12 bytes would be converted into 12.\n    if (nonce.length < 8)\n        throw new Error('aes/gcm: invalid nonce length');\n    const tagLength = 16;\n    function _computeTag(authKey, tagMask, data) {\n        const tag = computeTag(ghash, false, authKey, data, AAD);\n        for (let i = 0; i < tagMask.length; i++)\n            tag[i] ^= tagMask[i];\n        return tag;\n    }\n    function deriveKeys() {\n        const xk = expandKeyLE(key);\n        const authKey = EMPTY_BLOCK.slice();\n        const counter = EMPTY_BLOCK.slice();\n        ctr32(xk, false, counter, counter, authKey);\n        // NIST 800-38d, page 15: different behavior for 96-bit and non-96-bit nonces\n        if (nonce.length === 12) {\n            counter.set(nonce);\n        }\n        else {\n            const nonceLen = EMPTY_BLOCK.slice();\n            const view = createView(nonceLen);\n            view.setBigUint64(8, BigInt(nonce.length * 8), false);\n            // ghash(nonce || u64be(0) || u64be(nonceLen*8))\n            const g = ghash.create(authKey).update(nonce).update(nonceLen);\n            g.digestInto(counter); // digestInto doesn't trigger '.destroy'\n            g.destroy();\n        }\n        const tagMask = ctr32(xk, false, counter, EMPTY_BLOCK);\n        return { xk, authKey, counter, tagMask };\n    }\n    return {\n        encrypt(plaintext) {\n            const { xk, authKey, counter, tagMask } = deriveKeys();\n            const out = new Uint8Array(plaintext.length + tagLength);\n            const toClean = [xk, authKey, counter, tagMask];\n            if (!isAligned32(plaintext))\n                toClean.push((plaintext = copyBytes(plaintext)));\n            ctr32(xk, false, counter, plaintext, out.subarray(0, plaintext.length));\n            const tag = _computeTag(authKey, tagMask, out.subarray(0, out.length - tagLength));\n            toClean.push(tag);\n            out.set(tag, plaintext.length);\n            clean(...toClean);\n            return out;\n        },\n        decrypt(ciphertext) {\n            const { xk, authKey, counter, tagMask } = deriveKeys();\n            const toClean = [xk, authKey, tagMask, counter];\n            if (!isAligned32(ciphertext))\n                toClean.push((ciphertext = copyBytes(ciphertext)));\n            const data = ciphertext.subarray(0, -tagLength);\n            const passedTag = ciphertext.subarray(-tagLength);\n            const tag = _computeTag(authKey, tagMask, data);\n            toClean.push(tag);\n            if (!equalBytes(tag, passedTag))\n                throw new Error('aes/gcm: invalid ghash tag');\n            const out = ctr32(xk, false, counter, data);\n            clean(...toClean);\n            return out;\n        },\n    };\n});\nconst limit = (name, min, max) => (value) => {\n    if (!Number.isSafeInteger(value) || min > value || value > max) {\n        const minmax = '[' + min + '..' + max + ']';\n        throw new Error('' + name + ': expected value in range ' + minmax + ', got ' + value);\n    }\n};\n/**\n * **SIV** (Synthetic IV): GCM with nonce-misuse resistance.\n * Repeating nonces reveal only the fact plaintexts are identical.\n * Also suffers from GCM issues: key wear-out limits & MAC forging.\n * See [RFC 8452](https://www.rfc-editor.org/rfc/rfc8452).\n */\nexport const gcmsiv = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 12, tagLength: 16, varSizeNonce: true }, function aessiv(key, nonce, AAD) {\n    const tagLength = 16;\n    // From RFC 8452: Section 6\n    const AAD_LIMIT = limit('AAD', 0, 2 ** 36);\n    const PLAIN_LIMIT = limit('plaintext', 0, 2 ** 36);\n    const NONCE_LIMIT = limit('nonce', 12, 12);\n    const CIPHER_LIMIT = limit('ciphertext', 16, 2 ** 36 + 16);\n    abytes(key);\n    validateKeyLength(key);\n    NONCE_LIMIT(nonce.length);\n    if (AAD !== undefined)\n        AAD_LIMIT(AAD.length);\n    function deriveKeys() {\n        const xk = expandKeyLE(key);\n        const encKey = new Uint8Array(key.length);\n        const authKey = new Uint8Array(16);\n        const toClean = [xk, encKey];\n        let _nonce = nonce;\n        if (!isAligned32(_nonce))\n            toClean.push((_nonce = copyBytes(_nonce)));\n        const n32 = u32(_nonce);\n        // prettier-ignore\n        let s0 = 0, s1 = n32[0], s2 = n32[1], s3 = n32[2];\n        let counter = 0;\n        for (const derivedKey of [authKey, encKey].map(u32)) {\n            const d32 = u32(derivedKey);\n            for (let i = 0; i < d32.length; i += 2) {\n                // aes(u32le(0) || nonce)[:8] || aes(u32le(1) || nonce)[:8] ...\n                const { s0: o0, s1: o1 } = encrypt(xk, s0, s1, s2, s3);\n                d32[i + 0] = o0;\n                d32[i + 1] = o1;\n                s0 = ++counter; // increment counter inside state\n            }\n        }\n        const res = { authKey, encKey: expandKeyLE(encKey) };\n        // Cleanup\n        clean(...toClean);\n        return res;\n    }\n    function _computeTag(encKey, authKey, data) {\n        const tag = computeTag(polyval, true, authKey, data, AAD);\n        // Compute the expected tag by XORing S_s and the nonce, clearing the\n        // most significant bit of the last byte and encrypting with the\n        // message-encryption key.\n        for (let i = 0; i < 12; i++)\n            tag[i] ^= nonce[i];\n        tag[15] &= 0x7f; // Clear the highest bit\n        // encrypt tag as block\n        const t32 = u32(tag);\n        // prettier-ignore\n        let s0 = t32[0], s1 = t32[1], s2 = t32[2], s3 = t32[3];\n        ({ s0, s1, s2, s3 } = encrypt(encKey, s0, s1, s2, s3));\n        ((t32[0] = s0), (t32[1] = s1), (t32[2] = s2), (t32[3] = s3));\n        return tag;\n    }\n    // actual decrypt/encrypt of message.\n    function processSiv(encKey, tag, input) {\n        let block = copyBytes(tag);\n        block[15] |= 0x80; // Force highest bit\n        const res = ctr32(encKey, true, block, input);\n        // Cleanup\n        clean(block);\n        return res;\n    }\n    return {\n        encrypt(plaintext) {\n            PLAIN_LIMIT(plaintext.length);\n            const { encKey, authKey } = deriveKeys();\n            const tag = _computeTag(encKey, authKey, plaintext);\n            const toClean = [encKey, authKey, tag];\n            if (!isAligned32(plaintext))\n                toClean.push((plaintext = copyBytes(plaintext)));\n            const out = new Uint8Array(plaintext.length + tagLength);\n            out.set(tag, plaintext.length);\n            out.set(processSiv(encKey, tag, plaintext));\n            // Cleanup\n            clean(...toClean);\n            return out;\n        },\n        decrypt(ciphertext) {\n            CIPHER_LIMIT(ciphertext.length);\n            const tag = ciphertext.subarray(-tagLength);\n            const { encKey, authKey } = deriveKeys();\n            const toClean = [encKey, authKey];\n            if (!isAligned32(ciphertext))\n                toClean.push((ciphertext = copyBytes(ciphertext)));\n            const plaintext = processSiv(encKey, tag, ciphertext.subarray(0, -tagLength));\n            const expectedTag = _computeTag(encKey, authKey, plaintext);\n            toClean.push(expectedTag);\n            if (!equalBytes(tag, expectedTag)) {\n                clean(...toClean);\n                throw new Error('invalid polyval tag');\n            }\n            // Cleanup\n            clean(...toClean);\n            return plaintext;\n        },\n    };\n});\nfunction isBytes32(a) {\n    return (a instanceof Uint32Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint32Array'));\n}\nfunction encryptBlock(xk, block) {\n    abytes(block, 16, 'block');\n    if (!isBytes32(xk))\n        throw new Error('_encryptBlock accepts result of expandKeyLE');\n    const b32 = u32(block);\n    let { s0, s1, s2, s3 } = encrypt(xk, b32[0], b32[1], b32[2], b32[3]);\n    ((b32[0] = s0), (b32[1] = s1), (b32[2] = s2), (b32[3] = s3));\n    return block;\n}\nfunction decryptBlock(xk, block) {\n    abytes(block, 16, 'block');\n    if (!isBytes32(xk))\n        throw new Error('_decryptBlock accepts result of expandKeyLE');\n    const b32 = u32(block);\n    let { s0, s1, s2, s3 } = decrypt(xk, b32[0], b32[1], b32[2], b32[3]);\n    ((b32[0] = s0), (b32[1] = s1), (b32[2] = s2), (b32[3] = s3));\n    return block;\n}\n/**\n * AES-W (base for AESKW/AESKWP).\n * Specs: [SP800-38F](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38F.pdf),\n * [RFC 3394](https://www.rfc-editor.org/rfc/rfc3394),\n * [RFC 5649](https://www.rfc-editor.org/rfc/rfc5649).\n */\nconst AESW = {\n    /*\n    High-level pseudocode:\n    ```\n    A: u64 = IV\n    out = []\n    for (let i=0, ctr = 0; i<6; i++) {\n      for (const chunk of chunks(plaintext, 8)) {\n        A ^= swapEndianess(ctr++)\n        [A, res] = chunks(encrypt(A || chunk), 8);\n        out ||= res\n      }\n    }\n    out = A || out\n    ```\n    Decrypt is the same, but reversed.\n    */\n    encrypt(kek, out) {\n        // Size is limited to 4GB, otherwise ctr will overflow and we'll need to switch to bigints.\n        // If you need it larger, open an issue.\n        if (out.length >= 2 ** 32)\n            throw new Error('plaintext should be less than 4gb');\n        const xk = expandKeyLE(kek);\n        if (out.length === 16)\n            encryptBlock(xk, out);\n        else {\n            const o32 = u32(out);\n            // prettier-ignore\n            let a0 = o32[0], a1 = o32[1]; // A\n            for (let j = 0, ctr = 1; j < 6; j++) {\n                for (let pos = 2; pos < o32.length; pos += 2, ctr++) {\n                    const { s0, s1, s2, s3 } = encrypt(xk, a0, a1, o32[pos], o32[pos + 1]);\n                    // A = MSB(64, B) ^ t where t = (n*j)+i\n                    ((a0 = s0), (a1 = s1 ^ byteSwap(ctr)), (o32[pos] = s2), (o32[pos + 1] = s3));\n                }\n            }\n            ((o32[0] = a0), (o32[1] = a1)); // out = A || out\n        }\n        xk.fill(0);\n    },\n    decrypt(kek, out) {\n        if (out.length - 8 >= 2 ** 32)\n            throw new Error('ciphertext should be less than 4gb');\n        const xk = expandKeyDecLE(kek);\n        const chunks = out.length / 8 - 1; // first chunk is IV\n        if (chunks === 1)\n            decryptBlock(xk, out);\n        else {\n            const o32 = u32(out);\n            // prettier-ignore\n            let a0 = o32[0], a1 = o32[1]; // A\n            for (let j = 0, ctr = chunks * 6; j < 6; j++) {\n                for (let pos = chunks * 2; pos >= 1; pos -= 2, ctr--) {\n                    a1 ^= byteSwap(ctr);\n                    const { s0, s1, s2, s3 } = decrypt(xk, a0, a1, o32[pos], o32[pos + 1]);\n                    ((a0 = s0), (a1 = s1), (o32[pos] = s2), (o32[pos + 1] = s3));\n                }\n            }\n            ((o32[0] = a0), (o32[1] = a1));\n        }\n        xk.fill(0);\n    },\n};\nconst AESKW_IV = /* @__PURE__ */ new Uint8Array(8).fill(0xa6); // A6A6A6A6A6A6A6A6\n/**\n * AES-KW (key-wrap). Injects static IV into plaintext, adds counter, encrypts 6 times.\n * Reduces block size from 16 to 8 bytes.\n * For padded version, use aeskwp.\n * [RFC 3394](https://www.rfc-editor.org/rfc/rfc3394/),\n * [NIST.SP.800-38F](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.800-38F.pdf).\n */\nexport const aeskw = /* @__PURE__ */ wrapCipher({ blockSize: 8 }, (kek) => ({\n    encrypt(plaintext) {\n        if (!plaintext.length || plaintext.length % 8 !== 0)\n            throw new Error('invalid plaintext length');\n        if (plaintext.length === 8)\n            throw new Error('8-byte keys not allowed in AESKW, use AESKWP instead');\n        const out = concatBytes(AESKW_IV, plaintext);\n        AESW.encrypt(kek, out);\n        return out;\n    },\n    decrypt(ciphertext) {\n        // ciphertext must be at least 24 bytes and a multiple of 8 bytes\n        // 24 because should have at least two block (1 iv + 2).\n        // Replace with 16 to enable '8-byte keys'\n        if (ciphertext.length % 8 !== 0 || ciphertext.length < 3 * 8)\n            throw new Error('invalid ciphertext length');\n        const out = copyBytes(ciphertext);\n        AESW.decrypt(kek, out);\n        if (!equalBytes(out.subarray(0, 8), AESKW_IV))\n            throw new Error('integrity check failed');\n        out.subarray(0, 8).fill(0); // ciphertext.subarray(0, 8) === IV, but we clean it anyway\n        return out.subarray(8);\n    },\n}));\n/*\nWe don't support 8-byte keys. The rabbit hole:\n\n- Wycheproof says: \"NIST SP 800-38F does not define the wrapping of 8 byte keys.\n  RFC 3394 Section 2  on the other hand specifies that 8 byte keys are wrapped\n  by directly encrypting one block with AES.\"\n    - https://github.com/C2SP/wycheproof/blob/master/doc/key_wrap.md\n    - \"RFC 3394 specifies in Section 2, that the input for the key wrap\n      algorithm must be at least two blocks and otherwise the constant\n      field and key are simply encrypted with ECB as a single block\"\n- What RFC 3394 actually says (in Section 2):\n    - \"Before being wrapped, the key data is parsed into n blocks of 64 bits.\n      The only restriction the key wrap algorithm places on n is that n be\n      at least two\"\n    - \"For key data with length less than or equal to 64 bits, the constant\n      field used in this specification and the key data form a single\n      128-bit codebook input making this key wrap unnecessary.\"\n- Which means \"assert(n >= 2)\" and \"use something else for 8 byte keys\"\n- NIST SP800-38F actually prohibits 8-byte in \"5.3.1 Mandatory Limits\".\n  It states that plaintext for KW should be \"2 to 2^54 -1 semiblocks\".\n- So, where does \"directly encrypt single block with AES\" come from?\n    - Not RFC 3394. Pseudocode of key wrap in 2.2 explicitly uses\n      loop of 6 for any code path\n    - There is a weird W3C spec:\n      https://www.w3.org/TR/2002/REC-xmlenc-core-20021210/Overview.html#kw-aes128\n    - This spec is outdated, as admitted by Wycheproof authors\n    - There is RFC 5649 for padded key wrap, which is padding construction on\n      top of AESKW. In '4.1.2' it says: \"If the padded plaintext contains exactly\n      eight octets, then prepend the AIV as defined in Section 3 above to P[1] and\n      encrypt the resulting 128-bit block using AES in ECB mode [Modes] with key\n      K (the KEK).  In this case, the output is two 64-bit blocks C[0] and C[1]:\"\n    - Browser subtle crypto is actually crashes on wrapping keys less than 16 bytes:\n      `Error: error:1C8000E6:Provider routines::invalid input length] { opensslErrorStack: [ 'error:030000BD:digital envelope routines::update error' ]`\n\nIn the end, seems like a bug in Wycheproof.\nThe 8-byte check can be easily disabled inside of AES_W.\n*/\nconst AESKWP_IV = 0xa65959a6; // single u32le value\n/**\n * AES-KW, but with padding and allows random keys.\n * Second u32 of IV is used as counter for length.\n * [RFC 5649](https://www.rfc-editor.org/rfc/rfc5649)\n */\nexport const aeskwp = /* @__PURE__ */ wrapCipher({ blockSize: 8 }, (kek) => ({\n    encrypt(plaintext) {\n        if (!plaintext.length)\n            throw new Error('invalid plaintext length');\n        const padded = Math.ceil(plaintext.length / 8) * 8;\n        const out = new Uint8Array(8 + padded);\n        out.set(plaintext, 8);\n        const out32 = u32(out);\n        out32[0] = AESKWP_IV;\n        out32[1] = byteSwap(plaintext.length);\n        AESW.encrypt(kek, out);\n        return out;\n    },\n    decrypt(ciphertext) {\n        // 16 because should have at least one block\n        if (ciphertext.length < 16)\n            throw new Error('invalid ciphertext length');\n        const out = copyBytes(ciphertext);\n        const o32 = u32(out);\n        AESW.decrypt(kek, out);\n        const len = byteSwap(o32[1]) >>> 0;\n        const padded = Math.ceil(len / 8) * 8;\n        if (o32[0] !== AESKWP_IV || out.length - 8 !== padded)\n            throw new Error('integrity check failed');\n        for (let i = len; i < padded; i++)\n            if (out[8 + i] !== 0)\n                throw new Error('integrity check failed');\n        out.subarray(0, 8).fill(0); // ciphertext.subarray(0, 8) === IV, but we clean it anyway\n        return out.subarray(8, 8 + len);\n    },\n}));\nclass _AesCtrDRBG {\n    blockLen;\n    key;\n    nonce;\n    state;\n    reseedCnt;\n    constructor(keyLen, seed, personalization) {\n        this.blockLen = ctr.blockSize;\n        const keyLenBytes = keyLen / 8;\n        const nonceLen = 16;\n        this.state = new Uint8Array(keyLenBytes + nonceLen);\n        this.key = this.state.subarray(0, keyLenBytes);\n        this.nonce = this.state.subarray(keyLenBytes, keyLenBytes + nonceLen);\n        this.reseedCnt = 1;\n        incBytes(this.nonce, false, 1);\n        this.addEntropy(seed, personalization);\n    }\n    update(data) {\n        // cannot re-use state here, because we will wipe current key\n        ctr(this.key, this.nonce).encrypt(new Uint8Array(this.state.length), this.state);\n        if (data) {\n            abytes(data);\n            for (let i = 0; i < data.length; i++)\n                this.state[i] ^= data[i];\n        }\n        incBytes(this.nonce, false, 1);\n    }\n    addEntropy(seed, info) {\n        abytes(seed, this.state.length, 'seed');\n        const _seed = seed.slice();\n        if (info) {\n            abytes(info);\n            if (info.length > _seed.length)\n                throw new Error('info length is too big');\n            for (let i = 0; i < info.length; i++)\n                _seed[i] ^= info[i];\n        }\n        this.update(_seed);\n        _seed.fill(0);\n        this.reseedCnt = 1;\n    }\n    randomBytes(len, info) {\n        anumber(len);\n        if (this.reseedCnt++ >= 2 ** 48)\n            throw new Error('entropy exhausted');\n        if (info)\n            this.update(info);\n        const res = new Uint8Array(len);\n        ctr(this.key, this.nonce).encrypt(res, res);\n        incBytes(this.nonce, false, Math.ceil(len / this.blockLen));\n        this.update(info);\n        return res;\n    }\n    clean() {\n        this.state.fill(0);\n        this.reseedCnt = 0;\n    }\n}\nconst createAesDrbg = (keyLen) => {\n    return (seed, personalization = undefined) => new _AesCtrDRBG(keyLen, seed, personalization);\n};\n/**\n * AES-CTR DRBG 128-bit - CSPRNG (cryptographically secure pseudorandom number generator).\n * It's best to limit usage to non-production, non-critical cases: for example, test-only.\n */\nexport const rngAesCtrDrbg128 = /* @__PURE__ */ createAesDrbg(128);\n/**\n * AES-CTR DRBG 256-bit - CSPRNG (cryptographically secure pseudorandom number generator).\n * It's best to limit usage to non-production, non-critical cases: for example, test-only.\n */\nexport const rngAesCtrDrbg256 = /* @__PURE__ */ createAesDrbg(256);\n//#region CMAC\n/**\n * Left-shift by one bit and conditionally XOR with 0x87:\n * ```\n * if MSB(L) is equal to 0\n * then    K1 := L << 1;\n * else    K1 := (L << 1) XOR const_Rb;\n * ```\n *\n * Specs: [RFC 4493, Section 2.3](https://www.rfc-editor.org/rfc/rfc4493.html#section-2.3),\n *        [RFC 5297 Section 2.3](https://datatracker.ietf.org/doc/html/rfc5297.html#section-2.3)\n *\n * @returns modified `block` (for chaining)\n */\nfunction dbl(block) {\n    let carry = 0;\n    // Left shift by 1 bit\n    for (let i = BLOCK_SIZE - 1; i >= 0; i--) {\n        const newCarry = (block[i] & 0x80) >>> 7;\n        block[i] = (block[i] << 1) | carry;\n        carry = newCarry;\n    }\n    // XOR with 0x87 if there was a carry from the most significant bit\n    if (carry) {\n        block[BLOCK_SIZE - 1] ^= 0x87;\n    }\n    return block;\n}\n/**\n * `a XOR b`, running in-site on `a`.\n * @param a left operand and output\n * @param b right operand\n * @returns `a` (for chaining)\n */\nfunction xorBlock(a, b) {\n    if (a.length !== b.length)\n        throw new Error('xorBlock: blocks must have same length');\n    for (let i = 0; i < a.length; i++) {\n        a[i] = a[i] ^ b[i];\n    }\n    return a;\n}\n/**\n * xorend as defined in [RFC 5297 Section 2.1](https://datatracker.ietf.org/doc/html/rfc5297.html#section-2.1).\n *\n * ```\n * leftmost(A, len(A)-len(B)) || (rightmost(A, len(B)) xor B)\n * ```\n */\nfunction xorend(a, b) {\n    if (b.length > a.length) {\n        throw new Error('xorend: len(B) must be less than or equal to len(A)');\n    }\n    // keep leftmost part of `a` unchanged\n    // and xor only the rightmost part:\n    const offset = a.length - b.length;\n    for (let i = 0; i < b.length; i++) {\n        a[offset + i] = a[offset + i] ^ b[i];\n    }\n    return a;\n}\n/**\n * Internal CMAC class.\n */\nclass _CMAC {\n    buffer;\n    destroyed;\n    k1;\n    k2;\n    xk;\n    constructor(key) {\n        abytes(key);\n        validateKeyLength(key);\n        this.xk = expandKeyLE(key);\n        this.buffer = new Uint8Array(0);\n        this.destroyed = false;\n        // L = AES_encrypt(K, const_Zero)\n        const L = new Uint8Array(BLOCK_SIZE);\n        encryptBlock(this.xk, L);\n        // Generate subkeys K1 and K2 from the main key according to\n        // [RFC 4493, Section 2.3](https://www.rfc-editor.org/rfc/rfc4493.html#section-2.3)\n        // K1\n        this.k1 = dbl(L);\n        this.k2 = dbl(new Uint8Array(this.k1));\n    }\n    update(data) {\n        const { destroyed, buffer } = this;\n        if (destroyed)\n            throw new Error('CMAC instance was destroyed');\n        abytes(data);\n        const newBuffer = new Uint8Array(buffer.length + data.length);\n        newBuffer.set(buffer);\n        newBuffer.set(data, buffer.length);\n        this.buffer = newBuffer;\n        return this;\n    }\n    // see https://www.rfc-editor.org/rfc/rfc4493.html#section-2.4\n    digest() {\n        if (this.destroyed)\n            throw new Error('CMAC instance was destroyed');\n        const { buffer } = this;\n        const msgLen = buffer.length;\n        // Step 2:\n        let n = Math.ceil(msgLen / BLOCK_SIZE); // n := ceil(len/const_Bsize);\n        // Step 3:\n        let flag; // denoting if last block is complete or not\n        if (n === 0) {\n            n = 1;\n            flag = false;\n        }\n        else {\n            flag = msgLen % BLOCK_SIZE === 0; // if len mod const_Bsize is 0\n        }\n        // Step 4:\n        const lastBlockStart = (n - 1) * BLOCK_SIZE;\n        const lastBlockData = buffer.subarray(lastBlockStart);\n        let m_last;\n        if (flag) {\n            // M_last := M_n XOR K1;\n            m_last = xorBlock(new Uint8Array(lastBlockData), this.k1);\n        }\n        else {\n            // M_last := padding(M_n) XOR K2;\n            //\n            // [...] padding(x) is the concatenation of x and a single '1',\n            // followed by the minimum number of '0's, so that the total length is\n            // equal to 128 bits.\n            const padded = new Uint8Array(BLOCK_SIZE);\n            padded.set(lastBlockData);\n            padded[lastBlockData.length] = 0x80; // single '1' bit\n            m_last = xorBlock(padded, this.k2);\n        }\n        // Step 5:\n        let x = new Uint8Array(BLOCK_SIZE); // X := const_Zero;\n        // Step 6:\n        for (let i = 0; i < n - 1; i++) {\n            const m_i = buffer.subarray(i * BLOCK_SIZE, (i + 1) * BLOCK_SIZE); // M_i\n            xorBlock(x, m_i); // Y := X XOR M_i;\n            encryptBlock(this.xk, x); // X := AES-128(K,Y);\n        }\n        // Step 7:\n        xorBlock(x, m_last); // Y := M_last XOR X;\n        encryptBlock(this.xk, x); // T := AES-128(K,Y);\n        // cleanup:\n        clean(m_last);\n        return x; // T\n    }\n    destroy() {\n        const { buffer, destroyed, xk, k1, k2 } = this;\n        if (destroyed)\n            return;\n        this.destroyed = true;\n        clean(buffer, xk, k1, k2);\n    }\n}\n/**\n * AES-CMAC (Cipher-based Message Authentication Code).\n * Specs: [RFC 4493](https://www.rfc-editor.org/rfc/rfc4493.html).\n */\nexport const cmac = (key, message) => new _CMAC(key).update(message).digest();\ncmac.create = (key) => new _CMAC(key);\n/**\n * S2V (Synthetic Initialization Vector) function as described in [RFC 5297 Section 2.4](https://datatracker.ietf.org/doc/html/rfc5297.html#section-2.4).\n *\n * ```\n * S2V(K, S1, ..., Sn) {\n *   if n = 0 then\n *     return V = AES-CMAC(K, <one>)\n *   fi\n *   D = AES-CMAC(K, <zero>)\n *   for i = 1 to n-1 do\n *     D = dbl(D) xor AES-CMAC(K, Si)\n *   done\n *   if len(Sn) >= 128 then\n *     T = Sn xorend D\n *   else\n *     T = dbl(D) xor pad(Sn)\n *   fi\n *   return V = AES-CMAC(K, T)\n * }\n * ```\n *\n * S2V takes a key and a vector of strings S1, S2, ..., Sn and returns a 128-bit string.\n * The S2V function is used to generate a synthetic IV for AES-SIV.\n *\n * @param key - AES key (128, 192, or 256 bits)\n * @param strings - Array of byte arrays to process\n * @returns 128-bit synthetic IV\n */\nfunction s2v(key, strings) {\n    validateKeyLength(key);\n    const len = strings.length;\n    if (len > 127) {\n        // see https://datatracker.ietf.org/doc/html/rfc5297.html#section-7\n        throw new Error('s2v: number of input strings must be less than or equal to 127');\n    }\n    if (len === 0)\n        return cmac(key, ONE_BLOCK);\n    // D = AES-CMAC(K, <zero>)\n    let d = cmac(key, EMPTY_BLOCK);\n    // for i = 1 to n-1 do\n    //   D = dbl(D) xor AES-CMAC(K, Si)\n    for (let i = 0; i < len - 1; i++) {\n        dbl(d);\n        const cmacResult = cmac(key, strings[i]);\n        xorBlock(d, cmacResult);\n        clean(cmacResult);\n    }\n    const s_n = strings[len - 1];\n    let t;\n    // if len(Sn) >= 128 then\n    if (s_n.byteLength >= BLOCK_SIZE) {\n        // T = Sn xorend D\n        t = xorend(Uint8Array.from(s_n), d);\n    }\n    else {\n        // pad(Sn):\n        const paddedSn = new Uint8Array(BLOCK_SIZE);\n        paddedSn.set(s_n);\n        paddedSn[s_n.length] = 0x80; // padding: 0x80 followed by zeros\n        // T = dbl(D) xor pad(Sn)\n        t = xorBlock(dbl(d), paddedSn);\n        clean(paddedSn);\n    }\n    // V = AES-CMAC(K, T)\n    const result = cmac(key, t);\n    clean(d, t);\n    return result;\n}\n/** Use `gcmsiv` or `aessiv`. */\nexport const siv = () => {\n    throw new Error('\"siv\" from v1 is now \"gcmsiv\"');\n};\n/**\n * **SIV**: Synthetic Initialization Vector (SIV) Authenticated Encryption\n * Nonce is derived from the plaintext and AAD using the S2V function.\n * See [RFC 5297](https://datatracker.ietf.org/doc/html/rfc5297.html).\n */\nexport const aessiv = /* @__PURE__ */ wrapCipher({ blockSize: 16, tagLength: 16 }, function aessiv(key, ...AAD) {\n    // From RFC 5297: Section 6.1, 6.2, 6.3:\n    const PLAIN_LIMIT = limit('plaintext', 0, 2 ** 132);\n    const CIPHER_LIMIT = limit('ciphertext', 16, 2 ** 132 + 16);\n    if (AAD.length > 126) {\n        // see https://datatracker.ietf.org/doc/html/rfc5297.html#section-7\n        throw new Error('\"AAD\" number of elements must be less than or equal to 126');\n    }\n    AAD.forEach((aad) => abytes(aad));\n    abytes(key);\n    if (![32, 48, 64].includes(key.length))\n        throw new Error('\"aes key\" expected Uint8Array of length 32/48/64, got length=' + key.length);\n    // The key is split into equal halves, K1 = leftmost(K, len(K)/2) and\n    // K2 = rightmost(K, len(K)/2).  K1 is used for S2V and K2 is used for CTR.\n    const k1 = key.subarray(0, key.length / 2);\n    const k2 = key.subarray(key.length / 2);\n    return {\n        // https://datatracker.ietf.org/doc/html/rfc5297.html#section-2.6\n        encrypt(plaintext) {\n            PLAIN_LIMIT(plaintext.length);\n            const v = s2v(k1, [...AAD, plaintext]);\n            // clear out the 31st and 63rd (rightmost) bit:\n            const q = Uint8Array.from(v);\n            q[8] &= 0x7f;\n            q[12] &= 0x7f;\n            // encrypt:\n            const c = ctr(k2, q).encrypt(plaintext);\n            return concatBytes(v, c);\n        },\n        // https://datatracker.ietf.org/doc/html/rfc5297.html#section-2.7\n        decrypt(ciphertext) {\n            CIPHER_LIMIT(ciphertext.length);\n            const v = ciphertext.subarray(0, BLOCK_SIZE);\n            const c = ciphertext.subarray(BLOCK_SIZE);\n            // clear out the 31st and 63rd (rightmost) bit:\n            const q = Uint8Array.from(v);\n            q[8] &= 0x7f;\n            q[12] &= 0x7f;\n            // decrypt:\n            const p = ctr(k2, q).decrypt(c);\n            // verify tag:\n            const t = s2v(k1, [...AAD, p]);\n            if (equalBytes(t, v)) {\n                return p;\n            }\n            else {\n                throw new Error('invalid siv tag');\n            }\n        },\n    };\n});\n//#endregion\n/** Unsafe low-level internal methods. May change at any time. */\nexport const unsafe = {\n    expandKeyLE,\n    expandKeyDecLE,\n    encrypt,\n    decrypt,\n    encryptBlock,\n    decryptBlock,\n    ctrCounter,\n    ctr32,\n    dbl,\n    xorBlock,\n    xorend,\n    s2v,\n};\n//# sourceMappingURL=aes.js.map"],"names":["sbox","sbox2","t0","t1","t2","t3"],"mappings":"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","x_google_ignoreList":[0]}