@arkiv-network/sdk 0.7.0 → 0.8.0-advanced.3

package/dist/index-D0IzFwMX.d.ts

@@ -0,0 +1,328 @@
+import { a as Bytes32Value, c as I32Value, d as TypeTag, f as U256Value, i as BoolValue, l as KeyValue, n as AnyArkivValue, p as U64Value, r as ArkivValue, s as DecValue, t as AddrValue, u as StrValue } from "./codec-M74UR1_0.js";
+import { Hex } from "viem";
+
+//#region src/attr/values.d.ts
+/** The widest `i32`. */
+declare const I32_MAX = 2147483647;
+/** The narrowest `i32`. */
+declare const I32_MIN = -2147483648;
+/** The widest `u64`. */
+declare const U64_MAX: bigint;
+/** The widest `u256`. */
+declare const U256_MAX: bigint;
+/**
+ * The longest `str`, in UTF-8 bytes
+ */
+declare const MAX_STRING_BYTES = 128;
+/**
+ * A boolean.
+ *
+ * `bool` is the one type that may also be written bare — `{ flagged: true }` and
+ * `{ flagged: bool(true) }` are the same attribute.
+ *
+ * @example
+ * bool(true) // { type: "bool", value: true }
+ */
+declare function bool(value: boolean): BoolValue;
+/**
+ * A 32-bit signed integer, indexed for equality and range queries. This is the default type for a
+ * bare number, so `{ level: 10 }` and `{ level: i32(10) }` are the same attribute.
+ *
+ * @param value - An integer in [-2147483648, 2147483647].
+ * @throws {InvalidValueError} If the value is not an integer, or does not fit an `i32`.
+ *
+ * @example
+ * i32(10)   // { type: "i32", value: 10 }
+ * i32(-42)  // negative values are fine — i32 is the signed integer
+ */
+declare function i32(value: number | bigint): I32Value;
+/**
+ * A 256-bit unsigned integer, indexed for equality and range queries. The type for token amounts
+ * and anything else that can outgrow 2⁶⁴ — reach for {@link u64} first for counters, timestamps
+ * and block heights.
+ *
+ * @param value - A non-negative integer, as a `bigint`, a safe `number`, or a decimal or `0x` hex
+ * string.
+ * @throws {InvalidValueError} If the value is negative, non-integral, or wider than 256 bits.
+ *
+ * @example
+ * u256(1_000_000n)
+ * u256(Date.now())        // safe integers are accepted
+ * u256("0xf4240")         // hex, as it comes back over JSON-RPC
+ */
+declare function u256(value: bigint | number | string): U256Value;
+/**
+ * A 64-bit unsigned integer, indexed for equality and range queries.
+ *
+ * This is the width the protocol counts in: block heights, `$expiresAt` and the entity-nonce are
+ * all `u64`, so it is the type to reach for when a value has to line up with one of them. Use
+ * {@link u256} for token amounts and anything else that can exceed 2⁶⁴.
+ *
+ * @param value - A non-negative integer, as a `bigint`, a safe `number`, or a decimal or `0x` hex
+ * string.
+ * @throws {InvalidValueError} If the value is negative, non-integral, or wider than 64 bits.
+ *
+ * @example
+ * u64(1_200_000n)     // a block height
+ * u64(Date.now())     // safe integers are accepted
+ * u64("0x124f80")     // hex, as it comes back over JSON-RPC
+ */
+declare function u64(value: bigint | number | string): U64Value;
+/**
+ * A signed fixed-point decimal with exactly 18 decimal places, indexed for equality and range
+ * queries.
+ *
+ * Pass fractional values as **strings**. A JavaScript number cannot represent most decimals
+ * exactly, so accepting `dec(0.1 + 0.2)` would quietly store `0.30000000000000004`; requiring the
+ * string keeps what you write and what is stored the same thing. Excess precision is likewise an
+ * error rather than a rounding.
+ *
+ * @param value - A decimal string, or an integral `number` / `bigint`.
+ * @throws {InvalidValueError} If the value is malformed, has more than 18 fractional digits, or
+ * falls outside the `int256` range.
+ *
+ * @example
+ * dec("3.5")
+ * dec("-0.000000000000000001")  // the smallest step
+ * dec(5)                        // integers may be passed bare
+ */
+declare function dec(value: string | number | bigint): DecValue;
+/**
+ * The exact scaled integer behind a `dec` — the value multiplied by 10 ** 18, which is what the
+ * protocol stores and compares. Use it when you need exact arithmetic; JavaScript has no native
+ * decimal type, so the SDK carries the canonical string and leaves the maths to you.
+ *
+ * @example
+ * decUnits(dec("3.5"))  // 3500000000000000000n
+ */
+declare function decUnits(value: DecValue): bigint;
+/**
+ * A `dec` built from its scaled integer units — the inverse of {@link decUnits}.
+ *
+ * @example
+ * decFromUnits(3_500_000_000_000_000_000n)  // dec("3.5")
+ */
+declare function decFromUnits(units: bigint): DecValue;
+/**
+ * A UTF-8 string of at most 128 bytes, indexed for equality and prefix (`STARTSWITH`) matching.
+ *
+ * The limit is on **bytes**, not characters: a string of 128 emoji does not fit.
+ *
+ * C0 control characters and DEL are rejected: the query language writes a `str` as `str('...')`,
+ * whose only escape is a doubled quote, so a control character could be stored but never queried.
+ *
+ * @throws {InvalidValueError} If the value is not a string, holds a control character, or exceeds
+ * 128 UTF-8 bytes.
+ *
+ * @example
+ * str("Bob")
+ */
+declare function str(value: string): StrValue;
+/**
+ * A 20-byte Ethereum address, indexed for equality.
+ *
+ * All-lowercase and all-uppercase input carries no checksum and is accepted as-is; mixed-case
+ * input is checked against its EIP-55 checksum, so a mistyped address is caught here rather than
+ * being written to a wrong account. The stored value is always EIP-55 checksummed.
+ *
+ * @throws {InvalidValueError} If the value is not 20 hex bytes, or fails its EIP-55 checksum.
+ *
+ * @example
+ * addr("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045")
+ */
+declare function addr(value: string): AddrValue;
+/**
+ * A reference to another entity, indexed for equality.
+ *
+ * References are **weak**: nothing checks that the target exists when you write it, and a
+ * reference to a deleted or expired entity is allowed to dangle.
+ *
+ * @param value - A 32-byte entity key, as `0x` hex or raw bytes.
+ * @throws {InvalidValueError} If the value is not exactly 32 bytes.
+ *
+ * @example
+ * key(parentEntityKey)
+ */
+declare function key(value: Hex | Uint8Array): KeyValue;
+/**
+ * 32 opaque bytes — a hash, a digest, an identifier from another system — indexed for equality.
+ *
+ * Use {@link key} instead when the bytes are an Arkiv entity key: same wire width, but the
+ * distinct type makes the reference visible to readers and to the query language.
+ *
+ * @param value - 32 bytes, as `0x` hex or raw bytes.
+ * @throws {InvalidValueError} If the value is not exactly 32 bytes.
+ *
+ * @example
+ * bytes32(keccak256(toBytes("hello")))
+ */
+declare function bytes32(value: Hex | Uint8Array): Bytes32Value;
+/**
+ * A JavaScript value accepted wherever a typed value is expected: either a tagged value, or one of
+ * the four bare forms that map unambiguously onto a single type.
+ *
+ * | bare form | type    |
+ * | --------- | ------- |
+ * | `boolean` | `bool`  |
+ * | `number`  | `i32`   |
+ * | `bigint`  | `u256`  |
+ * | `string`  | `str`   |
+ *
+ * Anything else — a large number, a decimal, an address, an entity key — must name its type, which
+ * is what keeps `"0x1234..."` a string rather than silently becoming a key.
+ *
+ * These defaults apply identically when writing and when querying, so a value written bare and
+ * queried bare always agrees with itself. The mismatch to watch for is mixing the two: an attribute
+ * written as {@link u64} does not match a bare `bigint` predicate, because that predicate asserts
+ * `u256`. A type mismatch is not an error to the engine — it simply matches nothing.
+ */
+type ValueInput = ArkivValue | boolean | number | bigint | string;
+/**
+ * Resolves a {@link ValueInput} to a typed value, applying the bare-form defaults above. Tagged
+ * values pass through untouched.
+ *
+ * @param input - The value to resolve.
+ * @param attributeName - The attribute this value belongs to, used to make errors name it.
+ *
+ * @throws {MissingValueError} If the input is `undefined` or `null` — an attribute is either set
+ * with a value and a type, or not set at all.
+ * @throws {UntypedValueError} If the input is not a tagged value or a bare boolean, number, bigint
+ * or string.
+ * @throws {InvalidValueError} If a bare value does not fit the type it defaults to.
+ *
+ * @example
+ * toValue(10)          // i32(10)
+ * toValue(10n)         // u256(10n)
+ * toValue("hello")     // str("hello")
+ * toValue(dec("3.5"))  // unchanged
+ */
+declare function toValue(input: ValueInput, attributeName?: string): ArkivValue;
+//#endregion
+//#region src/attr/attributes.d.ts
+/**
+ * The most attribute cells one operation may carry.
+ */
+declare const MAX_ATTRIBUTES = 32;
+/**
+ * The largest payload an entity may carry, in bytes. The payload travels as the `$payload` system
+ * cell, so this is a bound on that one attribute rather than on the operation as a whole.
+ */
+declare const MAX_PAYLOAD_BYTES: number;
+/**
+ * The attributes written on an entity, as a plain object keyed by attribute name.
+ *
+ * Values may be tagged ({@link ArkivValue}) or bare where the type is unambiguous — see
+ * {@link toValue} for the bare-form defaults.
+ *
+ * @example
+ * const attributes = {
+ *   level:   i32(10),
+ *   balance: u256(1_000_000n),
+ *   score:   dec("3.5"),
+ *   parent:  key(parentKey),
+ *   name:    "Bob",   // bare string -> str
+ *   flagged: true,    // bare boolean -> bool
+ * } satisfies AttributeInputs
+ */
+type AttributeInputs = Readonly<Record<string, ValueInput>>;
+/**
+ * The attributes read back from an entity: the same shape, with every value typed.
+ *
+ * A value read from here drops straight back into an {@link AttributeInputs} — the vocabulary is the
+ * same in both directions.
+ */
+type Attributes = Readonly<Record<string, AnyArkivValue>>;
+/**
+ * The names and types of an entity's attributes, with no values — what the `attributeSchema`
+ * projection returns.
+ *
+ * Useful for asking what shape the data has without paying to transfer it, and for telling apart
+ * two entities that use the same name with different types.
+ */
+type AttributeSchema = Readonly<Record<string, TypeTag>>;
+//#endregion
+//#region src/attr/decimal.d.ts
+/**
+ * Decimal places a `dec` value is scaled by. Fixed by the protocol, so any two decimals are
+ * directly comparable — and range-indexable — as plain integers.
+ */
+declare const DECIMAL_SCALE = 18;
+/** 10 ** {@link DECIMAL_SCALE} — the scaling factor between a `dec` and its integer units. */
+declare const DECIMAL_UNIT: bigint;
+//#endregion
+//#region src/attr/errors.d.ts
+/**
+ * A value was rejected by its tagged constructor — out of range, wrong length, bad checksum, too
+ * much precision, and so on.
+ *
+ * The message names the offending value and, where there is one, the type that *would* hold it, so
+ * the fix is in the error rather than in the docs.
+ */
+declare class InvalidValueError extends Error {
+  /** The type tag whose constructor rejected the value. */
+  readonly tag: TypeTag;
+  /** The rejected input, as given. */
+  readonly input: unknown;
+  constructor(tag: TypeTag, input: unknown, reason: string, hint?: string);
+}
+/**
+ * A bare JavaScript value could not be given a type. Raised when an attribute or predicate is
+ * handed something that is neither a tagged value nor one of the four bare forms
+ * (`boolean`, `number`, `bigint`, `string`).
+ */
+declare class UntypedValueError extends Error {
+  readonly input: unknown;
+  constructor(input: unknown);
+}
+/**
+ * An attribute was given `undefined` or `null` as its value.
+ *
+ * There is no such thing as an attribute with no value: an attribute either exists with a type, or
+ * is not set. The fix is always to leave the name out of the map rather than to write an empty
+ * value, so this is called out separately from {@link UntypedValueError} — the remedy is different.
+ */
+declare class MissingValueError extends Error {
+  /** The attribute whose value was missing, when raised from an attribute map. */
+  readonly attributeName: string | undefined;
+  constructor(input: null | undefined, attributeName?: string);
+}
+/** An attribute name violated the on-chain name grammar. */
+declare class InvalidAttributeNameError extends Error {
+  readonly attributeName: string;
+  constructor(attributeName: string, reason: string);
+}
+/**
+ * One patch tried to both write and remove the same attribute.
+ */
+declare class ConflictingMutationError extends Error {
+  readonly attributeName: string;
+  constructor(attributeName: string);
+}
+/** More attributes were supplied than an entity operation can carry. */
+declare class TooManyAttributesError extends Error {
+  constructor(count: number, max: number);
+}
+/** The node sent back an attribute this SDK cannot decode. */
+declare class UnknownAttributeTypeError extends Error {
+  /** The type as the node named it — a tag over JSON-RPC, a typeId on the wire. */
+  readonly type: string | number;
+  constructor(type: string | number);
+}
+//#endregion
+//#region src/attr/names.d.ts
+/** The longest attribute name, in bytes — the width of the on-chain `Ident32` name cell. */
+declare const MAX_NAME_BYTES = 32;
+/**
+ * Validates an attribute name against the engine's `Ident32` grammar and the query language's
+ * reserved words.
+ *
+ * @param name - The attribute name.
+ * @throws {InvalidAttributeNameError} If the name is empty, too long, uses characters outside the
+ * grammar, or collides with a reserved word.
+ */
+declare function validateAttributeName(name: string): void;
+/** Whether `name` is a valid attribute name — the non-throwing form of {@link validateAttributeName}. */
+declare function isValidAttributeName(name: string): boolean;
+//#endregion
+export { i32 as A, ValueInput as C, dec as D, bytes32 as E, u64 as F, str as M, toValue as N, decFromUnits as O, u256 as P, U64_MAX as S, bool as T, MAX_PAYLOAD_BYTES as _, InvalidAttributeNameError as a, MAX_STRING_BYTES as b, TooManyAttributesError as c, DECIMAL_SCALE as d, DECIMAL_UNIT as f, MAX_ATTRIBUTES as g, Attributes as h, ConflictingMutationError as i, key as j, decUnits as k, UnknownAttributeTypeError as l, AttributeSchema as m, isValidAttributeName as n, InvalidValueError as o, AttributeInputs as p, validateAttributeName as r, MissingValueError as s, MAX_NAME_BYTES as t, UntypedValueError as u, I32_MAX as v, addr as w, U256_MAX as x, I32_MIN as y };
+//# sourceMappingURL=index-D0IzFwMX.d.ts.map

package/dist/index-D0IzFwMX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-D0IzFwMX.d.ts","names":[],"sources":["../src/attr/values.ts","../src/attr/attributes.ts","../src/attr/decimal.ts","../src/attr/errors.ts","../src/attr/names.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index-DZxwz2Ky.d.cts

@@ -0,0 +1,177 @@
+import { Address, Hex } from "viem";
+
+//#region src/entity/operations.d.ts
+
+/** One entry of the `execute` batch: the operation tag and its ABI-encoded payload. */
+type Operation = {
+  operation: number;
+  operationData: Hex;
+};
+//#endregion
+//#region src/entity/key.d.ts
+/** The widest salt the `uint128` wire field carries. */
+declare const MAX_SALT: bigint;
+/**
+ * Opts a create out of salting, as {@link CreateEntityParameters.salt}: the key is then derived
+ * from the owner and its nonce alone, so anyone who knows both can work it out before the create
+ * lands.
+ */
+declare const NO_SALT: unique symbol;
+/**
+ * A salt as a caller expresses it: an explicit `uint128`, or {@link NO_SALT} to opt out of salting.
+ */
+type SaltInput = bigint | typeof NO_SALT;
+/**
+ * A cryptographically random 128-bit salt — what {@link CreateEntityParameters.salt} defaults to.
+ *
+ * The salt exists for unpredictability, not uniqueness: the per-owner nonce already guarantees
+ * distinct keys. Random bits mean only the creator can predict the key of an entity they are about
+ * to create, so nobody else can reference or squat it in advance.
+ *
+ * @throws {NoRandomSourceError} If the runtime has no `crypto.getRandomValues`.
+ */
+declare function randomSalt(): bigint;
+/**
+ * The key an entity will be created with, derived exactly as the engine derives it:
+ * `keccak256(domain ++ owner ++ nonce ++ salt)`.
+ *
+ * Deriving it client-side is what lets a batch compose: predict the key of a create, then have a
+ * later operation in the same transaction reference it, or store it as a `key` attribute on a
+ * sibling entity.
+ */
+declare function predictEntityKey({
+  owner,
+  nonce,
+  salt,
+  chainId
+}: {
+  /** The account creating the entity. */
+  owner: Address;
+  /**
+   * The owner's entity-nonce at creation time. Each create in a batch consumes one, so the *n*th
+   * create in a batch uses `nonce + n`.
+   */
+  nonce: bigint;
+  /** The salt the create will carry, or {@link NO_SALT} if it carries none. */
+  salt: SaltInput;
+  /** The chain the entity is being created on — half of the derivation domain. */
+  chainId: number;
+}): Hex;
+//#endregion
+//#region src/entity/errors.d.ts
+/** An expiry could not be expressed, or would be rejected by the engine. */
+declare class InvalidExpiryError extends Error {
+  constructor(reason: string);
+}
+/** A `creationFlags` byte could not be built or read. */
+declare class InvalidCreationFlagsError extends Error {
+  constructor(reason: string);
+}
+/** A key salt was outside the `uint128` the wire carries. */
+declare class InvalidSaltError extends Error {
+  constructor(salt: unknown);
+}
+/** No cryptographic randomness was available to generate a salt. */
+declare class NoRandomSourceError extends Error {
+  constructor();
+}
+//#endregion
+//#region src/entity/events.d.ts
+/**
+ * The events the engine emits: one per applied operation, in application order, so an off-chain
+ * replica can replay a transaction operation by operation.
+ */
+declare const ENTITY_EVENTS_ABI: readonly [{
+  readonly name: "EntityCreated";
+  readonly type: "event";
+  readonly inputs: readonly [{
+    readonly type: "bytes32";
+    readonly name: "entityKey";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "owner";
+    readonly indexed: true;
+  }, {
+    readonly type: "uint64";
+    readonly name: "expiresAt";
+  }, {
+    readonly type: "uint8";
+    readonly name: "creationFlags";
+  }];
+}, {
+  readonly name: "EntityPatched";
+  readonly type: "event";
+  readonly inputs: readonly [{
+    readonly type: "bytes32";
+    readonly name: "entityKey";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "owner";
+    readonly indexed: true;
+  }];
+}, {
+  readonly name: "ExpiryExtended";
+  readonly type: "event";
+  readonly inputs: readonly [{
+    readonly type: "bytes32";
+    readonly name: "entityKey";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "owner";
+    readonly indexed: true;
+  }, {
+    readonly type: "uint64";
+    readonly name: "expiresAt";
+  }];
+}, {
+  readonly name: "OwnershipTransferred";
+  readonly type: "event";
+  readonly inputs: readonly [{
+    readonly type: "bytes32";
+    readonly name: "entityKey";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "previousOwner";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "newOwner";
+    readonly indexed: true;
+  }];
+}, {
+  readonly name: "EntityDeleted";
+  readonly type: "event";
+  readonly inputs: readonly [{
+    readonly type: "bytes32";
+    readonly name: "entityKey";
+    readonly indexed: true;
+  }, {
+    readonly type: "address";
+    readonly name: "owner";
+    readonly indexed: true;
+  }];
+}];
+/** The name of each event in {@link ENTITY_EVENTS_ABI}. */
+type EntityEventName = (typeof ENTITY_EVENTS_ABI)[number]["name"];
+//#endregion
+//#region src/entity/params.d.ts
+/**
+ * Max uint64 value
+ */
+declare const MAX_EXPIRES_AT: bigint;
+/** The operation tags of the `execute` ABI's tagged union. */
+declare const OperationType: {
+  readonly Create: 1;
+  readonly Patch: 2;
+  readonly ExtendExpiry: 3;
+  readonly TransferOwnership: 4;
+  readonly Delete: 5;
+};
+type OperationType = (typeof OperationType)[keyof typeof OperationType];
+//#endregion
+export { InvalidCreationFlagsError as a, NoRandomSourceError as c, SaltInput as d, predictEntityKey as f, EntityEventName as i, MAX_SALT as l, Operation as m, OperationType as n, InvalidExpiryError as o, randomSalt as p, ENTITY_EVENTS_ABI as r, InvalidSaltError as s, MAX_EXPIRES_AT as t, NO_SALT as u };
+//# sourceMappingURL=index-DZxwz2Ky.d.cts.map

package/dist/index-DZxwz2Ky.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DZxwz2Ky.d.cts","names":[],"sources":["../src/entity/operations.ts","../src/entity/key.ts","../src/entity/errors.ts","../src/entity/events.ts","../src/entity/params.ts"],"sourcesContent":[],"mappings":";;;;;KAiDY,SAAA;;iBAEK;;;;;cC7CJ;AD2Cb;;;;AC3CA;AAOa,cAAA,OAA2B,EAAA,OAAA,MAAA;AAKxC;AAWA;AAkCA;AACE,KA9CU,SAAA,GA8CV,MAAA,GAAA,OA9CsC,OA8CtC;;;;;;;;;;iBAnCc,UAAA,CAAA;;AEvBhB;AASA;;;;ACZA;AAGA;AAQY,iBHiDI,gBAAA,CGjDoB;EAAA,KAA4B;EAAA,KAAA;EAAA,IAAa;EAAA;CAAA,EAAA;;SHwDpE;;;;;;;QAOD;;;IAGJ;;;;cC/ES,kBAAA,SAA2B,KAAA;;AFgDxC;;cExCa,yBAAA,SAAkC,KAAA;;ADH/C;AAOA;AAKY,cCDC,gBAAA,SAAyB,KAAA,CDCS;EAW/B,WAAA,CAAA,IAAU,EAAA,OAAA;AAkC1B;;AAEE,cCpCW,mBAAA,SAA4B,KAAA,CDoCvC;EACA,WAAA,CAAA;;;;;;;ADjBF;cG3Ca;;;EFAA,SAAA,MAA0B,EAAA,SAAA,CAAA;IAO1B,SAA2B,IAAA,EAAA,SAAA;IAK5B,SAAS,IAAA,EAAA,WAAmB;IAWxB,SAAU,OAAA,EAAA,IAAA;EAkCV,CAAA,EAAA;IACd,SAAA,IAAA,EAAA,SAAA;IACA,SAAA,IAAA,EAAA,OAAA;IACA,SAAA,OAAA,EAAA,IAAA;EACA,CAAA,EAAA;IAGO,SAAA,IAAA,EAAA,QAAA;IAOD,SAAA,IAAA,EAAA,WAAA;EAGJ,CAAA,EAAA;IAAG,SAAA,IAAA,EAAA,OAAA;;;;EC/EM,SAAA,IAAA,EAAA,eAAmB;EAQnB,SAAA,IAAA,EAAA,OAAA;EAQA,SAAA,MAAA,EAAA,SAAiB,CAAA;IAYjB,SAAA,IAAA,EAAA,SAAoB;;;;ICvBpB,SAAA,IAAA,EAAA,SAMX;IAGU,SAAA,IAAA,EAAe,OAAA;;;;ECZd,SAAA,IAAA,EAAA,gBAA+B;EAG/B,SAAA,IAAA,EAAA,OAMH;EAEE,SAAA,MAAA,EAAa,SAAA,CAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KDCxB,eAAA,WAA0B;;;;;;AHkC1B,cI9CC,cJgDO,EAAA,MAAA;;cI7CP;;EHAA,SAAA,KAA0B,EAAA,CAAA;EAO1B,SAAA,YAA2B,EAAA,CAAA;EAK5B,SAAA,iBAA4B,EAAA,CAAA;EAWxB,SAAA,MAAU,EAAA,CAAA;AAkC1B,CAAA;AACE,KGlDU,aAAA,GHkDV,CAAA,OGlDkC,aHkDlC,CAAA,CAAA,MAAA,OGlD8D,aHkD9D,CAAA"}