@suigar/sdk 2.0.0-beta.13 → 2.0.0-beta.15

package/CHANGELOG.md

@@ -1,10 +1,29 @@
 # @suigar/sdk
 
+## 2.0.0-beta.15
+
+### Patch Changes
+
+- 67a8b5b: Add `parseGameEvent` to `@suigar/sdk/utils` for extracting a normalized Suigar game id plus raw Move event name for supported Suigar events in `GAME_EVENTS`, including standard `BetResultEvent` and PvP coinflip events.
+
+  Change `parseGameDetails` to accept `gameId` first so TypeScript can narrow the returned detail keys and value types per game.
+
+## 2.0.0-beta.14
+
+### Patch Changes
+
+- f846d27: Rename exported SDK config types to distinguish key unions from ID maps more clearly.
+  - Rename `SuigarPackageKey` to `SuigarPackage`.
+  - Rename the old `SuigarPackage` record type to `SuigarPackageIds`.
+  - Rename `SuigarRegistryKey` to `SuigarRegistry`.
+  - Rename the old `SuigarRegistry` record type to `SuigarRegistryIds`.
+  - Rename `SuigarPriceInfoObjectId` to `SuigarPriceInfoObjectIds`.
+
 ## 2.0.0-beta.13
 
 ### Patch Changes
 
-- 667d7c4: Normalize authored repository wording to use `on-chain` consistently.
+- 667d7c4: Normalize repository wording to use `on-chain` consistently.
 
 ## 2.0.0-beta.12
 
@@ -85,18 +104,18 @@
 
 ### Patch Changes
 
-- 6daa819: Add BCS parser helpers and a Next.js game integration example app.
+- 6daa819: Add BCS parser helpers and a Next.js playground example app.
   - expose parser helpers through `@suigar/sdk/utils`
   - add `parseGameDetails` for decoding `BetResultEvent.game_details`
   - document generated BCS event decoding and game detail parsing guidance
-  - add a testnet-only `apps/playground` app for standard and PvP Suigar transactions
+  - add a testnet-only app for standard and PvP Suigar transactions
   - integrate Mysten dApp Kit wallet connection, signing, and execution
   - add live transaction code previews and shared decoded event logging with SDK parser helpers
   - add Suigar-themed responsive UI, supported coin selection, and human-readable stake handling
   - update PvP coinflip join so callers only provide `gameId` and the SDK derives the join stake while using the configured price info object id
 
 - b89d0b4: Add a public `@suigar/sdk/games` export subpath for shared game option types, and export `SuigarClient` from the package root.
-- bf1f71b: Add `registryIds` to `SuigarConfig` and resolve it from the network config registry map.
+- bf1f71b: Add `registryIds` to `SuigarConfig` and resolve them from the network config registry map.
 
   Document the PvP coinflip runtime helpers more clearly by describing
   registry-backed unresolved game discovery through `getPvPCoinflipGames()` and

package/README.md

@@ -10,7 +10,7 @@ npm install --save @suigar/sdk @mysten/sui @mysten/bcs
 
 Runtime requirements:
 
-- Node.js `>=22`
+- Node.js `^22.18.0 || >=24`
 - ESM project configuration (`"type": "module"`)
 - `@mysten/sui` v2
 - `@mysten/bcs` v2
@@ -71,7 +71,7 @@ Numeric helper behavior:
   JavaScript `number`
 - `parseCoinType(type)` extracts the normalized first generic coin type from a
   Move object type string and throws `TypeError` when no coin type can be parsed
-- `parseGameDetails(gameDetails)` decodes standard `BetResultEvent.game_details`
+- `parseGameDetails(gameId, gameDetails)` decodes standard `BetResultEvent.game_details`
   byte arrays into the expected string, number, and boolean values while
   preserving the original on-chain keys
 
@@ -267,6 +267,9 @@ By default, per-object fetch or parse failures are skipped so one broken or
 already-deleted registry entry does not reject the full lookup. Pass
 `throwOnError: true` if you want the call to reject instead.
 
+Each returned entry includes the parsed game fields plus a derived
+`coin_type` string from the underlying Move object type.
+
 Any supported `listDynamicFields()` options such as `limit`, `cursor`, or
 `signal` can be passed through `options`.
 
@@ -275,7 +278,7 @@ const games = await client.suigar.getPvPCoinflipGames({ limit: 20 });
 
 for (const game of games) {
 	console.log(game.id);
-	console.log(game.coinType);
+	console.log(game.coin_type);
 }
 ```
 
@@ -460,7 +463,7 @@ These are generated Move event decoders. Use them to parse Suigar event payloads
 - `fromMoveFloat(float)` converts a generated Move `Float` struct to a JavaScript number
 - `parseCoinType(type)` extracts the normalized coin type from generic Move object type strings such as PvP coinflip `Game<T>`
   and throws `TypeError` when the type string does not include a first generic coin type
-- `parseGameDetails(game_details)` decodes `BetResultEvent.game_details` entries into the expected string, number, and boolean values
+- `parseGameDetails(gameId, game_details)` decodes `BetResultEvent.game_details` entries into the expected string, number, and boolean values
 
 ### Parse PvP Coinflip Game Object Data
 
@@ -525,17 +528,28 @@ Parsed fields include:
 - `game_details`
 - `metadata`
 
-`game_details` and `metadata` decode as `VecMap<string, vector<u8>>`-shaped data, so values come back as byte arrays. Use `parseGameDetails` from `@suigar/sdk/utils` to decode `game_details` with the SDK's known game-detail schemas.
+`game_details` and `metadata` decode as `VecMap<string, vector<u8>>`-shaped data, so values come back as byte arrays. Use `parseGameEvent(event)` from `@suigar/sdk/utils` to retrieve the normalized `gameId` and `eventName`, then pass that `gameId` to `parseGameDetails(gameId, decoded.game_details)` for game-specific key and value typing.
 
 ```ts
-import { parseGameDetails } from '@suigar/sdk/utils';
+import { parseGameDetails, parseGameEvent } from '@suigar/sdk/utils';
 
+const { gameId, eventName } = parseGameEvent(event)!;
 const decoded = client.suigar.bcs.BetResultEvent.parse(event.bcs);
-const gameDetails = parseGameDetails(decoded.game_details);
+const gameDetails = parseGameDetails(gameId, decoded.game_details);
 ```
 
 `parseGameDetails` preserves the on-chain keys and only changes the value representation. For example, coinflip details keep keys such as `player_bet` and `coin_outcome`; range details keep keys such as `roll_value`, `win`, and `payout_multiplier`.
 
+`parseGameDetails(gameId, decoded.game_details)` narrows based on the parsed event game id. For example, when `gameId === 'coinflip'` it narrows to:
+
+- `{ player_bet: string; coin_outcome: string }`
+
+`parseGameEvent(event)` returns the normalized game id and raw Move event name for every supported Suigar event in `GAME_EVENTS`:
+
+- `{ gameId: 'coinflip' | 'limbo' | 'plinko' | 'range' | 'wheel', eventName: 'BetResultEvent' }` for standard bet result events
+- `{ gameId: 'pvp-coinflip', eventName: 'GameCreatedEvent' | 'GameResolvedEvent' | 'GameCancelledEvent' }` for PvP coinflip events
+- `null` for unsupported event names or non-Suigar event payloads
+
 When the extension is configured with `partner`, decoded event `metadata` will
 contain that partner wallet address under the `partner` entry.
 
@@ -545,7 +559,7 @@ contain that partner wallet address under the `partner` entry.
 > - unwrap the core API union with `result.$kind`, `result.Transaction`, and `result.FailedTransaction`
 > - parse emitted events from the unwrapped transaction result
 > - use `event.bcs` for consistent decoding across transports
-> - use `parseGameDetails(decoded.game_details)` instead of hand-decoding standard game detail byte arrays
+> - use `const { gameId } = parseGameEvent(event)!` and then `parseGameDetails(gameId, decoded.game_details)` instead of hand-decoding standard game detail byte arrays
 
 > **Tip:**
 >

package/dist/client.d.mts

@@ -0,0 +1,258 @@
+import { Game, StandardGame } from "./types/game.type.mjs";
+import { SuigarConfig, SuigarExtensionOptions } from "./types/suigar-config.type.mjs";
+import { BuildPvPCoinflipTransactionOptions, PvPCoinflipAction, WithThrowOnError } from "./types/transaction-options.type.mjs";
+import { MoveStruct } from "./contracts/utils/index.mjs";
+import { Game as Game$1 } from "./contracts/pvp-coinflip/pvp_coinflip.mjs";
+import { BuildGameOptions } from "./types/build-game-transaction-options.type.mjs";
+import { GameParameters, GetGameParametersOptions } from "./types/game-settings.type.mjs";
+import { BuildTransactionOptions, Transaction } from "@mysten/sui/transactions";
+import { ClientWithCoreApi, SuiClientTypes } from "@mysten/sui/client";
+import * as _$_mysten_bcs0 from "@mysten/bcs";
+import { InferBcsType } from "@mysten/bcs";
+
+//#region src/client.d.ts
+declare function suigar<const Name = 'suigar'>({
+  name,
+  partner,
+  cacheTtl
+}?: SuigarExtensionOptions<Name>): {
+  name: Name;
+  register: (client: ClientWithCoreApi) => SuigarClient;
+};
+declare class SuigarClient {
+  #private;
+  constructor({
+    client,
+    name,
+    partner,
+    cacheTtl
+  }: {
+    client: ClientWithCoreApi;
+    name: string;
+    partner?: string;
+    cacheTtl?: number;
+  });
+  /**
+   * Returns the resolved SDK configuration for the connected network.
+   *
+   * This is primarily useful for debugging or inspecting which package ids,
+   * registry ids, supported coin types, and price info object ids the SDK
+   * resolved for the current client network.
+   *
+   * @returns Network-resolved Suigar configuration.
+   */
+  getConfig(): SuigarConfig;
+  /**
+   * Builds a transaction with the configured Sui client and encodes the resulting BCS bytes as base64.
+   *
+   * Use this when an external wallet, API, or transport expects the built transaction payload as a base64 string
+   * instead of raw bytes. The SDK always injects the configured Sui client, so `options` accepts the standard
+   * transaction build options except for `client`.
+   *
+   * @param transaction Transaction to build and serialize.
+   * @param options Optional transaction build options forwarded to `transaction.build()`, excluding `client`.
+   * @returns Base64-encoded transaction bytes ready to send over the wire.
+   */
+  serializeTransactionToBase64(transaction: Transaction, options?: Omit<BuildTransactionOptions, 'client'>): Promise<string>;
+  /**
+   * Reads on-chain game parameters for the requested game.
+   *
+   * The SDK first reads the selected game's settings object from SweetHouse,
+   * then reads that game's coin-specific `Parameters<T>` object. Results are
+   * cached according to the extension `cacheTtl` option. Pass
+   * `ignoreCache: true` to refresh the on-chain read and replace the cached
+   * value.
+   *
+   * @param game Game whose parameters should be loaded.
+   * @param options Optional coin type, cache override, and abort signal.
+   * @returns Parsed game parameters typed for the requested game.
+   */
+  getGameParameters<TGame extends Game>(game: TGame, options?: GetGameParametersOptions): Promise<GameParameters<TGame>>;
+  /**
+   * Lists unresolved PvP coinflip games from the configured registry and resolves
+   * each entry into parsed on-chain game state.
+   *
+   * This fetches dynamic fields from the PvP coinflip registry object, then bulk
+   * loads the referenced game objects through `client.core.getObjects()`. Registry
+   * membership is the unresolved-state signal: when a game is joined and resolved,
+   * the Move flow removes it from the registry and deletes the live `Game` object.
+   * Use this when a product needs the current set of open PvP coinflip matches for
+   * browsing or lobby views.
+   *
+   * @param options Optional dynamic field pagination forwarded to `listDynamicFields()`, excluding `parentId`.
+   * Supported options such as `limit`, `cursor`, and `signal` are forwarded to the
+   * underlying lookup calls. Pass `throwOnError: true` to fail the whole lookup
+   * when any referenced game object cannot be fetched or parsed. By default,
+   * failed per-object lookups are skipped and only successfully parsed unresolved
+   * games are returned.
+   * @returns Parsed unresolved PvP coinflip game objects for the requested
+   * registry page. When `throwOnError` is `false`, entries that fail object fetch
+   * or parse are omitted from the returned array.
+   */
+  getPvPCoinflipGames(options?: WithThrowOnError<Omit<SuiClientTypes.ListDynamicFieldsOptions, 'parentId'>>): Promise<(InferBcsType<typeof Game$1> & {
+    coin_type: string;
+  })[]>;
+  /**
+   * BCS struct constructors for decoding on-chain objects and events related to Suigar games.
+   *
+   * These can be used to parse the `content` field of on-chain objects and events into structured data with the
+   * expected types. For example, use `client.suigar.bcs.PvPCoinflipGame.parse(object.content)` to decode a PvP
+   * coinflip game object.
+   *
+   * Note that these constructors are not meant for encoding transaction arguments, as the SDK's transaction
+   * builders handle argument serialization internally. Use these primarily for decoding and parsing on-chain data.
+   */
+  bcs: {
+    /**
+     * Object representing the state of a PvP coinflip game, as stored on-chain.
+     */
+    PvPCoinflipGame: MoveStruct<{
+      id: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator_is_tails: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      is_private: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      creator_metadata: MoveStruct<{
+        contents: _$_mysten_bcs0.BcsType<{
+          key: string;
+          value: number[];
+        }[], Iterable<{
+          key: string;
+          value: Iterable<number> & {
+            length: number;
+          };
+        }> & {
+          length: number;
+        }, string>;
+      }, "0x2::vec_map::VecMap<string, vector<u8>>">;
+      joiner: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      winner: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      stake_per_player: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      house_edge_bps: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      stake_pot: MoveStruct<{
+        value: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      }, "0x2::balance::Balance<phantom T0>">;
+    }, "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip::Game<phantom T0>">;
+    /**
+     * Event emitted at the end of a standard game (e.g., Coinflip, Limbo), containing the result and payout information.
+     */
+    BetResultEvent: MoveStruct<{
+      player: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      coin_type: MoveStruct<{
+        name: _$_mysten_bcs0.BcsType<string, string, "string">;
+      }, "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName">;
+      stake_amount: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      unsafe_oracle_usd_coin_price: MoveStruct<{
+        is_negative: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+        exp: MoveStruct<{
+          bits: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+        }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+        mant: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+      adjusted_oracle_usd_coin_price: MoveStruct<{
+        is_negative: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+        exp: MoveStruct<{
+          bits: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+        }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::i64::I64">;
+        mant: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::float::Float">;
+      outcome_amount: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      game_details: MoveStruct<{
+        contents: _$_mysten_bcs0.BcsType<{
+          key: string;
+          value: number[];
+        }[], Iterable<{
+          key: string;
+          value: Iterable<number> & {
+            length: number;
+          };
+        }> & {
+          length: number;
+        }, string>;
+      }, "0x2::vec_map::VecMap<string, vector<u8>>">;
+      metadata: MoveStruct<{
+        contents: _$_mysten_bcs0.BcsType<{
+          key: string;
+          value: number[];
+        }[], Iterable<{
+          key: string;
+          value: Iterable<number> & {
+            length: number;
+          };
+        }> & {
+          length: number;
+        }, string>;
+      }, "0x2::vec_map::VecMap<string, vector<u8>>">;
+    }, "0xf391858d2a08473e8d4defcc8df89976bd7b123d3865c6b9341b237f7853dbbc::core::BetResultEvent<phantom T0>">;
+    /**
+     * Event emitted when a PvP Coinflip game is created, containing the game configuration and initial state.
+     */
+    PvPCoinflipGameCreatedEvent: MoveStruct<{
+      game_id: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator_is_tails: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      is_private: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      joiner_is_tails: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      stake_per_player: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      house_edge_bps: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      coin_type: MoveStruct<{
+        name: _$_mysten_bcs0.BcsType<string, string, "string">;
+      }, "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName">;
+    }, "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip::GameCreatedEvent<phantom T0>">;
+    /**
+     * Event emitted when a PvP Coinflip game is resolved, containing the final outcome.
+     */
+    PvPCoinflipGameResolvedEvent: MoveStruct<{
+      game_id: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      joiner: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      winner: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator_is_tails: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      is_private: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      joiner_is_tails: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      stake_per_player: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      total_pot: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      house_edge_amount: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      payout_amount: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      coin_type: MoveStruct<{
+        name: _$_mysten_bcs0.BcsType<string, string, "string">;
+      }, "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName">;
+    }, "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip::GameResolvedEvent<phantom T0>">;
+    /**
+     * Event emitted when a PvP Coinflip game is cancelled.
+     */
+    PvPCoinflipGameCancelledEvent: MoveStruct<{
+      game_id: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator: _$_mysten_bcs0.BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+      creator_is_tails: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      is_private: _$_mysten_bcs0.BcsType<boolean, boolean, "bool">;
+      stake_per_player: _$_mysten_bcs0.BcsType<string, string | number | bigint, "u64">;
+      coin_type: MoveStruct<{
+        name: _$_mysten_bcs0.BcsType<string, string, "string">;
+      }, "0x0000000000000000000000000000000000000000000000000000000000000001::type_name::TypeName">;
+    }, "0xb43cf6583c0c15315c7e66f173af4be79ac40c38aad1fd92ec08638ab2026202::pvp_coinflip::GameCancelledEvent<phantom T0>">;
+  };
+  /**
+   * Transaction builders for Suigar games.
+   */
+  tx: {
+    /**
+     * Creates a standard game transaction for the provided game id.
+     *
+     * @param gameId Supported standard game identifier.
+     * @param options Transaction builder options for the selected game.
+     * @returns Prepared transaction for the selected game.
+     */
+    createBetTransaction: <GameId extends StandardGame>(gameId: GameId, options: BuildGameOptions<GameId>) => Transaction;
+    /**
+     * Creates a PvP coinflip transaction for the requested action.
+     *
+     * @param action PvP coinflip action to perform.
+     * @param options Transaction builder options for the selected action.
+     * @returns Prepared PvP coinflip transaction.
+     */
+    createPvPCoinflipTransaction: <Action extends PvPCoinflipAction>(action: Action, options: BuildPvPCoinflipTransactionOptions<Action>) => Transaction;
+  };
+}
+//#endregion
+export { SuigarClient, suigar };
+//# sourceMappingURL=client.d.mts.map

package/dist/client.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.mts","names":[],"sources":["../src/client.ts"],"mappings":";;;;;;;;;;;;;iBA+DgB,MAAA,uBAAA,CAAA;EACf,IAAA;EACA,OAAA;EACA;AAAA,IACE,sBAAA,CAAuB,IAAA;;qBAGL,iBAAA,KAAoB,YAAA;AAAA;AAAA,cAW5B,YAAA;EAAA;;IAUX,MAAA;IACA,IAAA;IACA,OAAA;IACA;EAAA;IAEA,MAAA,EAAQ,iBAAA;IACR,IAAA;IACA,OAAA;IACA,QAAA;EAAA;EAlCD;;;;;;;;;EA+DA,SAAA,CAAA,GAAa,YAAA;EAhEb;;;;;;;;;;;EA+EM,4BAAA,CACL,WAAA,EAAa,WAAA,EACb,OAAA,GAAU,IAAA,CAAK,uBAAA,cACb,OAAA;;;;;AAjEJ;;;;;;;;;EAmFO,iBAAA,eAAgC,IAAA,CAAA,CACrC,IAAA,EAAM,KAAA,EACN,OAAA,GAAS,wBAAA,GACP,OAAA,CAAQ,cAAA,CAAe,KAAA;EAtBV;;;;;;;;;;;;;;;;;;;;;EAsDV,mBAAA,CACL,OAAA,GAAS,gBAAA,CACR,IAAA,CAAK,cAAA,CAAe,wBAAA,iBAInB,OAAA,EAAS,YAAA,QAAoB,MAAA;IAAqB,SAAA;EAAA;;;;;;;;;;;EA4DrD,GAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsCW;;;;;;;;;;;;;;;IAlNV;;;;;;;;;;;;;;;;;;;IAuEuB;;;;;;;;;;;;;;EAoCvB;;;EA6FD,EAAA;IAxFqD;;;;;;;0CAgGd,YAAA,EAAY,MAAA,EACzC,MAAA,EAAM,OAAA,EACL,gBAAA,CAAiB,MAAA,MACxB,WAAA;;;;;;;;kDA2C2C,iBAAA,EAAiB,MAAA,EACtD,MAAA,EAAM,OAAA,EACL,kCAAA,CAAmC,MAAA,MAC1C,WAAA;EAAA;AAAA"}