viem 2.0.0-beta.12 → 2.0.0-beta.13

package/_types/utils/encoding/fromBytes.d.ts

@@ -0,0 +1,117 @@
+import type { ErrorType } from '../../errors/utils.js';
+import type { ByteArray, Hex } from '../../types/misc.js';
+import { type TrimErrorType } from '../data/trim.js';
+import { type AssertSizeErrorType, type HexToBigIntErrorType, type HexToNumberErrorType } from './fromHex.js';
+import { type BytesToHexErrorType } from './toHex.js';
+export type FromBytesParameters<TTo extends 'string' | 'hex' | 'bigint' | 'number' | 'boolean'> = TTo | {
+    /** Size of the bytes. */
+    size?: number;
+    /** Type to convert to. */
+    to: TTo;
+};
+export type FromBytesReturnType<TTo> = TTo extends 'string' ? string : TTo extends 'hex' ? Hex : TTo extends 'bigint' ? bigint : TTo extends 'number' ? number : TTo extends 'boolean' ? boolean : never;
+export type FromBytesErrorType = BytesToHexErrorType | BytesToBigIntErrorType | BytesToBoolErrorType | BytesToNumberErrorType | BytesToStringErrorType | ErrorType;
+/**
+ * Decodes a byte array into a UTF-8 string, hex value, number, bigint or boolean.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromBytes.html
+ * - Example: https://viem.sh/docs/utilities/fromBytes.html#usage
+ *
+ * @param bytes Byte array to decode.
+ * @param toOrOpts Type to convert to or options.
+ * @returns Decoded value.
+ *
+ * @example
+ * import { fromBytes } from 'viem'
+ * const data = fromBytes(new Uint8Array([1, 164]), 'number')
+ * // 420
+ *
+ * @example
+ * import { fromBytes } from 'viem'
+ * const data = fromBytes(
+ *   new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+ *   'string'
+ * )
+ * // 'Hello world'
+ */
+export declare function fromBytes<TTo extends 'string' | 'hex' | 'bigint' | 'number' | 'boolean'>(bytes: ByteArray, toOrOpts: FromBytesParameters<TTo>): FromBytesReturnType<TTo>;
+export type BytesToBigIntOpts = {
+    /** Whether or not the number of a signed representation. */
+    signed?: boolean;
+    /** Size of the bytes. */
+    size?: number;
+};
+export type BytesToBigIntErrorType = BytesToHexErrorType | HexToBigIntErrorType | ErrorType;
+/**
+ * Decodes a byte array into a bigint.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromBytes.html#bytestobigint
+ *
+ * @param bytes Byte array to decode.
+ * @param opts Options.
+ * @returns BigInt value.
+ *
+ * @example
+ * import { bytesToBigInt } from 'viem'
+ * const data = bytesToBigInt(new Uint8Array([1, 164]))
+ * // 420n
+ */
+export declare function bytesToBigInt(bytes: ByteArray, opts?: BytesToBigIntOpts): bigint;
+export type BytesToBoolOpts = {
+    /** Size of the bytes. */
+    size?: number;
+};
+export type BytesToBoolErrorType = AssertSizeErrorType | TrimErrorType | ErrorType;
+/**
+ * Decodes a byte array into a boolean.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromBytes.html#bytestobool
+ *
+ * @param bytes Byte array to decode.
+ * @param opts Options.
+ * @returns Boolean value.
+ *
+ * @example
+ * import { bytesToBool } from 'viem'
+ * const data = bytesToBool(new Uint8Array([1]))
+ * // true
+ */
+export declare function bytesToBool(bytes_: ByteArray, opts?: BytesToBoolOpts): boolean;
+export type BytesToNumberOpts = BytesToBigIntOpts;
+export type BytesToNumberErrorType = BytesToHexErrorType | HexToNumberErrorType | ErrorType;
+/**
+ * Decodes a byte array into a number.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromBytes.html#bytestonumber
+ *
+ * @param bytes Byte array to decode.
+ * @param opts Options.
+ * @returns Number value.
+ *
+ * @example
+ * import { bytesToNumber } from 'viem'
+ * const data = bytesToNumber(new Uint8Array([1, 164]))
+ * // 420
+ */
+export declare function bytesToNumber(bytes: ByteArray, opts?: BytesToNumberOpts): number;
+export type BytesToStringOpts = {
+    /** Size of the bytes. */
+    size?: number;
+};
+export type BytesToStringErrorType = AssertSizeErrorType | TrimErrorType | ErrorType;
+/**
+ * Decodes a byte array into a UTF-8 string.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromBytes.html#bytestostring
+ *
+ * @param bytes Byte array to decode.
+ * @param opts Options.
+ * @returns String value.
+ *
+ * @example
+ * import { bytesToString } from 'viem'
+ * const data = bytesToString(new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]))
+ * // 'Hello world'
+ */
+export declare function bytesToString(bytes_: ByteArray, opts?: BytesToStringOpts): string;
+//# sourceMappingURL=fromBytes.d.ts.map

package/_types/utils/encoding/fromBytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fromBytes.d.ts","sourceRoot":"","sources":["../../../utils/encoding/fromBytes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,EAAE,KAAK,aAAa,EAAQ,MAAM,iBAAiB,CAAA;AAE1D,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EAI1B,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,KAAK,mBAAmB,EAAc,MAAM,YAAY,CAAA;AAEjE,MAAM,MAAM,mBAAmB,CAC7B,GAAG,SAAS,QAAQ,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,IAE5D,GAAG,GACH;IACE,yBAAyB;IACzB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,0BAA0B;IAC1B,EAAE,EAAE,GAAG,CAAA;CACR,CAAA;AAEL,MAAM,MAAM,mBAAmB,CAAC,GAAG,IAAI,GAAG,SAAS,QAAQ,GACvD,MAAM,GACN,GAAG,SAAS,KAAK,GACf,GAAG,GACH,GAAG,SAAS,QAAQ,GAClB,MAAM,GACN,GAAG,SAAS,QAAQ,GAClB,MAAM,GACN,GAAG,SAAS,SAAS,GACnB,OAAO,GACP,KAAK,CAAA;AAEjB,MAAM,MAAM,kBAAkB,GAC1B,mBAAmB,GACnB,sBAAsB,GACtB,oBAAoB,GACpB,sBAAsB,GACtB,sBAAsB,GACtB,SAAS,CAAA;AAEb;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,SAAS,CACvB,GAAG,SAAS,QAAQ,GAAG,KAAK,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,EAE9D,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,mBAAmB,CAAC,GAAG,CAAC,GACjC,mBAAmB,CAAC,GAAG,CAAC,CAa1B;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,4DAA4D;IAC5D,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,yBAAyB;IACzB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,sBAAsB,GAC9B,mBAAmB,GACnB,oBAAoB,GACpB,SAAS,CAAA;AAEb;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,SAAS,EAChB,IAAI,GAAE,iBAAsB,GAC3B,MAAM,CAIR;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,yBAAyB;IACzB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,oBAAoB,GAC5B,mBAAmB,GACnB,aAAa,GACb,SAAS,CAAA;AAEb;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,SAAS,EACjB,IAAI,GAAE,eAAoB,GACzB,OAAO,CAST;AAED,MAAM,MAAM,iBAAiB,GAAG,iBAAiB,CAAA;AAEjD,MAAM,MAAM,sBAAsB,GAC9B,mBAAmB,GACnB,oBAAoB,GACpB,SAAS,CAAA;AAEb;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,SAAS,EAChB,IAAI,GAAE,iBAAsB,GAC3B,MAAM,CAIR;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,yBAAyB;IACzB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,sBAAsB,GAC9B,mBAAmB,GACnB,aAAa,GACb,SAAS,CAAA;AAEb;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,EACjB,IAAI,GAAE,iBAAsB,GAC3B,MAAM,CAOR"}

package/_types/utils/encoding/fromHex.d.ts

@@ -0,0 +1,149 @@
+import { type InvalidHexBooleanErrorType, type SizeOverflowErrorType } from '../../errors/encoding.js';
+import type { ErrorType } from '../../errors/utils.js';
+import type { ByteArray, Hex } from '../../types/misc.js';
+import { type SizeErrorType } from '../data/size.js';
+import { type TrimErrorType } from '../data/trim.js';
+import { type HexToBytesErrorType } from './toBytes.js';
+export type AssertSizeErrorType = SizeOverflowErrorType | SizeErrorType | ErrorType;
+export declare function assertSize(hexOrBytes: Hex | ByteArray, { size }: {
+    size: number;
+}): void;
+export type FromHexParameters<TTo extends 'string' | 'bigint' | 'number' | 'bytes' | 'boolean'> = TTo | {
+    /** Size (in bytes) of the hex value. */
+    size?: number;
+    /** Type to convert to. */
+    to: TTo;
+};
+export type FromHexReturnType<TTo> = TTo extends 'string' ? string : TTo extends 'bigint' ? bigint : TTo extends 'number' ? number : TTo extends 'bytes' ? ByteArray : TTo extends 'boolean' ? boolean : never;
+export type FromHexErrorType = HexToNumberErrorType | HexToBigIntErrorType | HexToBoolErrorType | HexToStringErrorType | HexToBytesErrorType | ErrorType;
+/**
+ * Decodes a hex string into a string, number, bigint, boolean, or byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromHex.html
+ * - Example: https://viem.sh/docs/utilities/fromHex.html#usage
+ *
+ * @param hex Hex string to decode.
+ * @param toOrOpts Type to convert to or options.
+ * @returns Decoded value.
+ *
+ * @example
+ * import { fromHex } from 'viem'
+ * const data = fromHex('0x1a4', 'number')
+ * // 420
+ *
+ * @example
+ * import { fromHex } from 'viem'
+ * const data = fromHex('0x48656c6c6f20576f726c6421', 'string')
+ * // 'Hello world'
+ *
+ * @example
+ * import { fromHex } from 'viem'
+ * const data = fromHex('0x48656c6c6f20576f726c64210000000000000000000000000000000000000000', {
+ *   size: 32,
+ *   to: 'string'
+ * })
+ * // 'Hello world'
+ */
+export declare function fromHex<TTo extends 'string' | 'bigint' | 'number' | 'bytes' | 'boolean'>(hex: Hex, toOrOpts: FromHexParameters<TTo>): FromHexReturnType<TTo>;
+export type HexToBigIntOpts = {
+    /** Whether or not the number of a signed representation. */
+    signed?: boolean;
+    /** Size (in bytes) of the hex value. */
+    size?: number;
+};
+export type HexToBigIntErrorType = AssertSizeErrorType | ErrorType;
+/**
+ * Decodes a hex value into a bigint.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromHex.html#hextobigint
+ *
+ * @param hex Hex value to decode.
+ * @param opts Options.
+ * @returns BigInt value.
+ *
+ * @example
+ * import { hexToBigInt } from 'viem'
+ * const data = hexToBigInt('0x1a4', { signed: true })
+ * // 420n
+ *
+ * @example
+ * import { hexToBigInt } from 'viem'
+ * const data = hexToBigInt('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })
+ * // 420n
+ */
+export declare function hexToBigInt(hex: Hex, opts?: HexToBigIntOpts): bigint;
+export type HexToBoolOpts = {
+    /** Size (in bytes) of the hex value. */
+    size?: number;
+};
+export type HexToBoolErrorType = AssertSizeErrorType | InvalidHexBooleanErrorType | TrimErrorType | ErrorType;
+/**
+ * Decodes a hex value into a boolean.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromHex.html#hextobool
+ *
+ * @param hex Hex value to decode.
+ * @param opts Options.
+ * @returns Boolean value.
+ *
+ * @example
+ * import { hexToBool } from 'viem'
+ * const data = hexToBool('0x01')
+ * // true
+ *
+ * @example
+ * import { hexToBool } from 'viem'
+ * const data = hexToBool('0x0000000000000000000000000000000000000000000000000000000000000001', { size: 32 })
+ * // true
+ */
+export declare function hexToBool(hex_: Hex, opts?: HexToBoolOpts): boolean;
+export type HexToNumberOpts = HexToBigIntOpts;
+export type HexToNumberErrorType = HexToBigIntErrorType | ErrorType;
+/**
+ * Decodes a hex string into a number.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromHex.html#hextonumber
+ *
+ * @param hex Hex value to decode.
+ * @param opts Options.
+ * @returns Number value.
+ *
+ * @example
+ * import { hexToNumber } from 'viem'
+ * const data = hexToNumber('0x1a4')
+ * // 420
+ *
+ * @example
+ * import { hexToNumber } from 'viem'
+ * const data = hexToBigInt('0x00000000000000000000000000000000000000000000000000000000000001a4', { size: 32 })
+ * // 420
+ */
+export declare function hexToNumber(hex: Hex, opts?: HexToNumberOpts): number;
+export type HexToStringOpts = {
+    /** Size (in bytes) of the hex value. */
+    size?: number;
+};
+export type HexToStringErrorType = AssertSizeErrorType | HexToBytesErrorType | TrimErrorType | ErrorType;
+/**
+ * Decodes a hex value into a UTF-8 string.
+ *
+ * - Docs: https://viem.sh/docs/utilities/fromHex.html#hextostring
+ *
+ * @param hex Hex value to decode.
+ * @param opts Options.
+ * @returns String value.
+ *
+ * @example
+ * import { hexToString } from 'viem'
+ * const data = hexToString('0x48656c6c6f20576f726c6421')
+ * // 'Hello world!'
+ *
+ * @example
+ * import { hexToString } from 'viem'
+ * const data = hexToString('0x48656c6c6f20576f726c64210000000000000000000000000000000000000000', {
+ *  size: 32,
+ * })
+ * // 'Hello world'
+ */
+export declare function hexToString(hex: Hex, opts?: HexToStringOpts): string;
+//# sourceMappingURL=fromHex.d.ts.map

package/_types/utils/encoding/fromHex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fromHex.d.ts","sourceRoot":"","sources":["../../../utils/encoding/fromHex.ts"],"names":[],"mappings":"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"}

package/_types/utils/encoding/fromRlp.d.ts

@@ -0,0 +1,21 @@
+import { type BaseErrorType } from '../../errors/base.js';
+import { type InvalidHexValueErrorType } from '../../errors/encoding.js';
+import type { ErrorType } from '../../errors/utils.js';
+import type { ByteArray, Hex } from '../../types/misc.js';
+import { type CreateCursorErrorType } from '../cursor.js';
+import { type HexToBytesErrorType } from './toBytes.js';
+import { type BytesToHexErrorType } from './toHex.js';
+import type { RecursiveArray } from './toRlp.js';
+type To = 'hex' | 'bytes';
+export type FromRlpReturnType<to extends To> = (to extends 'bytes' ? RecursiveArray<ByteArray> : never) | (to extends 'hex' ? RecursiveArray<Hex> : never);
+export type FromRlpErrorType = CreateCursorErrorType | FromRlpCursorErrorType | HexToBytesErrorType | InvalidHexValueErrorType | ErrorType;
+export declare function fromRlp<to extends To = 'hex'>(value: ByteArray | Hex, to?: to | To | undefined): FromRlpReturnType<to>;
+export type RlpToBytesErrorType = FromRlpErrorType | ErrorType;
+export declare function rlpToBytes<to extends To = 'bytes'>(bytes: ByteArray, to?: to | To | undefined): FromRlpReturnType<to>;
+export type RlpToHexErrorType = FromRlpErrorType | ErrorType;
+export declare function rlpToHex<to extends To = 'hex'>(hex: Hex, to?: to | To | undefined): FromRlpReturnType<to>;
+export type FromRlpCursorErrorType = BytesToHexErrorType | ReadLengthErrorType | ReadListErrorType | ErrorType;
+export type ReadLengthErrorType = BaseErrorType | ErrorType;
+export type ReadListErrorType = ErrorType;
+export {};
+//# sourceMappingURL=fromRlp.d.ts.map

package/_types/utils/encoding/fromRlp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fromRlp.d.ts","sourceRoot":"","sources":["../../../utils/encoding/fromRlp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACpE,OAAO,EAEL,KAAK,wBAAwB,EAC9B,MAAM,0BAA0B,CAAA;AACjC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,EACL,KAAK,qBAAqB,EAG3B,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,KAAK,mBAAmB,EAAc,MAAM,cAAc,CAAA;AACnE,OAAO,EAAE,KAAK,mBAAmB,EAAc,MAAM,YAAY,CAAA;AAEjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAEhD,KAAK,EAAE,GAAG,KAAK,GAAG,OAAO,CAAA;AAEzB,MAAM,MAAM,iBAAiB,CAAC,EAAE,SAAS,EAAE,IACvC,CAAC,EAAE,SAAS,OAAO,GAAG,cAAc,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC,GACxD,CAAC,EAAE,SAAS,KAAK,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAA;AAEpD,MAAM,MAAM,gBAAgB,GACxB,qBAAqB,GACrB,sBAAsB,GACtB,mBAAmB,GACnB,wBAAwB,GACxB,SAAS,CAAA;AAEb,wBAAgB,OAAO,CAAC,EAAE,SAAS,EAAE,GAAG,KAAK,EAC3C,KAAK,EAAE,SAAS,GAAG,GAAG,EACtB,EAAE,GAAE,EAAE,GAAG,EAAE,GAAG,SAAiB,GAC9B,iBAAiB,CAAC,EAAE,CAAC,CAcvB;AAED,MAAM,MAAM,mBAAmB,GAAG,gBAAgB,GAAG,SAAS,CAAA;AAE9D,wBAAgB,UAAU,CAAC,EAAE,SAAS,EAAE,GAAG,OAAO,EAChD,KAAK,EAAE,SAAS,EAChB,EAAE,GAAE,EAAE,GAAG,EAAE,GAAG,SAAmB,GAChC,iBAAiB,CAAC,EAAE,CAAC,CAEvB;AAED,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,GAAG,SAAS,CAAA;AAE5D,wBAAgB,QAAQ,CAAC,EAAE,SAAS,EAAE,GAAG,KAAK,EAC5C,GAAG,EAAE,GAAG,EACR,EAAE,GAAE,EAAE,GAAG,EAAE,GAAG,SAAiB,GAC9B,iBAAiB,CAAC,EAAE,CAAC,CAEvB;AAED,MAAM,MAAM,sBAAsB,GAC9B,mBAAmB,GACnB,mBAAmB,GACnB,iBAAiB,GACjB,SAAS,CAAA;AA0Bb,MAAM,MAAM,mBAAmB,GAAG,aAAa,GAAG,SAAS,CAAA;AAY3D,MAAM,MAAM,iBAAiB,GAAG,SAAS,CAAA"}

package/_types/utils/encoding/toBytes.d.ts

@@ -0,0 +1,134 @@
+import type { ErrorType } from '../../errors/utils.js';
+import type { ByteArray, Hex } from '../../types/misc.js';
+import { type IsHexErrorType } from '../data/isHex.js';
+import { type PadErrorType } from '../data/pad.js';
+import { type AssertSizeErrorType } from './fromHex.js';
+import { type NumberToHexErrorType, type NumberToHexOpts } from './toHex.js';
+export type ToBytesParameters = {
+    /** Size of the output bytes. */
+    size?: number;
+};
+export type ToBytesErrorType = NumberToBytesErrorType | BoolToBytesErrorType | HexToBytesErrorType | StringToBytesErrorType | IsHexErrorType | ErrorType;
+/**
+ * Encodes a UTF-8 string, hex value, bigint, number or boolean to a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes.html
+ * - Example: https://viem.sh/docs/utilities/toBytes.html#usage
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { toBytes } from 'viem'
+ * const data = toBytes('Hello world')
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ *
+ * @example
+ * import { toBytes } from 'viem'
+ * const data = toBytes(420)
+ * // Uint8Array([1, 164])
+ *
+ * @example
+ * import { toBytes } from 'viem'
+ * const data = toBytes(420, { size: 4 })
+ * // Uint8Array([0, 0, 1, 164])
+ */
+export declare function toBytes(value: string | bigint | number | boolean | Hex, opts?: ToBytesParameters): ByteArray;
+export type BoolToBytesOpts = {
+    /** Size of the output bytes. */
+    size?: number;
+};
+export type BoolToBytesErrorType = AssertSizeErrorType | PadErrorType | ErrorType;
+/**
+ * Encodes a boolean into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes.html#booltobytes
+ *
+ * @param value Boolean value to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { boolToBytes } from 'viem'
+ * const data = boolToBytes(true)
+ * // Uint8Array([1])
+ *
+ * @example
+ * import { boolToBytes } from 'viem'
+ * const data = boolToBytes(true, { size: 32 })
+ * // Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
+ */
+export declare function boolToBytes(value: boolean, opts?: BoolToBytesOpts): Uint8Array;
+export type HexToBytesOpts = {
+    /** Size of the output bytes. */
+    size?: number;
+};
+export type HexToBytesErrorType = AssertSizeErrorType | PadErrorType | ErrorType;
+/**
+ * Encodes a hex string into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes.html#hextobytes
+ *
+ * @param hex Hex string to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { hexToBytes } from 'viem'
+ * const data = hexToBytes('0x48656c6c6f20776f726c6421')
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ *
+ * @example
+ * import { hexToBytes } from 'viem'
+ * const data = hexToBytes('0x48656c6c6f20776f726c6421', { size: 32 })
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+ */
+export declare function hexToBytes(hex_: Hex, opts?: HexToBytesOpts): ByteArray;
+export type NumberToBytesErrorType = NumberToHexErrorType | HexToBytesErrorType | ErrorType;
+/**
+ * Encodes a number into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes.html#numbertobytes
+ *
+ * @param value Number to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { numberToBytes } from 'viem'
+ * const data = numberToBytes(420)
+ * // Uint8Array([1, 164])
+ *
+ * @example
+ * import { numberToBytes } from 'viem'
+ * const data = numberToBytes(420, { size: 4 })
+ * // Uint8Array([0, 0, 1, 164])
+ */
+export declare function numberToBytes(value: bigint | number, opts?: NumberToHexOpts): Uint8Array;
+export type StringToBytesOpts = {
+    /** Size of the output bytes. */
+    size?: number;
+};
+export type StringToBytesErrorType = AssertSizeErrorType | PadErrorType | ErrorType;
+/**
+ * Encodes a UTF-8 string into a byte array.
+ *
+ * - Docs: https://viem.sh/docs/utilities/toBytes.html#stringtobytes
+ *
+ * @param value String to encode.
+ * @param opts Options.
+ * @returns Byte array value.
+ *
+ * @example
+ * import { stringToBytes } from 'viem'
+ * const data = stringToBytes('Hello world!')
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100, 33])
+ *
+ * @example
+ * import { stringToBytes } from 'viem'
+ * const data = stringToBytes('Hello world!', { size: 32 })
+ * // Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+ */
+export declare function stringToBytes(value: string, opts?: StringToBytesOpts): ByteArray;
+//# sourceMappingURL=toBytes.d.ts.map

package/_types/utils/encoding/toBytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toBytes.d.ts","sourceRoot":"","sources":["../../../utils/encoding/toBytes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,EAAE,KAAK,cAAc,EAAS,MAAM,kBAAkB,CAAA;AAC7D,OAAO,EAAE,KAAK,YAAY,EAAO,MAAM,gBAAgB,CAAA;AAEvD,OAAO,EAAE,KAAK,mBAAmB,EAAc,MAAM,cAAc,CAAA;AACnE,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,eAAe,EAErB,MAAM,YAAY,CAAA;AAInB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,gCAAgC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,gBAAgB,GACxB,sBAAsB,GACtB,oBAAoB,GACpB,mBAAmB,GACnB,sBAAsB,GACtB,cAAc,GACd,SAAS,CAAA;AAEb;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,GAAG,EAC/C,IAAI,GAAE,iBAAsB,GAC3B,SAAS,CAMX;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,gCAAgC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,oBAAoB,GAC5B,mBAAmB,GACnB,YAAY,GACZ,SAAS,CAAA;AAEb;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,eAAoB,cAQrE;AAsBD,MAAM,MAAM,cAAc,GAAG;IAC3B,gCAAgC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,mBAAmB,GAAG,YAAY,GAAG,SAAS,CAAA;AAEhF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,GAAE,cAAmB,GAAG,SAAS,CAyB1E;AAED,MAAM,MAAM,sBAAsB,GAC9B,oBAAoB,GACpB,mBAAmB,GACnB,SAAS,CAAA;AAEb;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,CAAC,EAAE,eAAe,cAG3E;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,gCAAgC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,sBAAsB,GAC9B,mBAAmB,GACnB,YAAY,GACZ,SAAS,CAAA;AAEb;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,MAAM,EACb,IAAI,GAAE,iBAAsB,GAC3B,SAAS,CAOX"}

package/_types/utils/encoding/toHex.d.ts

@@ -0,0 +1,148 @@
+import { type IntegerOutOfRangeErrorType } from '../../errors/encoding.js';
+import type { ErrorType } from '../../errors/utils.js';
+import type { ByteArray, Hex } from '../../types/misc.js';
+import { type PadErrorType } from '../data/pad.js';
+import { type AssertSizeErrorType } from './fromHex.js';
+export type ToHexParameters = {
+    /** The size (in bytes) of the output hex value. */
+    size?: number;
+};
+export type ToHexErrorType = BoolToHexErrorType | BytesToHexErrorType | NumberToHexErrorType | StringToHexErrorType | ErrorType;
+/**
+ * Encodes a string, number, bigint, or ByteArray into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex.html
+ * - Example: https://viem.sh/docs/utilities/toHex.html#usage
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { toHex } from 'viem'
+ * const data = toHex('Hello world')
+ * // '0x48656c6c6f20776f726c6421'
+ *
+ * @example
+ * import { toHex } from 'viem'
+ * const data = toHex(420)
+ * // '0x1a4'
+ *
+ * @example
+ * import { toHex } from 'viem'
+ * const data = toHex('Hello world', { size: 32 })
+ * // '0x48656c6c6f20776f726c64210000000000000000000000000000000000000000'
+ */
+export declare function toHex(value: string | number | bigint | boolean | ByteArray, opts?: ToHexParameters): Hex;
+export type BoolToHexOpts = {
+    /** The size (in bytes) of the output hex value. */
+    size?: number;
+};
+export type BoolToHexErrorType = AssertSizeErrorType | PadErrorType | ErrorType;
+/**
+ * Encodes a boolean into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex.html#booltohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { boolToHex } from 'viem'
+ * const data = boolToHex(true)
+ * // '0x1'
+ *
+ * @example
+ * import { boolToHex } from 'viem'
+ * const data = boolToHex(false)
+ * // '0x0'
+ *
+ * @example
+ * import { boolToHex } from 'viem'
+ * const data = boolToHex(true, { size: 32 })
+ * // '0x0000000000000000000000000000000000000000000000000000000000000001'
+ */
+export declare function boolToHex(value: boolean, opts?: BoolToHexOpts): Hex;
+export type BytesToHexOpts = {
+    /** The size (in bytes) of the output hex value. */
+    size?: number;
+};
+export type BytesToHexErrorType = AssertSizeErrorType | PadErrorType | ErrorType;
+/**
+ * Encodes a bytes array into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex.html#bytestohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { bytesToHex } from 'viem'
+ * const data = bytesToHex(Uint8Array.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33])
+ * // '0x48656c6c6f20576f726c6421'
+ *
+ * @example
+ * import { bytesToHex } from 'viem'
+ * const data = bytesToHex(Uint8Array.from([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]), { size: 32 })
+ * // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'
+ */
+export declare function bytesToHex(value: ByteArray, opts?: BytesToHexOpts): Hex;
+export type NumberToHexOpts = {
+    /** Whether or not the number of a signed representation. */
+    signed?: boolean;
+    /** The size (in bytes) of the output hex value. */
+    size: number;
+} | {
+    signed?: never;
+    /** The size (in bytes) of the output hex value. */
+    size?: number;
+};
+export type NumberToHexErrorType = IntegerOutOfRangeErrorType | PadErrorType | ErrorType;
+/**
+ * Encodes a number or bigint into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex.html#numbertohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { numberToHex } from 'viem'
+ * const data = numberToHex(420)
+ * // '0x1a4'
+ *
+ * @example
+ * import { numberToHex } from 'viem'
+ * const data = numberToHex(420, { size: 32 })
+ * // '0x00000000000000000000000000000000000000000000000000000000000001a4'
+ */
+export declare function numberToHex(value_: number | bigint, opts?: NumberToHexOpts): Hex;
+export type StringToHexOpts = {
+    /** The size (in bytes) of the output hex value. */
+    size?: number;
+};
+export type StringToHexErrorType = BytesToHexErrorType | ErrorType;
+/**
+ * Encodes a UTF-8 string into a hex string
+ *
+ * - Docs: https://viem.sh/docs/utilities/toHex.html#stringtohex
+ *
+ * @param value Value to encode.
+ * @param opts Options.
+ * @returns Hex value.
+ *
+ * @example
+ * import { stringToHex } from 'viem'
+ * const data = stringToHex('Hello World!')
+ * // '0x48656c6c6f20576f726c6421'
+ *
+ * @example
+ * import { stringToHex } from 'viem'
+ * const data = stringToHex('Hello World!', { size: 32 })
+ * // '0x48656c6c6f20576f726c64210000000000000000000000000000000000000000'
+ */
+export declare function stringToHex(value_: string, opts?: StringToHexOpts): Hex;
+//# sourceMappingURL=toHex.d.ts.map

package/_types/utils/encoding/toHex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toHex.d.ts","sourceRoot":"","sources":["../../../utils/encoding/toHex.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,0BAA0B,EAChC,MAAM,0BAA0B,CAAA;AACjC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,EAAE,KAAK,YAAY,EAAO,MAAM,gBAAgB,CAAA;AAEvD,OAAO,EAAE,KAAK,mBAAmB,EAAc,MAAM,cAAc,CAAA;AAMnE,MAAM,MAAM,eAAe,GAAG;IAC5B,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,cAAc,GACtB,kBAAkB,GAClB,mBAAmB,GACnB,oBAAoB,GACpB,oBAAoB,GACpB,SAAS,CAAA;AAEb;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,KAAK,CACnB,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,EACrD,IAAI,GAAE,eAAoB,GACzB,GAAG,CAQL;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG,mBAAmB,GAAG,YAAY,GAAG,SAAS,CAAA;AAE/E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,GAAE,aAAkB,GAAG,GAAG,CAOvE;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,mBAAmB,GAAG,YAAY,GAAG,SAAS,CAAA;AAEhF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,GAAE,cAAmB,GAAG,GAAG,CAY3E;AAED,MAAM,MAAM,eAAe,GACvB;IACE,4DAA4D;IAC5D,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAA;CACb,GACD;IACE,MAAM,CAAC,EAAE,KAAK,CAAA;IACd,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAEL,MAAM,MAAM,oBAAoB,GAC5B,0BAA0B,GAC1B,YAAY,GACZ,SAAS,CAAA;AAEb;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,IAAI,GAAE,eAAoB,GACzB,GAAG,CAgCL;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,mDAAmD;IACnD,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,GAAG,SAAS,CAAA;AAIlE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE,eAAoB,GAAG,GAAG,CAG3E"}

package/_types/utils/encoding/toRlp.d.ts

@@ -0,0 +1,16 @@
+import type { ErrorType } from '../../errors/utils.js';
+import type { ByteArray, Hex } from '../../types/misc.js';
+import { type CreateCursorErrorType } from '../cursor.js';
+import { type HexToBytesErrorType } from './toBytes.js';
+import { type BytesToHexErrorType } from './toHex.js';
+export type RecursiveArray<T> = T | RecursiveArray<T>[];
+type To = 'hex' | 'bytes';
+export type ToRlpReturnType<to extends To> = (to extends 'bytes' ? ByteArray : never) | (to extends 'hex' ? Hex : never);
+export type ToRlpErrorType = CreateCursorErrorType | BytesToHexErrorType | HexToBytesErrorType | ErrorType;
+export declare function toRlp<to extends To = 'hex'>(bytes: RecursiveArray<ByteArray> | RecursiveArray<Hex>, to?: to | To | undefined): ToRlpReturnType<to>;
+export type BytesToRlpErrorType = ToRlpErrorType | ErrorType;
+export declare function bytesToRlp<to extends To = 'bytes'>(bytes: RecursiveArray<ByteArray>, to?: to | To | undefined): ToRlpReturnType<to>;
+export type HexToRlpErrorType = ToRlpErrorType | ErrorType;
+export declare function hexToRlp<to extends To = 'hex'>(hex: RecursiveArray<Hex>, to?: to | To | undefined): ToRlpReturnType<to>;
+export {};
+//# sourceMappingURL=toRlp.d.ts.map

package/_types/utils/encoding/toRlp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toRlp.d.ts","sourceRoot":"","sources":["../../../utils/encoding/toRlp.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AAEtD,OAAO,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,qBAAqB,CAAA;AACzD,OAAO,EACL,KAAK,qBAAqB,EAG3B,MAAM,cAAc,CAAA;AAErB,OAAO,EAAE,KAAK,mBAAmB,EAAc,MAAM,cAAc,CAAA;AACnE,OAAO,EAAE,KAAK,mBAAmB,EAAc,MAAM,YAAY,CAAA;AAEjE,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,EAAE,CAAA;AAEvD,KAAK,EAAE,GAAG,KAAK,GAAG,OAAO,CAAA;AAOzB,MAAM,MAAM,eAAe,CAAC,EAAE,SAAS,EAAE,IACrC,CAAC,EAAE,SAAS,OAAO,GAAG,SAAS,GAAG,KAAK,CAAC,GACxC,CAAC,EAAE,SAAS,KAAK,GAAG,GAAG,GAAG,KAAK,CAAC,CAAA;AAEpC,MAAM,MAAM,cAAc,GACtB,qBAAqB,GACrB,mBAAmB,GACnB,mBAAmB,GACnB,SAAS,CAAA;AAEb,wBAAgB,KAAK,CAAC,EAAE,SAAS,EAAE,GAAG,KAAK,EACzC,KAAK,EAAE,cAAc,CAAC,SAAS,CAAC,GAAG,cAAc,CAAC,GAAG,CAAC,EACtD,EAAE,GAAE,EAAE,GAAG,EAAE,GAAG,SAAiB,GAC9B,eAAe,CAAC,EAAE,CAAC,CAOrB;AAED,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,SAAS,CAAA;AAE5D,wBAAgB,UAAU,CAAC,EAAE,SAAS,EAAE,GAAG,OAAO,EAChD,KAAK,EAAE,cAAc,CAAC,SAAS,CAAC,EAChC,EAAE,GAAE,EAAE,GAAG,EAAE,GAAG,SAAmB,GAChC,eAAe,CAAC,EAAE,CAAC,CAErB;AAED,MAAM,MAAM,iBAAiB,GAAG,cAAc,GAAG,SAAS,CAAA;AAE1D,wBAAgB,QAAQ,CAAC,EAAE,SAAS,EAAE,GAAG,KAAK,EAC5C,GAAG,EAAE,cAAc,CAAC,GAAG,CAAC,EACxB,EAAE,GAAE,EAAE,GAAG,EAAE,GAAG,SAAiB,GAC9B,eAAe,CAAC,EAAE,CAAC,CAErB"}

package/_types/utils/ens/avatar/parseAvatarRecord.d.ts

@@ -0,0 +1,13 @@
+import type { Client } from '../../../clients/createClient.js';
+import type { Transport } from '../../../clients/transports/createTransport.js';
+import type { ErrorType } from '../../../errors/utils.js';
+import type { Chain } from '../../../types/chain.js';
+import type { AssetGatewayUrls } from '../../../types/ens.js';
+import { type GetJsonImageErrorType, type GetMetadataAvatarUriErrorType, type GetNftTokenUriErrorType, type ParseAvatarUriErrorType, type ParseNftUriErrorType, type ResolveAvatarUriErrorType } from './utils.js';
+export type ParseAvatarRecordErrorType = ParseNftAvatarUriErrorType | ParseAvatarUriErrorType | ErrorType;
+export declare function parseAvatarRecord<TChain extends Chain | undefined>(client: Client<Transport, TChain>, { gatewayUrls, record, }: {
+    gatewayUrls?: AssetGatewayUrls;
+    record: string;
+}): Promise<string>;
+export type ParseNftAvatarUriErrorType = ParseNftUriErrorType | GetNftTokenUriErrorType | ResolveAvatarUriErrorType | ParseAvatarUriErrorType | GetJsonImageErrorType | GetMetadataAvatarUriErrorType | ErrorType;
+//# sourceMappingURL=parseAvatarRecord.d.ts.map

package/_types/utils/ens/avatar/parseAvatarRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseAvatarRecord.d.ts","sourceRoot":"","sources":["../../../../utils/ens/avatar/parseAvatarRecord.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gDAAgD,CAAA;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAA;AACzD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAA;AACpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAE7D,OAAO,EACL,KAAK,qBAAqB,EAC1B,KAAK,6BAA6B,EAClC,KAAK,uBAAuB,EAC5B,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,EACzB,KAAK,yBAAyB,EAO/B,MAAM,YAAY,CAAA;AAEnB,MAAM,MAAM,0BAA0B,GAClC,0BAA0B,GAC1B,uBAAuB,GACvB,SAAS,CAAA;AAEb,wBAAsB,iBAAiB,CAAC,MAAM,SAAS,KAAK,GAAG,SAAS,EACtE,MAAM,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,EACjC,EACE,WAAW,EACX,MAAM,GACP,EAAE;IACD,WAAW,CAAC,EAAE,gBAAgB,CAAA;IAC9B,MAAM,EAAE,MAAM,CAAA;CACf,GACA,OAAO,CAAC,MAAM,CAAC,CAIjB;AAED,MAAM,MAAM,0BAA0B,GAClC,oBAAoB,GACpB,uBAAuB,GACvB,yBAAyB,GACzB,uBAAuB,GACvB,qBAAqB,GACrB,6BAA6B,GAC7B,SAAS,CAAA"}