@aptos-labs/ts-sdk 6.3.1 → 7.0.0

package/dist/core/accountAddress.js

@@ -0,0 +1,457 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
+import { Serializable, serializeEntryFunctionBytesCompat } from "../bcs/serializer.js";
+import { ParsingError } from "./common.js";
+import { ScriptTransactionArgumentVariants } from "../types/index.js";
+/**
+ * Provides reasons for an address was invalid.
+ * @group Implementation
+ * @category Serialization
+ */
+export var AddressInvalidReason;
+(function (AddressInvalidReason) {
+    AddressInvalidReason["INCORRECT_NUMBER_OF_BYTES"] = "incorrect_number_of_bytes";
+    AddressInvalidReason["INVALID_HEX_CHARS"] = "invalid_hex_chars";
+    AddressInvalidReason["TOO_SHORT"] = "too_short";
+    AddressInvalidReason["TOO_LONG"] = "too_long";
+    AddressInvalidReason["LEADING_ZERO_X_REQUIRED"] = "leading_zero_x_required";
+    AddressInvalidReason["LONG_FORM_REQUIRED_UNLESS_SPECIAL"] = "long_form_required_unless_special";
+    AddressInvalidReason["INVALID_PADDING_ZEROES"] = "INVALID_PADDING_ZEROES";
+    AddressInvalidReason["INVALID_PADDING_STRICTNESS"] = "INVALID_PADDING_STRICTNESS";
+})(AddressInvalidReason || (AddressInvalidReason = {}));
+/**
+ * NOTE: Only use this class for account addresses. For other hex data, e.g. transaction
+ * hashes, use the Hex class.
+ *
+ * AccountAddress is used for working with account addresses. Account addresses, when
+ * represented as a string, generally look like these examples:
+ * - 0x1
+ * - 0xaa86fe99004361f747f91342ca13c426ca0cccb0c1217677180c9493bad6ef0c
+ *
+ * Proper formatting and parsing of account addresses is defined by AIP-40.
+ * To learn more about the standard, read the AIP here:
+ * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+ *
+ * The comments in this class make frequent reference to the LONG and SHORT formats,
+ * as well as "special" addresses. To learn what these refer to see AIP-40.
+ * @group Implementation
+ * @category Serialization
+ */
+export class AccountAddress extends Serializable {
+    /**
+     * This is the internal representation of an account address.
+     * @group Implementation
+     * @category Serialization
+     */
+    data;
+    /**
+     * The number of bytes that make up an account address.
+     * @group Implementation
+     * @category Serialization
+     */
+    static LENGTH = 32;
+    /**
+     * The length of an address string in LONG form without a leading 0x.
+     * @group Implementation
+     * @category Serialization
+     */
+    static LONG_STRING_LENGTH = 64;
+    static ZERO = AccountAddress.from("0x0");
+    static ONE = AccountAddress.from("0x1");
+    static TWO = AccountAddress.from("0x2");
+    static THREE = AccountAddress.from("0x3");
+    static FOUR = AccountAddress.from("0x4");
+    static A = AccountAddress.from("0xA");
+    /**
+     * Creates an instance of AccountAddress from a Uint8Array.
+     *
+     * This function ensures that the input data is exactly 32 bytes long, which is required for a valid account address.
+     *
+     * @param input A Uint8Array representing an account address.
+     * @throws ParsingError if the input length is not equal to 32 bytes.
+     * @group Implementation
+     * @category Serialization
+     */
+    constructor(input) {
+        super();
+        if (input.length !== AccountAddress.LENGTH) {
+            throw new ParsingError("AccountAddress data should be exactly 32 bytes long", AddressInvalidReason.INCORRECT_NUMBER_OF_BYTES);
+        }
+        this.data = input;
+    }
+    /**
+     * Determines if the address is classified as special, which is defined as 0x0 to 0xf inclusive.
+     * In other words, the last byte of the address must be < 0b10000 (16)
+     * and every other byte must be zero.
+     *
+     * For more information on how special addresses are defined, see AIP-40:
+     * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+     *
+     * @returns true if the address is special, false otherwise.
+     * @group Implementation
+     * @category Serialization
+     */
+    isSpecial() {
+        return (this.data.slice(0, this.data.length - 1).every((byte) => byte === 0) && this.data[this.data.length - 1] < 0b10000);
+    }
+    // ===
+    // Methods for representing an instance of AccountAddress as other types.
+    // ===
+    /**
+     * Return the AccountAddress as a string as per AIP-40.
+     * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+     * This representation returns special addresses in SHORT form (0xf)
+     * and other addresses in LONG form (0x + 64 characters).
+     *
+     * @returns AccountAddress as a string conforming to AIP-40.
+     * @group Implementation
+     * @category Serialization
+     */
+    toString() {
+        return `0x${this.toStringWithoutPrefix()}`;
+    }
+    /**
+     * Return the AccountAddress as a string conforming to AIP-40 but without the leading 0x.
+     *
+     * NOTE: Prefer to use `toString` where possible.
+     *
+     * @returns AccountAddress as a string without the leading 0x.
+     * @group Implementation
+     * @category Serialization
+     */
+    toStringWithoutPrefix() {
+        let hex = bytesToHex(this.data);
+        if (this.isSpecial()) {
+            hex = hex[hex.length - 1];
+        }
+        return hex;
+    }
+    /**
+     * Convert the account address to a string in LONG format, which is always 0x followed by 64 hex characters.
+     *
+     * NOTE: Prefer to use `toString` where possible, as it formats special addresses using the SHORT form (no leading 0s).
+     *
+     * @returns AccountAddress as a string in LONG form.
+     * @group Implementation
+     * @category Serialization
+     */
+    toStringLong() {
+        return `0x${this.toStringLongWithoutPrefix()}`;
+    }
+    /**
+     * Returns the account address as a string in LONG form without a leading 0x.
+     * This function will include leading zeroes and will produce a string of 64 hex characters.
+     *
+     * NOTE: Prefer to use `toString` where possible, as it formats special addresses using the SHORT form (no leading 0s).
+     *
+     * @returns {string} The account address in LONG form.
+     * @group Implementation
+     * @category Serialization
+     */
+    toStringLongWithoutPrefix() {
+        return bytesToHex(this.data);
+    }
+    /**
+     * Convert the account address to a string in SHORT format, which is 0x followed by the shortest
+     * possible representation (no leading zeros).
+     *
+     * @returns AccountAddress as a string in SHORT form.
+     * @group Implementation
+     * @category Serialization
+     */
+    toStringShort() {
+        return `0x${this.toStringShortWithoutPrefix()}`;
+    }
+    /**
+     * Returns a lossless short string representation of the address by trimming leading zeros.
+     * If the address consists of all zeros, returns "0".
+     *
+     * @returns A string representation of the address without leading zeros
+     * @group Implementation
+     * @category Serialization
+     */
+    toStringShortWithoutPrefix() {
+        const hex = bytesToHex(this.data).replace(/^0+/, "");
+        return hex === "" ? "0" : hex;
+    }
+    /**
+     * Get the inner data as a Uint8Array.
+     * The inner data is already a Uint8Array, so no conversion takes place.
+     *
+     * @returns Hex data as Uint8Array
+     * @group Implementation
+     * @category Serialization
+     */
+    toUint8Array() {
+        return this.data;
+    }
+    /**
+     * Serialize the AccountAddress to a Serializer instance's data buffer.
+     * @param serializer The serializer to serialize the AccountAddress to.
+     * @returns void
+     * @example
+     * const serializer = new Serializer();
+     * const address = AccountAddress.fromString("0x1");
+     * address.serialize(serializer);
+     * const bytes = serializer.toUint8Array();
+     * // `bytes` is now the BCS-serialized address.
+     * @group Implementation
+     * @category Serialization
+     */
+    serialize(serializer) {
+        serializer.serializeFixedBytes(this.data);
+    }
+    /**
+     * Serializes the current instance into a byte sequence suitable for entry functions.
+     * This allows for the proper encoding of data when interacting with entry functions in the blockchain.
+     * Uses serializeAsBytes when available, with a fallback for older Serializer versions.
+     *
+     * @param serializer - The serializer instance used to convert the data into bytes.
+     * @group Implementation
+     * @category Serialization
+     */
+    serializeForEntryFunction(serializer) {
+        serializeEntryFunctionBytesCompat(serializer, this);
+    }
+    /**
+     * Serializes the current instance for use in a script function by encoding it into a byte sequence.
+     * This process involves serializing the variant index and the instance data, making it suitable for transmission.
+     *
+     * @param serializer - The serializer instance used to perform the serialization.
+     * @group Implementation
+     * @category Serialization
+     */
+    serializeForScriptFunction(serializer) {
+        serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.Address);
+        serializer.serialize(this);
+    }
+    /**
+     * Deserialize an AccountAddress from the byte buffer in a Deserializer instance.
+     * This function allows you to convert a byte representation of an AccountAddress into an instance of AccountAddress.
+     * @param deserializer The deserializer to deserialize the AccountAddress from.
+     * @returns An instance of AccountAddress.
+     * @example
+     * const bytes = hexToBytes("0x0102030405060708091011121314151617181920212223242526272829303132");
+     * const deserializer = new Deserializer(bytes);
+     * const address = AccountAddress.deserialize(deserializer);
+     * // `address` is now an instance of AccountAddress.
+     * @group Implementation
+     * @category Serialization
+     */
+    static deserialize(deserializer) {
+        const bytes = deserializer.deserializeFixedBytes(AccountAddress.LENGTH);
+        return new AccountAddress(bytes);
+    }
+    // ===
+    // Methods for creating an instance of AccountAddress from other types.
+    // ===
+    /**
+     * NOTE: This function has strict parsing behavior. For relaxed behavior, please use
+     * the `fromString` function.
+     *
+     * Creates an instance of AccountAddress from a hex string.
+     *
+     * This function allows only the strictest formats defined by AIP-40. In short this
+     * means only the following formats are accepted:
+     *
+     * - LONG
+     * - SHORT for special addresses
+     *
+     * Where:
+     * - LONG is defined as 0x + 64 hex characters.
+     * - SHORT for special addresses is 0x0 to 0xf inclusive without padding zeroes.
+     *
+     * This means the following are not accepted:
+     * - SHORT for non-special addresses.
+     * - Any address without a leading 0x.
+     *
+     * @param input - A hex string representing an account address.
+     *
+     * @throws {ParsingError} If the hex string does not start with 0x or is not in a valid format.
+     *
+     * @remarks
+     *
+     * This function has strict parsing behavior. For relaxed behavior, please use the `fromString` function.
+     *
+     * @see AIP-40 documentation for more details on address formats:
+     * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+     *
+     * @returns An instance of AccountAddress.
+     * @group Implementation
+     * @category Serialization
+     */
+    static fromStringStrict(input) {
+        // Assert the string starts with 0x.
+        if (!input.startsWith("0x")) {
+            throw new ParsingError("Hex string must start with a leading 0x.", AddressInvalidReason.LEADING_ZERO_X_REQUIRED);
+        }
+        const address = AccountAddress.fromString(input);
+        // Check if the address is in LONG form. If it is not, this is only allowed for
+        // special addresses, in which case we check it is in proper SHORT form.
+        if (input.length !== AccountAddress.LONG_STRING_LENGTH + 2) {
+            if (!address.isSpecial()) {
+                throw new ParsingError(`The given hex string ${input} is not a special address, it must be represented as 0x + 64 chars.`, AddressInvalidReason.LONG_FORM_REQUIRED_UNLESS_SPECIAL);
+            }
+            else if (input.length !== 3) {
+                // 0x + one hex char is the only valid SHORT form for special addresses.
+                throw new ParsingError(`The given hex string ${input} is a special address not in LONG form, it must be 0x0 to 0xf without padding zeroes.`, AddressInvalidReason.INVALID_PADDING_ZEROES);
+            }
+        }
+        return address;
+    }
+    /**
+     * NOTE: This function has relaxed parsing behavior. For strict behavior, please use
+     * the `fromStringStrict` function. Where possible use `fromStringStrict` rather than this
+     * function, `fromString`.
+     *
+     * Creates an instance of AccountAddress from a hex string.
+     *
+     * This function allows all formats defined by AIP-40. In short this means the
+     * following formats are accepted:
+     *
+     * - LONG, with or without leading 0x
+     * - SHORT*, with or without leading 0x
+     *
+     * Where:
+     * - LONG is 64 hex characters.
+     * - SHORT* is 1 to 63 hex characters inclusive. The address can have missing values up to `maxMissingChars` before it is padded.
+     * - Padding zeroes are allowed, e.g. 0x0123 is valid.
+     *
+     * Learn more about the different address formats by reading AIP-40:
+     * https://github.com/aptos-foundation/AIPs/blob/main/aips/aip-40.md.
+     *
+     * @param input A hex string representing an account address.
+     * @param args.maxMissingChars The number of characters that can be missing in a padded address before it is invalid.
+     *
+     * @returns An instance of AccountAddress.
+     *
+     * @throws ParsingError if the hex string is too short, too long, or contains invalid characters.
+     * @group Implementation
+     * @category Serialization
+     */
+    static fromString(input, { maxMissingChars = 4 } = {}) {
+        let parsedInput = input;
+        // Remove leading 0x for parsing.
+        if (input.startsWith("0x")) {
+            parsedInput = input.slice(2);
+        }
+        // Ensure the address string is at least 1 character long.
+        if (parsedInput.length === 0) {
+            throw new ParsingError("Hex string is too short, must be 1 to 64 chars long, excluding the leading 0x.", AddressInvalidReason.TOO_SHORT);
+        }
+        // Ensure the address string is not longer than 64 characters.
+        if (parsedInput.length > 64) {
+            throw new ParsingError("Hex string is too long, must be 1 to 64 chars long, excluding the leading 0x.", AddressInvalidReason.TOO_LONG);
+        }
+        // Ensure that the maxMissingChars is between or equal to 0 and 63.
+        if (maxMissingChars > 63 || maxMissingChars < 0) {
+            throw new ParsingError(`maxMissingChars must be between or equal to 0 and 63. Received ${maxMissingChars}`, AddressInvalidReason.INVALID_PADDING_STRICTNESS);
+        }
+        let addressBytes;
+        try {
+            // Pad the address with leading zeroes, so it is 64 chars long and then convert
+            // the hex string to bytes. Every two characters in a hex string constitutes a
+            // single byte. So a 64 length hex string becomes a 32 byte array.
+            addressBytes = hexToBytes(parsedInput.padStart(64, "0"));
+        }
+        catch (error) {
+            // At this point the only way this can fail is if the hex string contains
+            // invalid characters.
+            throw new ParsingError(`Hex characters are invalid: ${error?.message}`, AddressInvalidReason.INVALID_HEX_CHARS);
+        }
+        const address = new AccountAddress(addressBytes);
+        // Cannot pad the address if it has more than maxMissingChars missing.
+        if (parsedInput.length < 64 - maxMissingChars) {
+            if (!address.isSpecial()) {
+                throw new ParsingError(`Hex string is too short, must be ${64 - maxMissingChars} to 64 chars long, excluding the leading 0x. You may need to fix 
+the addresss by padding it with 0s before passing it to \`fromString\` (e.g. <addressString>.padStart(64, '0')). 
+Received ${input}`, AddressInvalidReason.TOO_SHORT);
+            }
+        }
+        return address;
+    }
+    /**
+     * Convenience method for creating an AccountAddress from various input types.
+     * This function accepts a string, Uint8Array, or an existing AccountAddress instance and returns the corresponding
+     * AccountAddress.
+     *
+     * @param input - The input to convert into an AccountAddress. This can be a string representation of an address, a Uint8Array,
+     * or an existing AccountAddress.
+     * @param args.maxMissingChars The number of characters that can be missing in a padded address before it is invalid.
+     * @group Implementation
+     * @category Serialization
+     */
+    static from(input, { maxMissingChars = 4 } = {}) {
+        if (typeof input === "string") {
+            return AccountAddress.fromString(input, { maxMissingChars });
+        }
+        if (input instanceof Uint8Array) {
+            return new AccountAddress(input);
+        }
+        return input;
+    }
+    /**
+     * Create an AccountAddress from various input types, including strings, Uint8Array, and AccountAddress instances.
+     *
+     * @param input - The input to convert into an AccountAddress, which can be a string, a Uint8Array, or an AccountAddress.
+     * @group Implementation
+     * @category Serialization
+     */
+    static fromStrict(input) {
+        if (typeof input === "string") {
+            return AccountAddress.fromStringStrict(input);
+        }
+        if (input instanceof Uint8Array) {
+            return new AccountAddress(input);
+        }
+        return input;
+    }
+    // ===
+    // Methods for checking validity.
+    // ===
+    /**
+     * Check if the provided input is a valid AccountAddress.
+     *
+     * @param args - The arguments for validation.
+     * @param args.input - A hex string representing an account address.
+     * @param args.strict - If true, use strict parsing behavior; if false, use relaxed parsing behavior.
+     *
+     * @returns An object indicating whether the address is valid. If valid, valid = true; if not, valid = false with additional details.
+     * If the address is invalid, invalidReason will explain why it is invalid, and invalidReasonMessage will provide the error message.
+     * @group Implementation
+     * @category Serialization
+     */
+    static isValid(args) {
+        try {
+            if (args.strict) {
+                AccountAddress.fromStrict(args.input);
+            }
+            else {
+                AccountAddress.from(args.input);
+            }
+            return { valid: true };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                invalidReason: error?.invalidReason,
+                invalidReasonMessage: error?.message,
+            };
+        }
+    }
+    /**
+     * Determine if two AccountAddresses are equal based on their underlying byte data.
+     *
+     * @param other - The AccountAddress to compare to.
+     * @returns true if the AccountAddresses are equal, false if not.
+     * @group Implementation
+     * @category Serialization
+     */
+    equals(other) {
+        if (this.data.length !== other.data.length)
+            return false;
+        return this.data.every((value, index) => value === other.data[index]);
+    }
+}
+//# sourceMappingURL=accountAddress.js.map

package/dist/core/accountAddress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accountAddress.js","sourceRoot":"","sources":["../../src/core/accountAddress.ts"],"names":[],"mappings":"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"}

package/dist/core/authenticationKey.d.ts

@@ -0,0 +1,129 @@
+import { AccountAddress } from "./accountAddress.js";
+import type { AccountPublicKey } from "./crypto/index.js";
+import { Hex } from "./hex.js";
+import { AuthenticationKeyScheme, HexInput } from "../types/index.js";
+import { Serializable, Serializer } from "../bcs/serializer.js";
+import { Deserializer } from "../bcs/deserializer.js";
+/**
+ * Represents an authentication key used for account management. Each account stores an authentication key that enables account
+ * owners to rotate their private key(s) without changing the address that hosts their account. The authentication key is a
+ * SHA3-256 hash of data and is always 32 bytes in length.
+ *
+ * @see {@link https://aptos.dev/concepts/accounts | Account Basics}
+ *
+ * Account addresses can be derived from the AuthenticationKey.
+ * @group Implementation
+ * @category Serialization
+ */
+export declare class AuthenticationKey extends Serializable {
+    /**
+     * An authentication key is always a SHA3-256 hash of data, and is always 32 bytes.
+     *
+     * The data to hash depends on the underlying public key type and the derivation scheme.
+     * @group Implementation
+     * @category Serialization
+     */
+    static readonly LENGTH: number;
+    /**
+     * The raw bytes of the authentication key.
+     * @group Implementation
+     * @category Serialization
+     */
+    readonly data: Hex;
+    /**
+     * Creates an instance of the AuthenticationKey using the provided hex input.
+     * This ensures that the hex input is valid and conforms to the required length for an Authentication Key.
+     *
+     * @param args - The arguments for constructing the AuthenticationKey.
+     * @param args.data - The hex input data to be used for the Authentication Key.
+     * @throws {Error} Throws an error if the length of the provided hex input is not equal to the required Authentication Key
+     * length.
+     * @group Implementation
+     * @category Serialization
+     */
+    constructor(args: {
+        data: HexInput;
+    });
+    /**
+     * Serializes the authentication key as length-prefixed bytes (BCS `serde_bytes` encoding).
+     *
+     * @param serializer - The serializer instance used to perform the serialization.
+     * @group Implementation
+     * @category Serialization
+     */
+    serialize(serializer: Serializer): void;
+    /**
+     * Deserialize an AuthenticationKey from the byte buffer in a Deserializer instance.
+     * @param deserializer - The deserializer to deserialize the AuthenticationKey from.
+     * @returns An instance of AuthenticationKey.
+     * @group Implementation
+     * @category Serialization
+     */
+    static deserialize(deserializer: Deserializer): AuthenticationKey;
+    /**
+     * Override `Serializable.toString` (which would return the length-prefixed BCS hex) so the public
+     * representation stays the underlying 32-byte hex address — what callers compare against
+     * (REST `authentication_key`, indexer GraphQL filters, on-chain account address derivation).
+     */
+    toString(): string;
+    /**
+     * Convert the internal data representation to a Uint8Array.
+     *
+     * This function is useful for obtaining a byte representation of the data, which can be utilized for serialization or transmission.
+     *
+     * @returns Uint8Array representation of the internal data.
+     * @group Implementation
+     * @category Serialization
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Generates an AuthenticationKey from the specified scheme and input bytes.
+     * This function is essential for creating a valid authentication key based on a given scheme.
+     *
+     * @param args - The arguments for generating the AuthenticationKey.
+     * @param args.scheme - The authentication key scheme to use.
+     * @param args.input - The input data in hexadecimal format to derive the key.
+     * @returns An instance of AuthenticationKey containing the generated key data.
+     * @group Implementation
+     * @category Serialization
+     */
+    static fromSchemeAndBytes(args: {
+        scheme: AuthenticationKeyScheme;
+        input: HexInput;
+    }): AuthenticationKey;
+    /**
+     * Derives an AuthenticationKey from the provided public key using a specified derivation scheme.
+     *
+     * @deprecated Use `fromPublicKey` instead.
+     * @param args - The arguments for deriving the authentication key.
+     * @param args.publicKey - The public key used for the derivation.
+     * @param args.scheme - The scheme to use for deriving the authentication key.
+     * @group Implementation
+     * @category Serialization
+     */
+    static fromPublicKeyAndScheme(args: {
+        publicKey: AccountPublicKey;
+        scheme: AuthenticationKeyScheme;
+    }): AuthenticationKey;
+    /**
+     * Converts a PublicKey to an AuthenticationKey using the derivation scheme inferred from the provided PublicKey instance.
+     *
+     * @param args - The arguments for the function.
+     * @param args.publicKey - The PublicKey to be converted.
+     * @returns AuthenticationKey - The derived AuthenticationKey.
+     * @group Implementation
+     * @category Serialization
+     */
+    static fromPublicKey(args: {
+        publicKey: AccountPublicKey;
+    }): AuthenticationKey;
+    /**
+     * Derives an account address from an AuthenticationKey by translating the AuthenticationKey bytes directly to an AccountAddress.
+     *
+     * @returns AccountAddress - The derived account address.
+     * @group Implementation
+     * @category Serialization
+     */
+    derivedAddress(): AccountAddress;
+}
+//# sourceMappingURL=authenticationKey.d.ts.map

package/dist/core/authenticationKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authenticationKey.d.ts","sourceRoot":"","sources":["../../src/core/authenticationKey.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,uBAAuB,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEtD;;;;;;;;;;GAUG;AACH,qBAAa,iBAAkB,SAAQ,YAAY;IACjD;;;;;;OAMG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAM;IAEpC;;;;OAIG;IACH,SAAgB,IAAI,EAAE,GAAG,CAAC;IAE1B;;;;;;;;;;OAUG;gBACS,IAAI,EAAE;QAAE,IAAI,EAAE,QAAQ,CAAA;KAAE;IAUpC;;;;;;OAMG;IACH,SAAS,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAIvC;;;;;;OAMG;IACH,MAAM,CAAC,WAAW,CAAC,YAAY,EAAE,YAAY,GAAG,iBAAiB;IAQjE;;;;OAIG;IACH,QAAQ,IAAI,MAAM;IAIlB;;;;;;;;OAQG;IACH,YAAY,IAAI,UAAU;IAI1B;;;;;;;;;;OAUG;IACH,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,uBAAuB,CAAC;QAAC,KAAK,EAAE,QAAQ,CAAA;KAAE,GAAG,iBAAiB;IAUxG;;;;;;;;;OASG;WACW,sBAAsB,CAAC,IAAI,EAAE;QAAE,SAAS,EAAE,gBAAgB,CAAC;QAAC,MAAM,EAAE,uBAAuB,CAAA;KAAE;IAK3G;;;;;;;;OAQG;IACH,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE;QAAE,SAAS,EAAE,gBAAgB,CAAA;KAAE,GAAG,iBAAiB;IAK9E;;;;;;OAMG;IACH,cAAc,IAAI,cAAc;CAGjC"}