@haneullabs/bcs 0.1.0 → 2.0.3

package/dist/bcs.d.mts

@@ -0,0 +1,184 @@
+import { EnumInputShape, EnumOutputShape, InferBcsInput, InferBcsType, JoinString } from "./types.mjs";
+import { BcsEnum, BcsStruct, BcsTuple, BcsType, BcsTypeOptions } from "./bcs-type.mjs";
+
+//#region src/bcs.d.ts
+declare function fixedArray<T extends BcsType<any>, Name extends string = string>(size: number, type: T, options?: BcsTypeOptions<InferBcsType<T>[], Iterable<InferBcsInput<T>> & {
+  length: number;
+}, Name>): BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & {
+  length: number;
+}, Name>;
+declare function fixedArray<T, Input, Name extends string = string>(size: number, type: BcsType<T, Input>, options?: BcsTypeOptions<T[], Iterable<Input> & {
+  length: number;
+}, Name>): BcsType<T[], Iterable<Input> & {
+  length: number;
+}, Name>;
+declare function option<T extends BcsType<any>>(type: T): BcsType<InferBcsType<T> | null, InferBcsInput<T> | null | undefined, `Option<${T['name']}>`>;
+declare function option<T, Input, Name extends string = string>(type: BcsType<T, Input, Name>): BcsType<T | null, Input | null | undefined>;
+declare function vector<T extends BcsType<any>, Name extends string = `vector<${T['name']}>`>(type: T, options?: BcsTypeOptions<InferBcsType<T>[], Iterable<InferBcsInput<T>> & {
+  length: number;
+}, Name>): BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & {
+  length: number;
+}, Name>;
+declare function vector<T, Input, Name extends string = string>(type: BcsType<T, Input, Name>, options?: BcsTypeOptions<T[], Iterable<Input> & {
+  length: number;
+}, `vector<${Name}>`>): BcsType<T[], Iterable<Input> & {
+  length: number;
+}, `vector<${Name}>`>;
+/**
+ * Compares two byte arrays using lexicographic ordering.
+ * This matches Rust's Ord implementation for Vec<u8>/[u8] which is used for BTreeMap key ordering.
+ * Comparison is done byte-by-byte first, then by length if all compared bytes are equal.
+ */
+declare function compareBcsBytes(a: Uint8Array, b: Uint8Array): number;
+declare function map<K$1 extends BcsType<any>, V extends BcsType<any>>(keyType: K$1, valueType: V): BcsType<Map<InferBcsType<K$1>, InferBcsType<V>>, Map<InferBcsInput<K$1>, InferBcsInput<V>>, `Map<${K$1['name']}, ${V['name']}>`>;
+declare function map<K$1, V, InputK = K$1, InputV = V>(keyType: BcsType<K$1, InputK>, valueType: BcsType<V, InputV>): BcsType<Map<K$1, V>, Map<InputK, InputV>, `Map<${string}, ${string}>`>;
+declare const bcs: {
+  /**
+   * Creates a BcsType that can be used to read and write an 8-bit unsigned integer.
+   * @example
+   * bcs.u8().serialize(255).toBytes() // Uint8Array [ 255 ]
+   */
+  u8(options?: BcsTypeOptions<number>): BcsType<number, number, "u8">;
+  /**
+   * Creates a BcsType that can be used to read and write a 16-bit unsigned integer.
+   * @example
+   * bcs.u16().serialize(65535).toBytes() // Uint8Array [ 255, 255 ]
+   */
+  u16(options?: BcsTypeOptions<number>): BcsType<number, number, "u16">;
+  /**
+   * Creates a BcsType that can be used to read and write a 32-bit unsigned integer.
+   * @example
+   * bcs.u32().serialize(4294967295).toBytes() // Uint8Array [ 255, 255, 255, 255 ]
+   */
+  u32(options?: BcsTypeOptions<number>): BcsType<number, number, "u32">;
+  /**
+   * Creates a BcsType that can be used to read and write a 64-bit unsigned integer.
+   * @example
+   * bcs.u64().serialize(1).toBytes() // Uint8Array [ 1, 0, 0, 0, 0, 0, 0, 0 ]
+   */
+  u64(options?: BcsTypeOptions<string, number | bigint | string>): BcsType<string, string | number | bigint, "u64">;
+  /**
+   * Creates a BcsType that can be used to read and write a 128-bit unsigned integer.
+   * @example
+   * bcs.u128().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
+   */
+  u128(options?: BcsTypeOptions<string, number | bigint | string>): BcsType<string, string | number | bigint, "u128">;
+  /**
+   * Creates a BcsType that can be used to read and write a 256-bit unsigned integer.
+   * @example
+   * bcs.u256().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]
+   */
+  u256(options?: BcsTypeOptions<string, number | bigint | string>): BcsType<string, string | number | bigint, "u256">;
+  /**
+   * Creates a BcsType that can be used to read and write boolean values.
+   * @example
+   * bcs.bool().serialize(true).toBytes() // Uint8Array [ 1 ]
+   */
+  bool(options?: BcsTypeOptions<boolean>): BcsType<boolean, boolean, "bool">;
+  /**
+   * Creates a BcsType that can be used to read and write unsigned LEB encoded integers
+   * @example
+   *
+   */
+  uleb128(options?: BcsTypeOptions<number>): BcsType<number, number, string>;
+  /**
+   * Creates a BcsType representing a fixed length byte array
+   * @param size The number of bytes this types represents
+   * @example
+   * bcs.bytes(3).serialize(new Uint8Array([1, 2, 3])).toBytes() // Uint8Array [1, 2, 3]
+   */
+  bytes<T extends number>(size: T, options?: BcsTypeOptions<Uint8Array, Iterable<number>>): BcsType<Uint8Array<ArrayBufferLike>, Iterable<number>, `bytes[${T}]`>;
+  /**
+   * Creates a BcsType representing a variable length byte array
+   *
+   * @example
+   * bcs.byteVector().serialize([1, 2, 3]).toBytes() // Uint8Array [3, 1, 2, 3]
+   */
+  byteVector(options?: BcsTypeOptions<Uint8Array, Iterable<number>>): BcsType<Uint8Array<ArrayBufferLike>, Iterable<number>, "vector<u8>">;
+  /**
+   * Creates a BcsType that can ser/de string values.  Strings will be UTF-8 encoded
+   * @example
+   * bcs.string().serialize('a').toBytes() // Uint8Array [ 1, 97 ]
+   */
+  string(options?: BcsTypeOptions<string>): BcsType<string, string, "string">;
+  /**
+   * Creates a BcsType that represents a fixed length array of a given type
+   * @param size The number of elements in the array
+   * @param type The BcsType of each element in the array
+   * @example
+   * bcs.fixedArray(3, bcs.u8()).serialize([1, 2, 3]).toBytes() // Uint8Array [ 1, 2, 3 ]
+   */
+  fixedArray: typeof fixedArray;
+  /**
+   * Creates a BcsType representing an optional value
+   * @param type The BcsType of the optional value
+   * @example
+   * bcs.option(bcs.u8()).serialize(null).toBytes() // Uint8Array [ 0 ]
+   * bcs.option(bcs.u8()).serialize(1).toBytes() // Uint8Array [ 1, 1 ]
+   */
+  option: typeof option;
+  /**
+   * Creates a BcsType representing a variable length vector of a given type
+   * @param type The BcsType of each element in the vector
+   *
+   * @example
+   * bcs.vector(bcs.u8()).toBytes([1, 2, 3]) // Uint8Array [ 3, 1, 2, 3 ]
+   */
+  vector: typeof vector;
+  /**
+   * Creates a BcsType representing a tuple of a given set of types
+   * @param types The BcsTypes for each element in the tuple
+   *
+   * @example
+   * const tuple = bcs.tuple([bcs.u8(), bcs.string(), bcs.bool()])
+   * tuple.serialize([1, 'a', true]).toBytes() // Uint8Array [ 1, 1, 97, 1 ]
+   */
+  tuple<const T extends readonly BcsType<any, any>[], const Name extends string = `(${JoinString<{ [K in keyof T]: T[K] extends BcsType<any, any, infer T_1 extends string> ? T_1 : never }, ", ">})`>(fields: T, options?: BcsTypeOptions<{ -readonly [K_1 in keyof T]: T[K_1] extends BcsType<infer T_1, any> ? T_1 : never }, { [K_1 in keyof T]: T[K_1] extends BcsType<any, infer T_1> ? T_1 : never }, Name>): BcsTuple<T, Name>;
+  /**
+   * Creates a BcsType representing a struct of a given set of fields
+   * @param name The name of the struct
+   * @param fields The fields of the struct. The order of the fields affects how data is serialized and deserialized
+   *
+   * @example
+   * const struct = bcs.struct('MyStruct', {
+   *  a: bcs.u8(),
+   *  b: bcs.string(),
+   * })
+   * struct.serialize({ a: 1, b: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
+   */
+  struct<T extends Record<string, BcsType<any>>, const Name extends string = string>(name: Name, fields: T, options?: Omit<BcsTypeOptions<{ [K in keyof T]: T[K] extends BcsType<infer U, any> ? U : never }, { [K in keyof T]: T[K] extends BcsType<any, infer U> ? U : never }>, "name">): BcsStruct<T, string>;
+  /**
+   * Creates a BcsType representing an enum of a given set of options
+   * @param name The name of the enum
+   * @param values The values of the enum. The order of the values affects how data is serialized and deserialized.
+   * null can be used to represent a variant with no data.
+   *
+   * @example
+   * const enum = bcs.enum('MyEnum', {
+   *   A: bcs.u8(),
+   *   B: bcs.string(),
+   *   C: null,
+   * })
+   * enum.serialize({ A: 1 }).toBytes() // Uint8Array [ 0, 1 ]
+   * enum.serialize({ B: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]
+   * enum.serialize({ C: true }).toBytes() // Uint8Array [ 2 ]
+   */
+  enum<T extends Record<string, BcsType<any> | null>, const Name extends string = string>(name: Name, fields: T, options?: Omit<BcsTypeOptions<EnumOutputShape<{ [K in keyof T]: T[K] extends BcsType<infer U, any, any> ? U : true }>, EnumInputShape<{ [K in keyof T]: T[K] extends BcsType<any, infer U, any> ? U : boolean | object | null }>, Name>, "name">): BcsEnum<T, Name>;
+  /**
+   * Creates a BcsType representing a map of a given key and value type
+   * @param keyType The BcsType of the key
+   * @param valueType The BcsType of the value
+   * @example
+   * const map = bcs.map(bcs.u8(), bcs.string())
+   * map.serialize(new Map([[2, 'a']])).toBytes() // Uint8Array [ 1, 2, 1, 97 ]
+   */
+  map: typeof map;
+  /**
+   * Creates a BcsType that wraps another BcsType which is lazily evaluated. This is useful for creating recursive types.
+   * @param cb A callback that returns the BcsType
+   */
+  lazy<T extends BcsType<any>>(cb: () => T): T;
+};
+//#endregion
+export { bcs, compareBcsBytes };
+//# sourceMappingURL=bcs.d.mts.map

package/dist/bcs.d.mts.map

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

package/dist/bcs.mjs

@@ -0,0 +1,250 @@
+import { ulebEncode } from "./uleb.mjs";
+import { BcsEnum, BcsStruct, BcsTuple, BcsType, bigUIntBcsType, dynamicSizeBcsType, fixedSizeBcsType, lazyBcsType, stringLikeBcsType, uIntBcsType } from "./bcs-type.mjs";
+
+//#region src/bcs.ts
+function fixedArray(size, type, options) {
+	return new BcsType({
+		read: (reader) => {
+			const result = new Array(size);
+			for (let i = 0; i < size; i++) result[i] = type.read(reader);
+			return result;
+		},
+		write: (value, writer) => {
+			for (const item of value) type.write(item, writer);
+		},
+		...options,
+		name: options?.name ?? `${type.name}[${size}]`,
+		validate: (value) => {
+			options?.validate?.(value);
+			if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+			if (value.length !== size) throw new TypeError(`Expected array of length ${size}, found ${value.length}`);
+		}
+	});
+}
+function option(type) {
+	return bcs.enum(`Option<${type.name}>`, {
+		None: null,
+		Some: type
+	}).transform({
+		input: (value) => {
+			if (value == null) return { None: true };
+			return { Some: value };
+		},
+		output: (value) => {
+			if (value.$kind === "Some") return value.Some;
+			return null;
+		}
+	});
+}
+function vector(type, options) {
+	return new BcsType({
+		read: (reader) => {
+			const length = reader.readULEB();
+			const result = new Array(length);
+			for (let i = 0; i < length; i++) result[i] = type.read(reader);
+			return result;
+		},
+		write: (value, writer) => {
+			writer.writeULEB(value.length);
+			for (const item of value) type.write(item, writer);
+		},
+		...options,
+		name: options?.name ?? `vector<${type.name}>`,
+		validate: (value) => {
+			options?.validate?.(value);
+			if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+		}
+	});
+}
+/**
+* Compares two byte arrays using lexicographic ordering.
+* This matches Rust's Ord implementation for Vec<u8>/[u8] which is used for BTreeMap key ordering.
+* Comparison is done byte-by-byte first, then by length if all compared bytes are equal.
+*/
+function compareBcsBytes(a, b) {
+	for (let i = 0; i < Math.min(a.length, b.length); i++) if (a[i] !== b[i]) return a[i] - b[i];
+	return a.length - b.length;
+}
+function map(keyType, valueType) {
+	return new BcsType({
+		name: `Map<${keyType.name}, ${valueType.name}>`,
+		read: (reader) => {
+			const length = reader.readULEB();
+			const result = /* @__PURE__ */ new Map();
+			for (let i = 0; i < length; i++) result.set(keyType.read(reader), valueType.read(reader));
+			return result;
+		},
+		write: (value, writer) => {
+			const entries = [...value.entries()].map(([key, val]) => [keyType.serialize(key).toBytes(), val]);
+			entries.sort(([a], [b]) => compareBcsBytes(a, b));
+			writer.writeULEB(entries.length);
+			for (const [keyBytes, val] of entries) {
+				writer.writeBytes(keyBytes);
+				valueType.write(val, writer);
+			}
+		}
+	});
+}
+const bcs = {
+	u8(options) {
+		return uIntBcsType({
+			readMethod: "read8",
+			writeMethod: "write8",
+			size: 1,
+			maxValue: 2 ** 8 - 1,
+			...options,
+			name: options?.name ?? "u8"
+		});
+	},
+	u16(options) {
+		return uIntBcsType({
+			readMethod: "read16",
+			writeMethod: "write16",
+			size: 2,
+			maxValue: 2 ** 16 - 1,
+			...options,
+			name: options?.name ?? "u16"
+		});
+	},
+	u32(options) {
+		return uIntBcsType({
+			readMethod: "read32",
+			writeMethod: "write32",
+			size: 4,
+			maxValue: 2 ** 32 - 1,
+			...options,
+			name: options?.name ?? "u32"
+		});
+	},
+	u64(options) {
+		return bigUIntBcsType({
+			readMethod: "read64",
+			writeMethod: "write64",
+			size: 8,
+			maxValue: 2n ** 64n - 1n,
+			...options,
+			name: options?.name ?? "u64"
+		});
+	},
+	u128(options) {
+		return bigUIntBcsType({
+			readMethod: "read128",
+			writeMethod: "write128",
+			size: 16,
+			maxValue: 2n ** 128n - 1n,
+			...options,
+			name: options?.name ?? "u128"
+		});
+	},
+	u256(options) {
+		return bigUIntBcsType({
+			readMethod: "read256",
+			writeMethod: "write256",
+			size: 32,
+			maxValue: 2n ** 256n - 1n,
+			...options,
+			name: options?.name ?? "u256"
+		});
+	},
+	bool(options) {
+		return fixedSizeBcsType({
+			size: 1,
+			read: (reader) => reader.read8() === 1,
+			write: (value, writer) => writer.write8(value ? 1 : 0),
+			...options,
+			name: options?.name ?? "bool",
+			validate: (value) => {
+				options?.validate?.(value);
+				if (typeof value !== "boolean") throw new TypeError(`Expected boolean, found ${typeof value}`);
+			}
+		});
+	},
+	uleb128(options) {
+		return dynamicSizeBcsType({
+			read: (reader) => reader.readULEB(),
+			serialize: (value) => {
+				return Uint8Array.from(ulebEncode(value));
+			},
+			...options,
+			name: options?.name ?? "uleb128"
+		});
+	},
+	bytes(size, options) {
+		return fixedSizeBcsType({
+			size,
+			read: (reader) => reader.readBytes(size),
+			write: (value, writer) => {
+				writer.writeBytes(new Uint8Array(value));
+			},
+			...options,
+			name: options?.name ?? `bytes[${size}]`,
+			validate: (value) => {
+				options?.validate?.(value);
+				if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+				if (value.length !== size) throw new TypeError(`Expected array of length ${size}, found ${value.length}`);
+			}
+		});
+	},
+	byteVector(options) {
+		return new BcsType({
+			read: (reader) => {
+				const length = reader.readULEB();
+				return reader.readBytes(length);
+			},
+			write: (value, writer) => {
+				const array = new Uint8Array(value);
+				writer.writeULEB(array.length);
+				writer.writeBytes(array);
+			},
+			...options,
+			name: options?.name ?? "vector<u8>",
+			serializedSize: (value) => {
+				const length = "length" in value ? value.length : null;
+				return length == null ? null : ulebEncode(length).length + length;
+			},
+			validate: (value) => {
+				options?.validate?.(value);
+				if (!value || typeof value !== "object" || !("length" in value)) throw new TypeError(`Expected array, found ${typeof value}`);
+			}
+		});
+	},
+	string(options) {
+		return stringLikeBcsType({
+			toBytes: (value) => new TextEncoder().encode(value),
+			fromBytes: (bytes) => new TextDecoder().decode(bytes),
+			...options,
+			name: options?.name ?? "string"
+		});
+	},
+	fixedArray,
+	option,
+	vector,
+	tuple(fields, options) {
+		return new BcsTuple({
+			fields,
+			...options
+		});
+	},
+	struct(name, fields, options) {
+		return new BcsStruct({
+			name,
+			fields,
+			...options
+		});
+	},
+	enum(name, fields, options) {
+		return new BcsEnum({
+			name,
+			fields,
+			...options
+		});
+	},
+	map,
+	lazy(cb) {
+		return lazyBcsType(cb);
+	}
+};
+
+//#endregion
+export { bcs, compareBcsBytes };
+//# sourceMappingURL=bcs.mjs.map

package/dist/bcs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bcs.mjs","names":[],"sources":["../src/bcs.ts"],"sourcesContent":["// Copyright (c) Mysten Labs, Inc.\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { BcsTypeOptions } from './bcs-type.js';\nimport {\n\tBcsEnum,\n\tBcsStruct,\n\tBcsTuple,\n\tBcsType,\n\tbigUIntBcsType,\n\tdynamicSizeBcsType,\n\tfixedSizeBcsType,\n\tlazyBcsType,\n\tstringLikeBcsType,\n\tuIntBcsType,\n} from './bcs-type.js';\nimport type {\n\tEnumInputShape,\n\tEnumOutputShape,\n\tInferBcsInput,\n\tInferBcsType,\n\tJoinString,\n} from './types.js';\nimport { ulebEncode } from './uleb.js';\n\nfunction fixedArray<T extends BcsType<any>, Name extends string = string>(\n\tsize: number,\n\ttype: T,\n\toptions?: BcsTypeOptions<\n\t\tInferBcsType<T>[],\n\t\tIterable<InferBcsInput<T>> & { length: number },\n\t\tName\n\t>,\n): BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & { length: number }, Name>;\nfunction fixedArray<T, Input, Name extends string = string>(\n\tsize: number,\n\ttype: BcsType<T, Input>,\n\toptions?: BcsTypeOptions<T[], Iterable<Input> & { length: number }, Name>,\n): BcsType<T[], Iterable<Input> & { length: number }, Name>;\nfunction fixedArray<T extends BcsType<any>, Name extends string = `${T['name']}[${number}]`>(\n\tsize: number,\n\ttype: T,\n\toptions?: BcsTypeOptions<\n\t\tInferBcsType<T>[],\n\t\tIterable<InferBcsInput<T>> & { length: number },\n\t\tName\n\t>,\n): BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & { length: number }, Name> {\n\treturn new BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & { length: number }, Name>({\n\t\tread: (reader) => {\n\t\t\tconst result: InferBcsType<T>[] = new Array(size);\n\t\t\tfor (let i = 0; i < size; i++) {\n\t\t\t\tresult[i] = type.read(reader);\n\t\t\t}\n\t\t\treturn result;\n\t\t},\n\t\twrite: (value, writer) => {\n\t\t\tfor (const item of value) {\n\t\t\t\ttype.write(item, writer);\n\t\t\t}\n\t\t},\n\t\t...options,\n\t\tname: (options?.name ?? `${type.name}[${size}]`) as Name,\n\t\tvalidate: (value) => {\n\t\t\toptions?.validate?.(value);\n\t\t\tif (!value || typeof value !== 'object' || !('length' in value)) {\n\t\t\t\tthrow new TypeError(`Expected array, found ${typeof value}`);\n\t\t\t}\n\t\t\tif (value.length !== size) {\n\t\t\t\tthrow new TypeError(`Expected array of length ${size}, found ${value.length}`);\n\t\t\t}\n\t\t},\n\t});\n}\n\nfunction option<T extends BcsType<any>>(\n\ttype: T,\n): BcsType<InferBcsType<T> | null, InferBcsInput<T> | null | undefined, `Option<${T['name']}>`>;\nfunction option<T, Input, Name extends string = string>(\n\ttype: BcsType<T, Input, Name>,\n): BcsType<T | null, Input | null | undefined>;\nfunction option<T extends BcsType<any>>(\n\ttype: T,\n): BcsType<InferBcsType<T> | null, InferBcsInput<T> | null | undefined, `Option<${T['name']}>`> {\n\treturn bcs\n\t\t.enum(`Option<${type.name}>`, {\n\t\t\tNone: null,\n\t\t\tSome: type,\n\t\t})\n\t\t.transform({\n\t\t\tinput: (value: InferBcsInput<T> | null | undefined) => {\n\t\t\t\tif (value == null) {\n\t\t\t\t\treturn { None: true };\n\t\t\t\t}\n\n\t\t\t\treturn { Some: value };\n\t\t\t},\n\t\t\toutput: (value) => {\n\t\t\t\tif (value.$kind === 'Some') {\n\t\t\t\t\treturn value.Some as InferBcsType<T>;\n\t\t\t\t}\n\n\t\t\t\treturn null;\n\t\t\t},\n\t\t});\n}\n\nfunction vector<T extends BcsType<any>, Name extends string = `vector<${T['name']}>`>(\n\ttype: T,\n\toptions?: BcsTypeOptions<\n\t\tInferBcsType<T>[],\n\t\tIterable<InferBcsInput<T>> & { length: number },\n\t\tName\n\t>,\n): BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & { length: number }, Name>;\nfunction vector<T, Input, Name extends string = string>(\n\ttype: BcsType<T, Input, Name>,\n\toptions?: BcsTypeOptions<T[], Iterable<Input> & { length: number }, `vector<${Name}>`>,\n): BcsType<T[], Iterable<Input> & { length: number }, `vector<${Name}>`>;\nfunction vector<T extends BcsType<any>, Name extends string = `vector<${T['name']}>`>(\n\ttype: T,\n\toptions?: BcsTypeOptions<\n\t\tInferBcsType<T>[],\n\t\tIterable<InferBcsInput<T>> & { length: number },\n\t\tName\n\t>,\n): BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & { length: number }, Name> {\n\treturn new BcsType<InferBcsType<T>[], Iterable<InferBcsInput<T>> & { length: number }, Name>({\n\t\tread: (reader) => {\n\t\t\tconst length = reader.readULEB();\n\t\t\tconst result: InferBcsType<T>[] = new Array(length);\n\t\t\tfor (let i = 0; i < length; i++) {\n\t\t\t\tresult[i] = type.read(reader);\n\t\t\t}\n\t\t\treturn result;\n\t\t},\n\t\twrite: (value, writer) => {\n\t\t\twriter.writeULEB(value.length);\n\t\t\tfor (const item of value) {\n\t\t\t\ttype.write(item, writer);\n\t\t\t}\n\t\t},\n\t\t...options,\n\t\tname: (options?.name ?? `vector<${type.name}>`) as Name,\n\t\tvalidate: (value) => {\n\t\t\toptions?.validate?.(value);\n\t\t\tif (!value || typeof value !== 'object' || !('length' in value)) {\n\t\t\t\tthrow new TypeError(`Expected array, found ${typeof value}`);\n\t\t\t}\n\t\t},\n\t});\n}\n\n/**\n * Compares two byte arrays using lexicographic ordering.\n * This matches Rust's Ord implementation for Vec<u8>/[u8] which is used for BTreeMap key ordering.\n * Comparison is done byte-by-byte first, then by length if all compared bytes are equal.\n */\nexport function compareBcsBytes(a: Uint8Array, b: Uint8Array): number {\n\tfor (let i = 0; i < Math.min(a.length, b.length); i++) {\n\t\tif (a[i] !== b[i]) {\n\t\t\treturn a[i] - b[i];\n\t\t}\n\t}\n\n\treturn a.length - b.length;\n}\n\nfunction map<K extends BcsType<any>, V extends BcsType<any>>(\n\tkeyType: K,\n\tvalueType: V,\n): BcsType<\n\tMap<InferBcsType<K>, InferBcsType<V>>,\n\tMap<InferBcsInput<K>, InferBcsInput<V>>,\n\t`Map<${K['name']}, ${V['name']}>`\n>;\nfunction map<K, V, InputK = K, InputV = V>(\n\tkeyType: BcsType<K, InputK>,\n\tvalueType: BcsType<V, InputV>,\n): BcsType<Map<K, V>, Map<InputK, InputV>, `Map<${string}, ${string}>`>;\nfunction map<K extends BcsType<any>, V extends BcsType<any>>(\n\tkeyType: K,\n\tvalueType: V,\n): BcsType<\n\tMap<InferBcsType<K>, InferBcsType<V>>,\n\tMap<InferBcsInput<K>, InferBcsInput<V>>,\n\t`Map<${K['name']}, ${V['name']}>`\n> {\n\treturn new BcsType({\n\t\tname: `Map<${keyType.name}, ${valueType.name}>`,\n\t\tread: (reader) => {\n\t\t\tconst length = reader.readULEB();\n\t\t\tconst result = new Map<InferBcsType<K>, InferBcsType<V>>();\n\t\t\tfor (let i = 0; i < length; i++) {\n\t\t\t\tresult.set(keyType.read(reader), valueType.read(reader));\n\t\t\t}\n\t\t\treturn result;\n\t\t},\n\t\twrite: (value, writer) => {\n\t\t\tconst entries = [...value.entries()].map(\n\t\t\t\t([key, val]) => [keyType.serialize(key).toBytes(), val] as const,\n\t\t\t);\n\t\t\tentries.sort(([a], [b]) => compareBcsBytes(a, b));\n\n\t\t\twriter.writeULEB(entries.length);\n\t\t\tfor (const [keyBytes, val] of entries) {\n\t\t\t\twriter.writeBytes(keyBytes);\n\t\t\t\tvalueType.write(val, writer);\n\t\t\t}\n\t\t},\n\t});\n}\n\nexport const bcs = {\n\t/**\n\t * Creates a BcsType that can be used to read and write an 8-bit unsigned integer.\n\t * @example\n\t * bcs.u8().serialize(255).toBytes() // Uint8Array [ 255 ]\n\t */\n\tu8(options?: BcsTypeOptions<number>) {\n\t\treturn uIntBcsType({\n\t\t\treadMethod: 'read8',\n\t\t\twriteMethod: 'write8',\n\t\t\tsize: 1,\n\t\t\tmaxValue: 2 ** 8 - 1,\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'u8') as 'u8',\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can be used to read and write a 16-bit unsigned integer.\n\t * @example\n\t * bcs.u16().serialize(65535).toBytes() // Uint8Array [ 255, 255 ]\n\t */\n\tu16(options?: BcsTypeOptions<number>) {\n\t\treturn uIntBcsType({\n\t\t\treadMethod: 'read16',\n\t\t\twriteMethod: 'write16',\n\t\t\tsize: 2,\n\t\t\tmaxValue: 2 ** 16 - 1,\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'u16') as 'u16',\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can be used to read and write a 32-bit unsigned integer.\n\t * @example\n\t * bcs.u32().serialize(4294967295).toBytes() // Uint8Array [ 255, 255, 255, 255 ]\n\t */\n\tu32(options?: BcsTypeOptions<number>) {\n\t\treturn uIntBcsType({\n\t\t\treadMethod: 'read32',\n\t\t\twriteMethod: 'write32',\n\t\t\tsize: 4,\n\t\t\tmaxValue: 2 ** 32 - 1,\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'u32') as 'u32',\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can be used to read and write a 64-bit unsigned integer.\n\t * @example\n\t * bcs.u64().serialize(1).toBytes() // Uint8Array [ 1, 0, 0, 0, 0, 0, 0, 0 ]\n\t */\n\tu64(options?: BcsTypeOptions<string, number | bigint | string>) {\n\t\treturn bigUIntBcsType({\n\t\t\treadMethod: 'read64',\n\t\t\twriteMethod: 'write64',\n\t\t\tsize: 8,\n\t\t\tmaxValue: 2n ** 64n - 1n,\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'u64') as 'u64',\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can be used to read and write a 128-bit unsigned integer.\n\t * @example\n\t * bcs.u128().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]\n\t */\n\tu128(options?: BcsTypeOptions<string, number | bigint | string>) {\n\t\treturn bigUIntBcsType({\n\t\t\treadMethod: 'read128',\n\t\t\twriteMethod: 'write128',\n\t\t\tsize: 16,\n\t\t\tmaxValue: 2n ** 128n - 1n,\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'u128') as 'u128',\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can be used to read and write a 256-bit unsigned integer.\n\t * @example\n\t * bcs.u256().serialize(1).toBytes() // Uint8Array [ 1, ..., 0 ]\n\t */\n\tu256(options?: BcsTypeOptions<string, number | bigint | string>) {\n\t\treturn bigUIntBcsType({\n\t\t\treadMethod: 'read256',\n\t\t\twriteMethod: 'write256',\n\t\t\tsize: 32,\n\t\t\tmaxValue: 2n ** 256n - 1n,\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'u256') as 'u256',\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can be used to read and write boolean values.\n\t * @example\n\t * bcs.bool().serialize(true).toBytes() // Uint8Array [ 1 ]\n\t */\n\tbool(options?: BcsTypeOptions<boolean>) {\n\t\treturn fixedSizeBcsType({\n\t\t\tsize: 1,\n\t\t\tread: (reader) => reader.read8() === 1,\n\t\t\twrite: (value, writer) => writer.write8(value ? 1 : 0),\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'bool') as 'bool',\n\t\t\tvalidate: (value) => {\n\t\t\t\toptions?.validate?.(value);\n\t\t\t\tif (typeof value !== 'boolean') {\n\t\t\t\t\tthrow new TypeError(`Expected boolean, found ${typeof value}`);\n\t\t\t\t}\n\t\t\t},\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can be used to read and write unsigned LEB encoded integers\n\t * @example\n\t *\n\t */\n\tuleb128(options?: BcsTypeOptions<number>) {\n\t\treturn dynamicSizeBcsType({\n\t\t\tread: (reader) => reader.readULEB(),\n\t\t\tserialize: (value) => {\n\t\t\t\treturn Uint8Array.from(ulebEncode(value));\n\t\t\t},\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'uleb128') as 'uleb128',\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType representing a fixed length byte array\n\t * @param size The number of bytes this types represents\n\t * @example\n\t * bcs.bytes(3).serialize(new Uint8Array([1, 2, 3])).toBytes() // Uint8Array [1, 2, 3]\n\t */\n\tbytes<T extends number>(size: T, options?: BcsTypeOptions<Uint8Array, Iterable<number>>) {\n\t\treturn fixedSizeBcsType<Uint8Array, Iterable<number>, `bytes[${T}]`>({\n\t\t\tsize,\n\t\t\tread: (reader) => reader.readBytes(size),\n\t\t\twrite: (value, writer) => {\n\t\t\t\twriter.writeBytes(new Uint8Array(value));\n\t\t\t},\n\t\t\t...options,\n\t\t\tname: (options?.name ?? `bytes[${size}]`) as `bytes[${T}]`,\n\t\t\tvalidate: (value) => {\n\t\t\t\toptions?.validate?.(value);\n\t\t\t\tif (!value || typeof value !== 'object' || !('length' in value)) {\n\t\t\t\t\tthrow new TypeError(`Expected array, found ${typeof value}`);\n\t\t\t\t}\n\t\t\t\tif (value.length !== size) {\n\t\t\t\t\tthrow new TypeError(`Expected array of length ${size}, found ${value.length}`);\n\t\t\t\t}\n\t\t\t},\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType representing a variable length byte array\n\t *\n\t * @example\n\t * bcs.byteVector().serialize([1, 2, 3]).toBytes() // Uint8Array [3, 1, 2, 3]\n\t */\n\tbyteVector(options?: BcsTypeOptions<Uint8Array, Iterable<number>>) {\n\t\treturn new BcsType<Uint8Array, Iterable<number>, 'vector<u8>'>({\n\t\t\tread: (reader) => {\n\t\t\t\tconst length = reader.readULEB();\n\n\t\t\t\treturn reader.readBytes(length);\n\t\t\t},\n\t\t\twrite: (value, writer) => {\n\t\t\t\tconst array = new Uint8Array(value);\n\t\t\t\twriter.writeULEB(array.length);\n\t\t\t\twriter.writeBytes(array);\n\t\t\t},\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'vector<u8>') as 'vector<u8>',\n\t\t\tserializedSize: (value) => {\n\t\t\t\tconst length = 'length' in value ? (value.length as number) : null;\n\t\t\t\treturn length == null ? null : ulebEncode(length).length + length;\n\t\t\t},\n\t\t\tvalidate: (value) => {\n\t\t\t\toptions?.validate?.(value);\n\t\t\t\tif (!value || typeof value !== 'object' || !('length' in value)) {\n\t\t\t\t\tthrow new TypeError(`Expected array, found ${typeof value}`);\n\t\t\t\t}\n\t\t\t},\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType that can ser/de string values.  Strings will be UTF-8 encoded\n\t * @example\n\t * bcs.string().serialize('a').toBytes() // Uint8Array [ 1, 97 ]\n\t */\n\tstring(options?: BcsTypeOptions<string>) {\n\t\treturn stringLikeBcsType({\n\t\t\ttoBytes: (value) => new TextEncoder().encode(value),\n\t\t\tfromBytes: (bytes) => new TextDecoder().decode(bytes),\n\t\t\t...options,\n\t\t\tname: (options?.name ?? 'string') as 'string',\n\t\t});\n\t},\n\t/**\n\t * Creates a BcsType that represents a fixed length array of a given type\n\t * @param size The number of elements in the array\n\t * @param type The BcsType of each element in the array\n\t * @example\n\t * bcs.fixedArray(3, bcs.u8()).serialize([1, 2, 3]).toBytes() // Uint8Array [ 1, 2, 3 ]\n\t */\n\tfixedArray,\n\n\t/**\n\t * Creates a BcsType representing an optional value\n\t * @param type The BcsType of the optional value\n\t * @example\n\t * bcs.option(bcs.u8()).serialize(null).toBytes() // Uint8Array [ 0 ]\n\t * bcs.option(bcs.u8()).serialize(1).toBytes() // Uint8Array [ 1, 1 ]\n\t */\n\toption,\n\n\t/**\n\t * Creates a BcsType representing a variable length vector of a given type\n\t * @param type The BcsType of each element in the vector\n\t *\n\t * @example\n\t * bcs.vector(bcs.u8()).toBytes([1, 2, 3]) // Uint8Array [ 3, 1, 2, 3 ]\n\t */\n\tvector,\n\n\t/**\n\t * Creates a BcsType representing a tuple of a given set of types\n\t * @param types The BcsTypes for each element in the tuple\n\t *\n\t * @example\n\t * const tuple = bcs.tuple([bcs.u8(), bcs.string(), bcs.bool()])\n\t * tuple.serialize([1, 'a', true]).toBytes() // Uint8Array [ 1, 1, 97, 1 ]\n\t */\n\ttuple<\n\t\tconst T extends readonly BcsType<any, any>[],\n\t\tconst Name extends string =\n\t\t\t`(${JoinString<{ [K in keyof T]: T[K] extends BcsType<any, any, infer T> ? T : never }, ', '>})`,\n\t>(\n\t\tfields: T,\n\t\toptions?: BcsTypeOptions<\n\t\t\t{\n\t\t\t\t-readonly [K in keyof T]: T[K] extends BcsType<infer T, any> ? T : never;\n\t\t\t},\n\t\t\t{\n\t\t\t\t[K in keyof T]: T[K] extends BcsType<any, infer T> ? T : never;\n\t\t\t},\n\t\t\tName\n\t\t>,\n\t) {\n\t\treturn new BcsTuple<T, Name>({\n\t\t\tfields,\n\t\t\t...options,\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType representing a struct of a given set of fields\n\t * @param name The name of the struct\n\t * @param fields The fields of the struct. The order of the fields affects how data is serialized and deserialized\n\t *\n\t * @example\n\t * const struct = bcs.struct('MyStruct', {\n\t *  a: bcs.u8(),\n\t *  b: bcs.string(),\n\t * })\n\t * struct.serialize({ a: 1, b: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]\n\t */\n\tstruct<T extends Record<string, BcsType<any>>, const Name extends string = string>(\n\t\tname: Name,\n\t\tfields: T,\n\t\toptions?: Omit<\n\t\t\tBcsTypeOptions<\n\t\t\t\t{\n\t\t\t\t\t[K in keyof T]: T[K] extends BcsType<infer U, any> ? U : never;\n\t\t\t\t},\n\t\t\t\t{\n\t\t\t\t\t[K in keyof T]: T[K] extends BcsType<any, infer U> ? U : never;\n\t\t\t\t}\n\t\t\t>,\n\t\t\t'name'\n\t\t>,\n\t) {\n\t\treturn new BcsStruct<T>({\n\t\t\tname,\n\t\t\tfields,\n\t\t\t...options,\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType representing an enum of a given set of options\n\t * @param name The name of the enum\n\t * @param values The values of the enum. The order of the values affects how data is serialized and deserialized.\n\t * null can be used to represent a variant with no data.\n\t *\n\t * @example\n\t * const enum = bcs.enum('MyEnum', {\n\t *   A: bcs.u8(),\n\t *   B: bcs.string(),\n\t *   C: null,\n\t * })\n\t * enum.serialize({ A: 1 }).toBytes() // Uint8Array [ 0, 1 ]\n\t * enum.serialize({ B: 'a' }).toBytes() // Uint8Array [ 1, 1, 97 ]\n\t * enum.serialize({ C: true }).toBytes() // Uint8Array [ 2 ]\n\t */\n\tenum<T extends Record<string, BcsType<any> | null>, const Name extends string = string>(\n\t\tname: Name,\n\t\tfields: T,\n\t\toptions?: Omit<\n\t\t\tBcsTypeOptions<\n\t\t\t\tEnumOutputShape<{\n\t\t\t\t\t[K in keyof T]: T[K] extends BcsType<infer U, any, any> ? U : true;\n\t\t\t\t}>,\n\t\t\t\tEnumInputShape<{\n\t\t\t\t\t[K in keyof T]: T[K] extends BcsType<any, infer U, any> ? U : boolean | object | null;\n\t\t\t\t}>,\n\t\t\t\tName\n\t\t\t>,\n\t\t\t'name'\n\t\t>,\n\t) {\n\t\treturn new BcsEnum<T, Name>({\n\t\t\tname,\n\t\t\tfields,\n\t\t\t...options,\n\t\t});\n\t},\n\n\t/**\n\t * Creates a BcsType representing a map of a given key and value type\n\t * @param keyType The BcsType of the key\n\t * @param valueType The BcsType of the value\n\t * @example\n\t * const map = bcs.map(bcs.u8(), bcs.string())\n\t * map.serialize(new Map([[2, 'a']])).toBytes() // Uint8Array [ 1, 2, 1, 97 ]\n\t */\n\tmap,\n\n\t/**\n\t * Creates a BcsType that wraps another BcsType which is lazily evaluated. This is useful for creating recursive types.\n\t * @param cb A callback that returns the BcsType\n\t */\n\tlazy<T extends BcsType<any>>(cb: () => T): T {\n\t\treturn lazyBcsType(cb) as T;\n\t},\n};\n"],"mappings":"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"}

package/dist/index.d.mts

@@ -0,0 +1,8 @@
+import { BcsReader } from "./reader.mjs";
+import { Encoding, EnumInputShape, EnumOutputShape, EnumOutputShapeWithKeys, InferBcsInput, InferBcsType, JoinString } from "./types.mjs";
+import { BcsWriter, BcsWriterOptions } from "./writer.mjs";
+import { BcsEnum, BcsStruct, BcsTuple, BcsType, BcsTypeOptions, SerializedBcs, isSerializedBcs } from "./bcs-type.mjs";
+import { bcs, compareBcsBytes } from "./bcs.mjs";
+import { decodeStr, encodeStr, splitGenericParameters } from "./utils.mjs";
+import { fromBase58, fromBase64, fromHex, toBase58, toBase64, toHex } from "@haneullabs/utils";
+export { BcsEnum, BcsReader, BcsStruct, BcsTuple, BcsType, type BcsTypeOptions, BcsWriter, type BcsWriterOptions, type Encoding, type EnumInputShape, type EnumOutputShape, type EnumOutputShapeWithKeys, type InferBcsInput, type InferBcsType, type JoinString, SerializedBcs, bcs, compareBcsBytes, decodeStr, encodeStr, fromBase58, fromBase64, fromHex, isSerializedBcs, splitGenericParameters, toBase58, toBase64, toHex };

package/dist/index.mjs

@@ -0,0 +1,8 @@
+import { BcsReader } from "./reader.mjs";
+import { decodeStr, encodeStr, splitGenericParameters } from "./utils.mjs";
+import { BcsWriter } from "./writer.mjs";
+import { BcsEnum, BcsStruct, BcsTuple, BcsType, SerializedBcs, isSerializedBcs } from "./bcs-type.mjs";
+import { bcs, compareBcsBytes } from "./bcs.mjs";
+import { fromBase58, fromBase64, fromHex, toBase58, toBase64, toHex } from "@haneullabs/utils";
+
+export { BcsEnum, BcsReader, BcsStruct, BcsTuple, BcsType, BcsWriter, SerializedBcs, bcs, compareBcsBytes, decodeStr, encodeStr, fromBase58, fromBase64, fromHex, isSerializedBcs, splitGenericParameters, toBase58, toBase64, toHex };

package/dist/reader.d.mts

@@ -0,0 +1,96 @@
+//#region src/reader.d.ts
+/**
+ * Class used for reading BCS data chunk by chunk. Meant to be used
+ * by some wrapper, which will make sure that data is valid and is
+ * matching the desired format.
+ *
+ * @example
+ * // data for this example is:
+ * // { a: u8, b: u32, c: bool, d: u64 }
+ *
+ * let reader = new BcsReader("647f1a060001ffffe7890423c78a050102030405");
+ * let field1 = reader.read8();
+ * let field2 = reader.read32();
+ * let field3 = reader.read8() === '1'; // bool
+ * let field4 = reader.read64();
+ * // ....
+ *
+ * Reading vectors is another deal in bcs. To read a vector, you first need to read
+ * its length using {@link readULEB}. Here's an example:
+ * @example
+ * // data encoded: { field: [1, 2, 3, 4, 5] }
+ * let reader = new BcsReader("050102030405");
+ * let vec_length = reader.readULEB();
+ * let elements = [];
+ * for (let i = 0; i < vec_length; i++) {
+ *   elements.push(reader.read8());
+ * }
+ * console.log(elements); // [1,2,3,4,5]
+ *
+ * @param {String} data HEX-encoded data (serialized BCS)
+ */
+declare class BcsReader {
+  private dataView;
+  private bytePosition;
+  /**
+   * @param {Uint8Array} data Data to use as a buffer.
+   */
+  constructor(data: Uint8Array);
+  /**
+   * Shift current cursor position by `bytes`.
+   *
+   * @param {Number} bytes Number of bytes to
+   * @returns {this} Self for possible chaining.
+   */
+  shift(bytes: number): this;
+  /**
+   * Read U8 value from the buffer and shift cursor by 1.
+   * @returns
+   */
+  read8(): number;
+  /**
+   * Read U16 value from the buffer and shift cursor by 2.
+   * @returns
+   */
+  read16(): number;
+  /**
+   * Read U32 value from the buffer and shift cursor by 4.
+   * @returns
+   */
+  read32(): number;
+  /**
+   * Read U64 value from the buffer and shift cursor by 8.
+   * @returns
+   */
+  read64(): string;
+  /**
+   * Read U128 value from the buffer and shift cursor by 16.
+   */
+  read128(): string;
+  /**
+   * Read U128 value from the buffer and shift cursor by 32.
+   * @returns
+   */
+  read256(): string;
+  /**
+   * Read `num` number of bytes from the buffer and shift cursor by `num`.
+   * @param num Number of bytes to read.
+   */
+  readBytes(num: number): Uint8Array;
+  /**
+   * Read ULEB value - an integer of varying size. Used for enum indexes and
+   * vector lengths.
+   * @returns {Number} The ULEB value.
+   */
+  readULEB(): number;
+  /**
+   * Read a BCS vector: read a length and then apply function `cb` X times
+   * where X is the length of the vector, defined as ULEB in BCS bytes.
+   * @param cb Callback to process elements of vector.
+   * @returns {Array<Any>} Array of the resulting values, returned by callback.
+   */
+  readVec(cb: (reader: BcsReader, i: number, length: number) => any): any[];
+}
+//#endregion
+export { BcsReader };
+//# sourceMappingURL=reader.d.mts.map

package/dist/reader.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reader.d.mts","names":[],"sources":["../src/reader.ts"],"mappings":";;AAmCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,SAAA;EAAA,QACJ,QAAA;EAAA,QACA,YAAA;EA8GyD;;;cAzGrD,IAAA,EAAM,UAAA;;;;;;;EASlB,KAAA,CAAM,KAAA;;;;;EAQN,KAAA,CAAA;;;;;EASA,MAAA,CAAA;;;;;EASA,MAAA,CAAA;;;;;EASA,MAAA,CAAA;;;;EAWA,OAAA,CAAA;;;;;EAWA,OAAA,CAAA;;;;;EAWA,SAAA,CAAU,GAAA,WAAc,UAAA;;;;;;EAaxB,QAAA,CAAA;;;;;;;EAeA,OAAA,CAAQ,EAAA,GAAK,MAAA,EAAQ,SAAA,EAAW,CAAA,UAAW,MAAA;AAAA"}