@arkiv-network/sdk 0.7.0 → 0.8.0-dev.1

package/dist/index-DVYFaXNV.d.ts

@@ -0,0 +1,417 @@
+import { Address, Hex } from "viem";
+
+//#region src/attr/types.d.ts
+
+/**
+ * The protocol's attribute type vocabulary, mapping each short **tag** (the name used by the
+ * client, the query language and this SDK) to its **typeId** (the byte carried on the wire and in
+ * the entity record).
+ *
+ * The typeIds are consensus-critical: they are written into entity records and mixed into index
+ * keys, so this table must never drift from the node's `AttributeType`.
+ *
+ * | tag       | typeId | ABI wire type       | indexing          |
+ * | --------- | ------ | ------------------- | ----------------- |
+ * | `bool`    | 1      | `bool`              | equality          |
+ * | `i32`     | 2      | `int32`             | equality + range  |
+ * | `u64`     | 3      | `uint64`            | equality + range  |
+ * | `u256`    | 4      | `uint256`           | equality + range  |
+ * | `dec`     | 5      | `int256` (18 dp)    | equality + range  |
+ * | `bytes32` | 6      | `bytes32`           | equality          |
+ * | `bytes`   | 7      | `bytes`             | none — system-only |
+ * | `str`     | 8      | `string` (<= 128 B) | equality + prefix |
+ * | `addr`    | 9      | `address`           | equality          |
+ * | `key`     | 10     | `bytes32`           | equality          |
+ */
+declare const TYPE_IDS: {
+  readonly bool: 1;
+  readonly i32: 2;
+  readonly u64: 3;
+  readonly u256: 4;
+  readonly dec: 5;
+  readonly bytes32: 6;
+  readonly bytes: 7;
+  readonly str: 8;
+  readonly addr: 9;
+  readonly key: 10;
+};
+/** Every type tag, including the system-only `bytes`. */
+type TypeTag = keyof typeof TYPE_IDS;
+/**
+ * The tags a client may set on an attribute. `bytes` is excluded: it backs the system `$payload`
+ * cell, which travels in its own operation field and is never carried in an attribute array.
+ */
+type UserTypeTag = Exclude<TypeTag, "bytes">;
+/**
+ * Marks a value as having passed its constructor's validation. The symbol is module-private, so a
+ * hand-written object literal is not assignable to {@link ArkivValue} — every value crossing the
+ * wire has been range-, length- and format-checked by {@link i32}, {@link u256}, {@link dec}, and
+ * friends.
+ */
+declare const validated: unique symbol;
+/**
+ * A typed attribute value: the tag it was created with, plus the JavaScript representation of that
+ * type. Constructed only by the tagged constructors in `@arkiv-network/sdk/attr`.
+ *
+ * @typeParam tag - The type tag, which also discriminates the {@link ArkivValue} union.
+ * @typeParam value - The decoded JavaScript representation.
+ */
+type Value<tag extends TypeTag, value> = {
+  readonly type: tag;
+  readonly value: value;
+  readonly [validated]: tag;
+};
+/** A boolean. */
+type BoolValue = Value<"bool", boolean>;
+/** A 32-bit signed integer — the default for an untagged number. */
+type I32Value = Value<"i32", number>;
+/**
+ * A 64-bit unsigned integer — block heights, the
+ * entity-nonce and `$expiresAt` are all `u64` */
+type U64Value = Value<"u64", bigint>;
+/** A 256-bit unsigned integer. */
+type U256Value = Value<"u256", bigint>;
+/**
+ * A fixed-point decimal with 18 decimal places, held as its canonical decimal string (`"3.5"`).
+ * Use {@link decUnits} for the exact scaled integer when you need to do arithmetic.
+ */
+type DecValue = Value<"dec", string>;
+/** 32 opaque bytes, as lowercase `0x` hex. */
+type Bytes32Value = Value<"bytes32", Hex>;
+/** A UTF-8 string of at most 128 bytes. */
+type StrValue = Value<"str", string>;
+/** A 20-byte Ethereum address, as EIP-55 checksummed hex. */
+type AddrValue = Value<"addr", Address>;
+/** A reference to another entity. Weak by spec: dangling references are permitted. */
+type KeyValue = Value<"key", Hex>;
+/**
+ * Opaque variable-length bytes, as lowercase `0x` hex. System-only — it backs `$payload` and is
+ * never settable as an attribute, so it is produced by decoding but has no constructor.
+ */
+type BytesValue = Value<"bytes", Hex>;
+/** Any value a client may set on an attribute. */
+type ArkivValue = BoolValue | I32Value | U64Value | U256Value | DecValue | Bytes32Value | StrValue | AddrValue | KeyValue;
+/** Any value that can come back from the node, including the system-only `bytes`. */
+type AnyArkivValue = ArkivValue | BytesValue;
+/**
+ * Whether `input` has the *shape* of an {@link ArkivValue} — a known type tag and a value.
+ */
+declare function isArkivValue(input: unknown): input is AnyArkivValue;
+//#endregion
+//#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.
+ *
+ * @throws {InvalidValueError} If the string 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;
+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 ValueInput}) 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, Bytes32Value as B, ValueInput as C, dec as D, bytes32 as E, u64 as F, StrValue as G, DecValue as H, AddrValue as I, U64Value as J, TypeTag as K, AnyArkivValue as L, str as M, toValue as N, decFromUnits as O, u256 as P, ArkivValue as R, U64_MAX as S, bool as T, I32Value as U, BytesValue as V, KeyValue as W, isArkivValue as X, UserTypeTag as Y, 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, U256Value as q, 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, BoolValue as z };
+//# sourceMappingURL=index-DVYFaXNV.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-DVYFaXNV.d.ts","names":[],"sources":["../src/attr/types.ts","../src/attr/values.ts","../src/attr/attributes.ts","../src/attr/decimal.ts","../src/attr/errors.ts","../src/attr/names.ts"],"sourcesContent":[],"mappings":";;;;;;AAuBA;AAcA;AASA;AAKC;AAiBD;;;;;;;AAOA;AAEA;AAIA;AAEA;AAKA;AAEA;AAEA;AAEA;AAEY,cAzEC,QAyEuB,EAAA;EAKxB,SAAA,IAAU,EAAA,CAAA;EAGV,SAAA,GAAA,EAAU,CAAA;EAClB,SAAA,GAAA,EAAA,CAAA;EACA,SAAA,IAAA,EAAA,CAAA;EACA,SAAA,GAAA,EAAA,CAAA;EACA,SAAA,OAAA,EAAA,CAAA;EACA,SAAA,KAAA,EAAA,CAAA;EACA,SAAA,GAAA,EAAA,CAAA;EACA,SAAA,IAAA,EAAA,CAAA;EACA,SAAA,GAAA,EAAA,EAAA;CACA;;AAGQ,KA/EA,OAAA,GA+Ea,MAAA,OA/EU,QA+EP;;;ACvF5B;AAEA;AAEa,KDaD,WAAA,GAAc,OCbW,CDaH,OCbG,EAAA,OAAA,CAAA;AA4BrC;AAkBA;AA8CA;AAoBA;AAgFA;AA6BA;AAUA,cD7Mc,SC6Mc,EAAA,OAAiB,MAAA;AAc7C;AAwCA;AA8BA;;;;;AAgBgB,KDxSJ,KCwSW,CAAA,YDxSO,OCwSP,EAAA,KAAA,CAAA,GAAA;EAAQ,SAAA,IAAA,EDvSd,GCuSc;EAAM,SAAA,KAAA,EDtSnB,KCsSmB;EAAa,UDrStC,SAAA,CCqSsC,EDrS1B,GCqS0B;CAAY;AA4C9D;AAqBgB,KDlWJ,SAAA,GAAY,KCkWO,CAAA,MAAA,EAAqC,OAAA,CAAA;;KDhWxD,QAAA,GAAW;;AEnEvB;AAEA;AAuBY,KF8CA,QAAA,GAAW,KE9CI,CAAA,KAAA,EAAA,MAAA,CAAA;;AAAY,KFgD3B,SAAA,GAAY,KEhDe,CAAA,MAAA,EAAA,MAAA,CAAA;;;AAQvC;;AAAkC,KF6CtB,QAAA,GAAW,KE7CW,CAAA,KAAA,EAAA,MAAA,CAAA;;AAAD,KF+CrB,YAAA,GAAe,KE/CM,CAAA,SAAA,EF+CW,GE/CX,CAAA;AASjC;AAAsD,KFwC1C,QAAA,GAAW,KExC+B,CAAA,KAAA,EAAA,MAAA,CAAA;;AAAxB,KF0ClB,SAAA,GAAY,KE1CM,CAAA,MAAA,EF0CQ,OE1CR,CAAA;;KF4ClB,QAAA,GAAW,aAAa;;;AG1FpC;AAGA;KH4FY,UAAA,GAAa,eAAe;;KAG5B,UAAA,GACR,YACA,WACA,WACA,YACA,WACA,eACA,WACA,YACA;AIxGJ;AAEgB,KJyGJ,aAAA,GAAgB,UIzGZ,GJyGyB,UIzGzB;;ACRhB;AAmDA;AA4CgB,iBLwCA,YAAA,CKxCoB,KAAA,EAAA,OAAA,CAAA,EAAA,KAAA,ILwCmB,aKxCnB;;;;AL3EvB,cCMA,OAAA,GDKH,UAAA;AAGV;AASY,cCfC,OAAA,GDeqB,CAAA,UAAR;AAKzB;AAiBW,cCnCC,ODmCI,EAAA,MAAA;;AACA,cClCJ,QDkCI,EAAA,MAAA;;;;AAEI,cChCR,gBAAA,GDgCQ,GAAA;AAIrB;AAEA;AAIA;AAEA;AAKA;AAEA;AAEA;AAEA;AAEA;AAKY,iBCxCI,IAAA,CDwCwB,KAAf,EAAA,OAAK,CAAA,ECxCQ,SDwCR;AAG9B;;;;;;;;;;;AAYY,iBCrCI,GAAA,CDqCS,KAAG,EAAA,MAAA,GAAa,MAAA,CAAA,ECrCI,QDqCM;AAsBnD;;;;AC7GA;AAEA;AAEA;AAEA;AAIA;AAsBA;AAkBA;AA8CA;AAoBA;AAgFA;AA6BgB,iBAjIA,IAAA,CAiIgB,KAAA,EAAQ,MAAA,GAAA,MAAA,GAAA,MAAA,CAAA,EAjIe,SAiIf;AAUxC;AAcA;AAwCA;AA8BA;;;;;AAgBA;;;;;AA4CA;AAqBA;;iBA5RgB,GAAA,mCAAsC;;ACvItD;AAEA;AAuBA;;;;;AAQA;;;;;AASA;;;;;iBD6KgB,GAAA,mCAAsC;;;AE3NtD;AAGA;;;;ACAA;AAEgB,iBHmPA,QAAA,CGnPA,KAAA,EHmPgB,QGnPhB,CAAA,EAAA,MAAA;;;;AAiBhB;AAqBA;AAoBA;AAgBa,iBHmLG,YAAA,CGnLsB,KAAA,EAAQ,MAAK,CAAA,EHmLN,QGnLM;AAenD;AAQA;;;;ACzGA;AAmDA;AA4CA;;;iBJoLgB,GAAA,iBAAoB;;;;;;;;;;;;;iBAwCpB,IAAA,iBAAqB;;;;;;;;;;;;;iBA8BrB,GAAA,QAAW,MAAM,aAAa;;;;;;;;;;;;;iBAgB9B,OAAA,QAAe,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;KA4CtC,UAAA,GAAa;;;;;;;;;;;;;;;;;;;;iBAqBT,OAAA,QAAe,qCAAqC;;;ADtZpE;AAcA;AASA;AAac,cEjDD,cAAA,GFiDyB,EAAA;AAS1B,cExDC,iBFwDI,EAAA,MAAA;;;;;;;AAOjB;AAEA;AAIA;AAEA;AAKA;AAEA;AAEA;AAEA;AAEA;AAKA;AAGY,KErEA,eAAA,GAAkB,QFqER,CErEiB,MFqEjB,CAAA,MAAA,EErEgC,UFqEhC,CAAA,CAAA;;;;;;;AAOlB,KEpEQ,UAAA,GAAa,QFoErB,CEpE8B,MFoE9B,CAAA,MAAA,EEpE6C,aFoE7C,CAAA,CAAA;;;;AAKJ;AAsBA;;;KEtFY,eAAA,GAAkB,SAAS,eAAe;;;;;;AF7BtD;AAcY,cG/BC,aAAA,GH+B8B,EAAA;AAS3C;AAac,cGlDD,YHkDyB,EAAA,MAAA;;;;;AApCtC;AAcA;AASA;AAKC;AAiBD;AAA8B,cI3DjB,iBAAA,SAA0B,KAAA,CJ2DT;EACb;EACC,SAAA,GAAA,EI3DF,OJ2DE;EACM;EAAZ,SAAA,KAAA,EAAA,OAAA;EAAS,WAAA,CAAA,GAAA,EIxDF,OJwDE,EAAA,KAAA,EAAA,OAAA,EAAA,MAAA,EAAA,MAAA,EAAA,IAAA,CAAA,EAAA,MAAA;AAIrB;AAEA;AAIA;AAEA;AAKA;AAEA;AAEY,cIhEC,iBAAA,SAA0B,KAAA,CJgEX;EAEhB,SAAA,KAAS,EAAA,OAAA;EAET,WAAQ,CAAA,KAAA,EAAA,OAAgB;AAKpC;AAGA;;;;;;;AAOI,cI9DS,iBAAA,SAA0B,KAAA,CJ8DnC;EACA;EACA,SAAA,aAAA,EAAA,MAAA,GAAA,SAAA;EAAQ,WAAA,CAAA,KAAA,EAAA,IAAA,GAAA,SAAA,EAAA,aAAA,CAAA,EAAA,MAAA;AAGZ;AAsBA;cIrEa,yBAAA,SAAkC,KAAA;;;AHxC/C;AAEA;AAEA;AAEA;AAIa,cG8CA,wBAAA,SAAiC,KAAA,CH9CjB;EAsBb,SAAI,aAAkB,EAAA,MAAS;EAkB/B,WAAG,CAAA,aAA0B,EAAQ,MAAA;AA8CrD;AAoBA;AAgFgB,cG7HH,sBAAA,SAA+B,KAAA,CH6HkB;EA6B9C,WAAQ,CAAA,KAAA,EAAA,MAAQ,EAAA,GAAA,EAAQ,MAAA;AAUxC;AAcA;AAwCgB,cGlNH,yBAAA,SAAkC,KAAA,CHkND;EA8B9B;EAAW,SAAA,IAAA,EAAA,MAAA,GAAA,MAAA;EAAM,WAAA,CAAA,IAAA,EAAA,MAAA,GAAA,MAAA;;;;;cIzVpB,cAAA;;ALoBb;AAcA;AASA;AAKC;AAiBD;;;AAEkB,iBKhBF,qBAAA,CLgBE,IAAA,EAAA,MAAA,CAAA,EAAA,IAAA;;AACN,iBK2BI,oBAAA,CL3BJ,IAAA,EAAA,MAAA,CAAA,EAAA,OAAA"}