wowok 2.2.3 → 2.2.5

package/dist/cjs/_deps/bcs/bcs-type.d.ts

@@ -0,0 +1,127 @@
+import { BcsReader } from "./reader.js";
+import type { BcsWriterOptions } from "./writer.js";
+import { BcsWriter } from "./writer.js";
+import type { EnumInputShape, EnumOutputShape, JoinString } from "./types.js";
+export interface BcsTypeOptions<T, Input = T, Name extends string = string> {
+    name?: Name;
+    validate?: (value: Input) => void;
+}
+export declare class BcsType<T, Input = T, const Name extends string = string> {
+    #private;
+    $inferType: T;
+    $inferInput: Input;
+    name: Name;
+    read: (reader: BcsReader) => T;
+    serializedSize: (value: Input, options?: BcsWriterOptions) => number | null;
+    validate: (value: Input) => void;
+    constructor(options: {
+        name: Name;
+        read: (reader: BcsReader) => T;
+        write: (value: Input, writer: BcsWriter) => void;
+        serialize?: (value: Input, options?: BcsWriterOptions) => Uint8Array<ArrayBuffer>;
+        serializedSize?: (value: Input) => number | null;
+        validate?: (value: Input) => void;
+    } & BcsTypeOptions<T, Input, Name>);
+    write(value: Input, writer: BcsWriter): void;
+    serialize(value: Input, options?: BcsWriterOptions): SerializedBcs<T, Input>;
+    parse(bytes: Uint8Array): T;
+    fromHex(hex: string): T;
+    fromBase58(b64: string): T;
+    fromBase64(b64: string): T;
+    transform<T2 = T, Input2 = Input, NewName extends string = Name>({ name, input, output, validate, }: {
+        input?: (val: Input2) => Input;
+        output?: (value: T) => T2;
+    } & BcsTypeOptions<T2, Input2, NewName>): BcsType<T2, Input2, NewName>;
+}
+declare const SERIALIZED_BCS_BRAND: never;
+export declare function isSerializedBcs(obj: unknown): obj is SerializedBcs<unknown>;
+export declare class SerializedBcs<T, Input = T> {
+    #private;
+    [SERIALIZED_BCS_BRAND]: boolean;
+    constructor(schema: BcsType<T, Input>, bytes: Uint8Array<ArrayBuffer>);
+    toBytes(): Uint8Array<ArrayBuffer>;
+    toHex(): string;
+    toBase64(): string;
+    toBase58(): string;
+    parse(): T;
+}
+export declare function fixedSizeBcsType<T, Input = T, const Name extends string = string>({ size, ...options }: {
+    name: Name;
+    size: number;
+    read: (reader: BcsReader) => T;
+    write: (value: Input, writer: BcsWriter) => void;
+} & BcsTypeOptions<T, Input, Name>): BcsType<T, Input, Name>;
+export declare function uIntBcsType<const Name extends string = string>({ readMethod, writeMethod, ...options }: {
+    name: Name;
+    size: number;
+    readMethod: `read${8 | 16 | 32}`;
+    writeMethod: `write${8 | 16 | 32}`;
+    maxValue: number;
+} & BcsTypeOptions<number, number, Name>): BcsType<number, number, Name>;
+export declare function bigUIntBcsType<const Name extends string = string>({ readMethod, writeMethod, ...options }: {
+    name: Name;
+    size: number;
+    readMethod: `read${64 | 128 | 256}`;
+    writeMethod: `write${64 | 128 | 256}`;
+    maxValue: bigint;
+} & BcsTypeOptions<string, string | number | bigint>): BcsType<string, string | number | bigint, Name>;
+export declare function dynamicSizeBcsType<T, Input = T, const Name extends string = string>({ serialize, ...options }: {
+    name: Name;
+    read: (reader: BcsReader) => T;
+    serialize: (value: Input, options?: BcsWriterOptions) => Uint8Array<ArrayBuffer>;
+} & BcsTypeOptions<T, Input>): BcsType<T, Input, string>;
+export declare function stringLikeBcsType<const Name extends string = string>({ toBytes, fromBytes, ...options }: {
+    name: Name;
+    toBytes: (value: string) => Uint8Array;
+    fromBytes: (bytes: Uint8Array) => string;
+    serializedSize?: (value: string) => number | null;
+} & BcsTypeOptions<string, string, Name>): BcsType<string, string, Name>;
+export declare function lazyBcsType<T, Input>(cb: () => BcsType<T, Input>): BcsType<T, Input, string>;
+export interface BcsStructOptions<T extends Record<string, BcsType<any>>, Name extends string = string> extends 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>, "name"> {
+    name: Name;
+    fields: T;
+}
+export declare class BcsStruct<T extends Record<string, BcsType<any>>, const Name extends string = string> extends BcsType<{
+    [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> {
+    constructor({ name, fields, ...options }: BcsStructOptions<T, Name>);
+}
+export interface BcsEnumOptions<T extends Record<string, BcsType<any> | null>, Name extends string = string> extends 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"> {
+    name: Name;
+    fields: T;
+}
+export declare class BcsEnum<T extends Record<string, BcsType<any> | null>, const Name extends string = string> extends BcsType<EnumOutputShape<{
+    [K in keyof T]: T[K] extends BcsType<infer U, any> ? U : true;
+}>, EnumInputShape<{
+    [K in keyof T]: T[K] extends BcsType<any, infer U, any> ? U : boolean | object | null;
+}>, Name> {
+    constructor({ fields, ...options }: BcsEnumOptions<T, Name>);
+}
+export interface BcsTupleOptions<T extends readonly BcsType<any>[], Name extends string> extends Omit<BcsTypeOptions<{
+    -readonly [K in keyof T]: T[K] extends BcsType<infer T, any> ? T : never;
+}, {
+    [K in keyof T]: T[K] extends BcsType<any, infer T> ? T : never;
+}, Name>, "name"> {
+    name?: Name;
+    fields: T;
+}
+export declare class BcsTuple<const T extends readonly BcsType<any>[], const Name extends string = `(${JoinString<{
+    [K in keyof T]: T[K] extends BcsType<any, any, infer T> ? T : never;
+}, ", ">})`> extends BcsType<{
+    -readonly [K in keyof T]: T[K] extends BcsType<infer T, any> ? T : never;
+}, {
+    [K in keyof T]: T[K] extends BcsType<any, infer T> ? T : never;
+}, Name> {
+    constructor({ fields, name, ...options }: BcsTupleOptions<T, Name>);
+}
+export {};

package/dist/cjs/_deps/bcs/bcs-type.js

@@ -0,0 +1 @@
+import{fromBase58,fromBase64,toBase58,toBase64,fromHex,toHex}from'../utils/index.js';import{BcsReader}from'./reader.js';import{ulebEncode}from'./uleb.js';import{BcsWriter}from'./writer.js';export class BcsType{['$inferType'];['$inferInput'];['name'];['read'];['serializedSize'];['validate'];#write;#serialize;constructor(a){this['name']=a['name'],this['read']=a['read'],this['serializedSize']=a['serializedSize']??(()=>null),this.#write=a['write'],this.#serialize=a['serialize']??((b,c)=>{const d=new BcsWriter({'initialSize':this['serializedSize'](b)??undefined,...c});return this.#write(b,d),d['toBytes']();}),this['validate']=a['validate']??(()=>{});}['write'](a,b){this['validate'](a),this.#write(a,b);}['serialize'](a,b){return this['validate'](a),new SerializedBcs(this,this.#serialize(a,b));}['parse'](a){const b=new BcsReader(a);return this['read'](b);}['fromHex'](a){return this['parse'](fromHex(a));}['fromBase58'](a){return this['parse'](fromBase58(a));}['fromBase64'](a){return this['parse'](fromBase64(a));}['transform']({name:a,input:b,output:c,validate:d}){return new BcsType({'name':a??this['name'],'read':e=>c?c(this['read'](e)):this['read'](e),'write':(e,f)=>this.#write(b?b(e):e,f),'serializedSize':e=>this['serializedSize'](b?b(e):e),'serialize':(e,f)=>this.#serialize(b?b(e):e,f),'validate':e=>{d?.(e),this['validate'](b?b(e):e);}});}}const SERIALIZED_BCS_BRAND=Symbol['for']('@mysten/serialized-bcs');export function isSerializedBcs(a){return!!a&&typeof a==='object'&&a[SERIALIZED_BCS_BRAND]===!![];}export class SerializedBcs{#schema;#bytes;get[SERIALIZED_BCS_BRAND](){return!![];}constructor(a,b){this.#schema=a,this.#bytes=b;}['toBytes'](){return this.#bytes;}['toHex'](){return toHex(this.#bytes);}['toBase64'](){return toBase64(this.#bytes);}['toBase58'](){return toBase58(this.#bytes);}['parse'](){return this.#schema['parse'](this.#bytes);}}export function fixedSizeBcsType({size:a,...b}){return new BcsType({...b,'serializedSize':()=>a});}export function uIntBcsType({readMethod:a,writeMethod:b,...c}){return fixedSizeBcsType({...c,'read':d=>d[a](),'write':(d,e)=>e[b](d),'validate':d=>{if(d<0x0||d>c['maxValue'])throw new TypeError('Invalid\x20'+c['name']+'\x20value:\x20'+d+'.\x20Expected\x20value\x20in\x20range\x200-'+c['maxValue']);c['validate']?.(d);}});}export function bigUIntBcsType({readMethod:a,writeMethod:b,...c}){return fixedSizeBcsType({...c,'read':d=>d[a](),'write':(d,e)=>e[b](BigInt(d)),'validate':d=>{const e=BigInt(d);if(e<0x0||e>c['maxValue'])throw new TypeError('Invalid\x20'+c['name']+'\x20value:\x20'+e+'.\x20Expected\x20value\x20in\x20range\x200-'+c['maxValue']);c['validate']?.(e);}});}export function dynamicSizeBcsType({serialize:a,...b}){const c=new BcsType({...b,'serialize':a,'write':(d,e)=>{for(const f of c['serialize'](d)['toBytes']()){e['write8'](f);}}});return c;}export function stringLikeBcsType({toBytes:a,fromBytes:b,...c}){return new BcsType({...c,'read':d=>{const e=d['readULEB'](),f=d['readBytes'](e);return b(f);},'write':(d,e)=>{const f=a(d);e['writeULEB'](f['length']);for(let g=0x0;g<f['length'];g++){e['write8'](f[g]);}},'serialize':d=>{const e=a(d),f=ulebEncode(e['length']),g=new Uint8Array(f['length']+e['length']);return g['set'](f,0x0),g['set'](e,f['length']),g;},'validate':d=>{if(typeof d!=='string')throw new TypeError('Invalid\x20'+c['name']+'\x20value:\x20'+d+'.\x20Expected\x20string');c['validate']?.(d);}});}export function lazyBcsType(a){let b=null;function c(){return!b&&(b=a()),b;}return new BcsType({'name':'lazy','read':d=>c()['read'](d),'serializedSize':d=>c()['serializedSize'](d),'write':(d,e)=>c()['write'](d,e),'serialize':(d,e)=>c()['serialize'](d,e)['toBytes']()});}export class BcsStruct extends BcsType{constructor({name:a,fields:b,...c}){const d=Object['entries'](b);super({'name':a,'serializedSize':e=>{let f=0x0;for(const [g,h]of d){const i=h['serializedSize'](e[g]);if(i==null)return null;f+=i;}return f;},'read':e=>{const f={};for(const [g,h]of d){f[g]=h['read'](e);}return f;},'write':(e,f)=>{for(const [g,h]of d){h['write'](e[g],f);}},...c,'validate':e=>{c?.['validate']?.(e);if(typeof e!=='object'||e==null)throw new TypeError('Expected\x20object,\x20found\x20'+typeof e);}});}}export class BcsEnum extends BcsType{constructor({fields:a,...b}){const c=Object['entries'](a);super({'read':d=>{const e=d['readULEB'](),f=c[e];if(!f)throw new TypeError('Unknown\x20value\x20'+e+'\x20for\x20enum\x20'+b['name']);const [g,h]=f;return{[g]:h?.['read'](d)??!![],'$kind':g};},'write':(d,e)=>{const [f,g]=Object['entries'](d)['filter'](([h])=>Object['hasOwn'](a,h))[0x0];for(let h=0x0;h<c['length'];h++){const [j,k]=c[h];if(j===f){e['writeULEB'](h),k?.['write'](g,e);return;}}},...b,'validate':d=>{b?.['validate']?.(d);if(typeof d!=='object'||d==null)throw new TypeError('Expected\x20object,\x20found\x20'+typeof d);const e=Object['keys'](d)['filter'](g=>d[g]!==undefined&&Object['hasOwn'](a,g));if(e['length']!==0x1)throw new TypeError('Expected\x20object\x20with\x20one\x20key,\x20but\x20found\x20'+e['length']+'\x20for\x20type\x20'+b['name']+'}');const [f]=e;if(!Object['hasOwn'](a,f))throw new TypeError('Invalid\x20enum\x20variant\x20'+f);}});}}export class BcsTuple extends BcsType{constructor({fields:a,name:b,...c}){super({'name':b??'('+a['map'](d=>d['name'])['join'](',\x20')+')','serializedSize':d=>{let e=0x0;for(let f=0x0;f<a['length'];f++){const g=a[f]['serializedSize'](d[f]);if(g==null)return null;e+=g;}return e;},'read':d=>{const e=[];for(const f of a){e['push'](f['read'](d));}return e;},'write':(d,e)=>{for(let f=0x0;f<a['length'];f++){a[f]['write'](d[f],e);}},...c,'validate':d=>{c?.['validate']?.(d);if(!Array['isArray'](d))throw new TypeError('Expected\x20array,\x20found\x20'+typeof d);if(d['length']!==a['length'])throw new TypeError('Expected\x20array\x20of\x20length\x20'+a['length']+',\x20found\x20'+d['length']);}});}}

package/dist/cjs/_deps/bcs/bcs.d.ts

@@ -0,0 +1,49 @@
+import type { BcsTypeOptions } from "./bcs-type.js";
+import { BcsEnum, BcsStruct, BcsTuple, BcsType } from "./bcs-type.js";
+import type { EnumInputShape, EnumOutputShape, InferBcsInput, InferBcsType, JoinString } from "./types.js";
+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}>`>;
+declare function map<K extends BcsType<any>, V extends BcsType<any>>(keyType: K, valueType: V): BcsType<Map<InferBcsType<K>, InferBcsType<V>>, Map<InferBcsInput<K>, InferBcsInput<V>>, `Map<${K["name"]}, ${V["name"]}>`>;
+declare function map<K, V, InputK = K, InputV = V>(keyType: BcsType<K, InputK>, valueType: BcsType<V, InputV>): BcsType<Map<K, V>, Map<InputK, InputV>, `Map<${string}, ${string}>`>;
+export declare const bcs: {
+    u8(options?: BcsTypeOptions<number>): BcsType<number, number, "u8">;
+    u16(options?: BcsTypeOptions<number>): BcsType<number, number, "u16">;
+    u32(options?: BcsTypeOptions<number>): BcsType<number, number, "u32">;
+    u64(options?: BcsTypeOptions<string, number | bigint | string>): BcsType<string, string | number | bigint, "u64">;
+    u128(options?: BcsTypeOptions<string, number | bigint | string>): BcsType<string, string | number | bigint, "u128">;
+    u256(options?: BcsTypeOptions<string, number | bigint | string>): BcsType<string, string | number | bigint, "u256">;
+    bool(options?: BcsTypeOptions<boolean>): BcsType<boolean, boolean, "bool">;
+    uleb128(options?: BcsTypeOptions<number>): BcsType<number, number, string>;
+    bytes<T extends number>(size: T, options?: BcsTypeOptions<Uint8Array, Iterable<number>>): BcsType<Uint8Array<ArrayBufferLike>, Iterable<number>, `bytes[${T}]`>;
+    byteVector(options?: BcsTypeOptions<Uint8Array, Iterable<number>>): BcsType<Uint8Array<ArrayBufferLike>, Iterable<number>, "vector<u8>">;
+    string(options?: BcsTypeOptions<string>): BcsType<string, string, "string">;
+    fixedArray: typeof fixedArray;
+    option: typeof option;
+    vector: typeof vector;
+    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>;
+    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>;
+    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>;
+    map: typeof map;
+    lazy<T extends BcsType<any>>(cb: () => T): T;
+};
+export {};

package/dist/cjs/_deps/bcs/bcs.js

@@ -0,0 +1 @@
+import{BcsEnum,BcsStruct,BcsTuple,BcsType,bigUIntBcsType,dynamicSizeBcsType,fixedSizeBcsType,lazyBcsType,stringLikeBcsType,uIntBcsType}from'./bcs-type.js';import{ulebEncode}from'./uleb.js';function fixedArray(a,b,c){return new BcsType({'read':d=>{const e=new Array(a);for(let f=0x0;f<a;f++){e[f]=b['read'](d);}return e;},'write':(d,e)=>{for(const f of d){b['write'](f,e);}},...c,'name':c?.['name']??b['name']+'['+a+']','validate':d=>{c?.['validate']?.(d);if(!d||typeof d!=='object'||!('length'in d))throw new TypeError('Expected\x20array,\x20found\x20'+typeof d);if(d['length']!==a)throw new TypeError('Expected\x20array\x20of\x20length\x20'+a+',\x20found\x20'+d['length']);}});}function option(a){return bcs['enum']('Option<'+a['name']+'>',{'None':null,'Some':a})['transform']({'input':b=>{if(b==null)return{'None':!![]};return{'Some':b};},'output':b=>{if(b['$kind']==='Some')return b['Some'];return null;}});}function vector(a,b){return new BcsType({'read':c=>{const d=c['readULEB'](),e=new Array(d);for(let f=0x0;f<d;f++){e[f]=a['read'](c);}return e;},'write':(c,d)=>{d['writeULEB'](c['length']);for(const e of c){a['write'](e,d);}},...b,'name':b?.['name']??'vector<'+a['name']+'>','validate':c=>{b?.['validate']?.(c);if(!c||typeof c!=='object'||!('length'in c))throw new TypeError('Expected\x20array,\x20found\x20'+typeof c);}});}function map(a,b){return bcs['vector'](bcs['tuple']([a,b]))['transform']({'name':'Map<'+a['name']+',\x20'+b['name']+'>','input':c=>{return[...c['entries']()];},'output':c=>{const d=new Map();for(const [e,f]of c){d['set'](e,f);}return d;}});}export const bcs={'u8'(a){return uIntBcsType({'readMethod':'read8','writeMethod':'write8','size':0x1,'maxValue':0x2**0x8-0x1,...a,'name':a?.['name']??'u8'});},'u16'(a){return uIntBcsType({'readMethod':'read16','writeMethod':'write16','size':0x2,'maxValue':0x2**0x10-0x1,...a,'name':a?.['name']??'u16'});},'u32'(a){return uIntBcsType({'readMethod':'read32','writeMethod':'write32','size':0x4,'maxValue':0x2**0x20-0x1,...a,'name':a?.['name']??'u32'});},'u64'(a){return bigUIntBcsType({'readMethod':'read64','writeMethod':'write64','size':0x8,'maxValue':0x2n**0x40n-0x1n,...a,'name':a?.['name']??'u64'});},'u128'(a){return bigUIntBcsType({'readMethod':'read128','writeMethod':'write128','size':0x10,'maxValue':0x2n**0x80n-0x1n,...a,'name':a?.['name']??'u128'});},'u256'(a){return bigUIntBcsType({'readMethod':'read256','writeMethod':'write256','size':0x20,'maxValue':0x2n**0x100n-0x1n,...a,'name':a?.['name']??'u256'});},'bool'(a){return fixedSizeBcsType({'size':0x1,'read':b=>b['read8']()===0x1,'write':(b,c)=>c['write8'](b?0x1:0x0),...a,'name':a?.['name']??'bool','validate':b=>{a?.['validate']?.(b);if(typeof b!=='boolean')throw new TypeError('Expected\x20boolean,\x20found\x20'+typeof b);}});},'uleb128'(a){return dynamicSizeBcsType({'read':b=>b['readULEB'](),'serialize':b=>{return Uint8Array['from'](ulebEncode(b));},...a,'name':a?.['name']??'uleb128'});},'bytes'(a,b){return fixedSizeBcsType({'size':a,'read':c=>c['readBytes'](a),'write':(c,d)=>{d['writeBytes'](new Uint8Array(c));},...b,'name':b?.['name']??'bytes['+a+']','validate':c=>{b?.['validate']?.(c);if(!c||typeof c!=='object'||!('length'in c))throw new TypeError('Expected\x20array,\x20found\x20'+typeof c);if(c['length']!==a)throw new TypeError('Expected\x20array\x20of\x20length\x20'+a+',\x20found\x20'+c['length']);}});},'byteVector'(a){return new BcsType({'read':b=>{const c=b['readULEB']();return b['readBytes'](c);},'write':(b,c)=>{const d=new Uint8Array(b);c['writeULEB'](d['length']),c['writeBytes'](d);},...a,'name':a?.['name']??'vector<u8>','serializedSize':b=>{const c='length'in b?b['length']:null;return c==null?null:ulebEncode(c)['length']+c;},'validate':b=>{a?.['validate']?.(b);if(!b||typeof b!=='object'||!('length'in b))throw new TypeError('Expected\x20array,\x20found\x20'+typeof b);}});},'string'(a){return stringLikeBcsType({'toBytes':b=>new TextEncoder()['encode'](b),'fromBytes':b=>new TextDecoder()['decode'](b),...a,'name':a?.['name']??'string'});},'fixedArray':fixedArray,'option':option,'vector':vector,'tuple'(a,b){return new BcsTuple({'fields':a,...b});},'struct'(a,b,c){return new BcsStruct({'name':a,'fields':b,...c});},'enum'(a,b,c){return new BcsEnum({'name':a,'fields':b,...c});},'map':map,'lazy'(a){return lazyBcsType(a);}};

package/dist/cjs/_deps/bcs/index.d.ts

@@ -0,0 +1,16 @@
+import { toBase58, fromBase58, toBase64, fromBase64, toHex, fromHex } from "../utils/index.js";
+import type { BcsTypeOptions } from "./bcs-type.js";
+import { BcsType, BcsStruct, BcsEnum, BcsTuple, isSerializedBcs, SerializedBcs } from "./bcs-type.js";
+import { bcs } from "./bcs.js";
+import { BcsReader } from "./reader.js";
+import type { EnumInputShape, EnumOutputShape, EnumOutputShapeWithKeys, InferBcsInput, InferBcsType } from "./types.js";
+import { decodeStr, encodeStr, splitGenericParameters } from "./utils.js";
+import type { BcsWriterOptions } from "./writer.js";
+import { BcsWriter } from "./writer.js";
+export { bcs, BcsType, BcsStruct, BcsEnum, BcsTuple, type BcsTypeOptions, SerializedBcs, isSerializedBcs, toBase58, fromBase58, toBase64, fromBase64, toHex, fromHex, encodeStr, decodeStr, splitGenericParameters, BcsReader, BcsWriter, type BcsWriterOptions, type InferBcsInput, type InferBcsType, type EnumOutputShape, type EnumInputShape, type EnumOutputShapeWithKeys, };
+export declare const toB58: (buffer: Uint8Array) => string;
+export declare const fromB58: (str: string) => Uint8Array<ArrayBuffer>;
+export declare const toB64: typeof toBase64;
+export declare const fromB64: typeof fromBase64;
+export declare const toHEX: typeof toHex;
+export declare const fromHEX: typeof fromHex;

package/dist/cjs/_deps/bcs/index.js

@@ -0,0 +1 @@
+import{toBase58,fromBase58,toBase64,fromBase64,toHex,fromHex}from'../utils/index.js';import{BcsType,BcsStruct,BcsEnum,BcsTuple,isSerializedBcs,SerializedBcs}from'./bcs-type.js';import{bcs}from'./bcs.js';import{BcsReader}from'./reader.js';import{decodeStr,encodeStr,splitGenericParameters}from'./utils.js';import{BcsWriter}from'./writer.js';export{bcs,BcsType,BcsStruct,BcsEnum,BcsTuple,SerializedBcs,isSerializedBcs,toBase58,fromBase58,toBase64,fromBase64,toHex,fromHex,encodeStr,decodeStr,splitGenericParameters,BcsReader,BcsWriter};export const toB58=toBase58;export const fromB58=fromBase58;export const toB64=toBase64;export const fromB64=fromBase64;export const toHEX=toHex;export const fromHEX=fromHex;

package/dist/cjs/_deps/bcs/reader.d.ts

@@ -0,0 +1,15 @@
+export declare class BcsReader {
+    private dataView;
+    private bytePosition;
+    constructor(data: Uint8Array);
+    shift(bytes: number): this;
+    read8(): number;
+    read16(): number;
+    read32(): number;
+    read64(): string;
+    read128(): string;
+    read256(): string;
+    readBytes(num: number): Uint8Array;
+    readULEB(): number;
+    readVec(cb: (reader: BcsReader, i: number, length: number) => any): any[];
+}

package/dist/cjs/_deps/bcs/reader.js

@@ -0,0 +1 @@
+import{ulebDecode}from'./uleb.js';export class BcsReader{['dataView'];['bytePosition']=0x0;constructor(a){this['dataView']=new DataView(a['buffer'],a['byteOffset'],a['byteLength']);}['shift'](a){return this['bytePosition']+=a,this;}['read8'](){const a=this['dataView']['getUint8'](this['bytePosition']);return this['shift'](0x1),a;}['read16'](){const a=this['dataView']['getUint16'](this['bytePosition'],!![]);return this['shift'](0x2),a;}['read32'](){const a=this['dataView']['getUint32'](this['bytePosition'],!![]);return this['shift'](0x4),a;}['read64'](){const a=this['read32'](),b=this['read32'](),c=b['toString'](0x10)+a['toString'](0x10)['padStart'](0x8,'0');return BigInt('0x'+c)['toString'](0xa);}['read128'](){const a=BigInt(this['read64']()),b=BigInt(this['read64']()),c=b['toString'](0x10)+a['toString'](0x10)['padStart'](0x10,'0');return BigInt('0x'+c)['toString'](0xa);}['read256'](){const a=BigInt(this['read128']()),b=BigInt(this['read128']()),c=b['toString'](0x10)+a['toString'](0x10)['padStart'](0x20,'0');return BigInt('0x'+c)['toString'](0xa);}['readBytes'](a){const b=this['bytePosition']+this['dataView']['byteOffset'],c=new Uint8Array(this['dataView']['buffer'],b,a);return this['shift'](a),c;}['readULEB'](){const a=this['bytePosition']+this['dataView']['byteOffset'],b=new Uint8Array(this['dataView']['buffer'],a),{value:c,length:d}=ulebDecode(b);return this['shift'](d),c;}['readVec'](a){const b=this['readULEB'](),c=[];for(let d=0x0;d<b;d++){c['push'](a(this,d,b));}return c;}}

package/dist/cjs/_deps/bcs/types.d.ts

@@ -0,0 +1,24 @@
+import type { Simplify } from "../utils/index.js";
+import type { BcsType } from "./bcs-type.js";
+export type Encoding = "base58" | "base64" | "hex";
+export type InferBcsType<T extends BcsType<any>> = T extends BcsType<infer U, any> ? U : never;
+export type InferBcsInput<T extends BcsType<any, any>> = T extends BcsType<any, infer U> ? U : never;
+export type EnumOutputShape<T extends Record<string, unknown>, Keys extends string = Extract<keyof T, string>, Values = T[keyof T] extends infer Type ? Type extends BcsType<infer U> ? U : never : never> = 0 extends Values ? EnumOutputShapeWithKeys<T, never> : 0n extends Values ? EnumOutputShapeWithKeys<T, never> : "" extends Values ? EnumOutputShapeWithKeys<T, never> : false extends Values ? EnumOutputShapeWithKeys<T, never> : EnumOutputShapeWithKeys<T, Keys>;
+export type EnumOutputShapeWithKeys<T extends Record<string, unknown>, Keys extends string> = {
+    [K in keyof T]: Exclude<Keys, K> extends infer Empty extends string ? Simplify<{
+        [K2 in K]: T[K];
+    } & {
+        [K in Empty]?: never;
+    } & {
+        $kind: K;
+    }> : never;
+}[keyof T];
+export type EnumInputShape<T extends Record<string, unknown>> = {
+    [K in keyof T]: {
+        [K2 in K]: T[K];
+    };
+}[keyof T];
+export type JoinString<T, Sep extends string> = T extends readonly [
+    infer F extends string,
+    ...infer R extends string[]
+] ? [] extends R ? F : `${F}${Sep}${JoinString<R, Sep>}` : "";

package/dist/cjs/_deps/bcs/uleb.d.ts

@@ -0,0 +1,5 @@
+export declare function ulebEncode(num: number | bigint): number[];
+export declare function ulebDecode(arr: number[] | Uint8Array): {
+    value: number;
+    length: number;
+};

package/dist/cjs/_deps/bcs/uleb.js

@@ -0,0 +1 @@
+export function ulebEncode(a){let b=BigInt(a);const c=[];let d=0x0;if(b===0x0n)return[0x0];while(b>0x0){c[d]=Number(b&0x7fn),b>>=0x7n,b>0x0n&&(c[d]|=0x80),d+=0x1;}return c;}export function ulebDecode(a){let b=0x0n,c=0x0n,d=0x0;while(!![]){if(d>=a['length'])throw new Error('ULEB\x20decode\x20error:\x20buffer\x20overflow');const e=a[d];d+=0x1,b+=BigInt(e&0x7f)<<c;if((e&0x80)===0x0)break;c+=0x7n;}if(b>BigInt(Number['MAX_SAFE_INTEGER']))throw new Error('ULEB\x20decode\x20error:\x20value\x20exceeds\x20MAX_SAFE_INTEGER');return{'value':Number(b),'length':d};}

package/dist/cjs/_deps/bcs/utils.d.ts

@@ -0,0 +1,4 @@
+import type { Encoding } from "./types.js";
+export declare function encodeStr(data: Uint8Array, encoding: Encoding): string;
+export declare function decodeStr(data: string, encoding: Encoding): Uint8Array;
+export declare function splitGenericParameters(str: string, genericSeparators?: [string, string]): any[];

package/dist/cjs/_deps/bcs/utils.js

@@ -0,0 +1 @@
+import{fromBase58,fromBase64,fromHex,toBase58,toBase64,toHex}from'../utils/index.js';export function encodeStr(a,b){switch(b){case'base58':return toBase58(a);case'base64':return toBase64(a);case'hex':return toHex(a);default:throw new Error('Unsupported\x20encoding,\x20supported\x20values\x20are:\x20base64,\x20hex');}}export function decodeStr(a,b){switch(b){case'base58':return fromBase58(a);case'base64':return fromBase64(a);case'hex':return fromHex(a);default:throw new Error('Unsupported\x20encoding,\x20supported\x20values\x20are:\x20base64,\x20hex');}}export function splitGenericParameters(a,b=['<','>']){const [c,d]=b,e=[];let f='',g=0x0;for(let h=0x0;h<a['length'];h++){const j=a[h];j===c&&g++;j===d&&g--;if(g===0x0&&j===','){e['push'](f['trim']()),f='';continue;}f+=j;}return e['push'](f['trim']()),e;}

package/dist/cjs/_deps/bcs/writer.d.ts

@@ -0,0 +1,28 @@
+import type { Encoding } from "./types.js";
+export interface BcsWriterOptions {
+    initialSize?: number;
+    maxSize?: number;
+    allocateSize?: number;
+}
+export declare class BcsWriter {
+    private dataView;
+    private bytePosition;
+    private size;
+    private maxSize;
+    private allocateSize;
+    constructor({ initialSize, maxSize, allocateSize, }?: BcsWriterOptions);
+    private ensureSizeOrGrow;
+    shift(bytes: number): this;
+    write8(value: number | bigint): this;
+    writeBytes(bytes: Uint8Array): this;
+    write16(value: number | bigint): this;
+    write32(value: number | bigint): this;
+    write64(value: number | bigint): this;
+    write128(value: number | bigint): this;
+    write256(value: number | bigint): this;
+    writeULEB(value: number): this;
+    writeVec(vector: any[], cb: (writer: BcsWriter, el: any, i: number, len: number) => void): this;
+    [Symbol.iterator](): Iterator<number, Iterable<number>>;
+    toBytes(): Uint8Array<ArrayBuffer>;
+    toString(encoding: Encoding): string;
+}

package/dist/cjs/_deps/bcs/writer.js

@@ -0,0 +1 @@
+import{ulebEncode}from'./uleb.js';import{encodeStr}from'./utils.js';export class BcsWriter{['dataView'];['bytePosition']=0x0;['size'];['maxSize'];['allocateSize'];constructor({initialSize:initialSize=0x400,maxSize:maxSize=Infinity,allocateSize:allocateSize=0x400}={}){this['size']=initialSize,this['maxSize']=maxSize,this['allocateSize']=allocateSize,this['dataView']=new DataView(new ArrayBuffer(initialSize));}['ensureSizeOrGrow'](a){const b=this['bytePosition']+a;if(b>this['size']){const c=Math['min'](this['maxSize'],Math['max'](this['size']+b,this['size']+this['allocateSize']));if(b>c)throw new Error('Attempting\x20to\x20serialize\x20to\x20BCS,\x20but\x20buffer\x20does\x20not\x20have\x20enough\x20size.\x20Allocated\x20size:\x20'+this['size']+',\x20Max\x20size:\x20'+this['maxSize']+',\x20Required\x20size:\x20'+b);this['size']=c;const d=new ArrayBuffer(this['size']);new Uint8Array(d)['set'](new Uint8Array(this['dataView']['buffer'])),this['dataView']=new DataView(d);}}['shift'](a){return this['bytePosition']+=a,this;}['write8'](a){return this['ensureSizeOrGrow'](0x1),this['dataView']['setUint8'](this['bytePosition'],Number(a)),this['shift'](0x1);}['writeBytes'](a){this['ensureSizeOrGrow'](a['length']);for(let b=0x0;b<a['length'];b++){this['dataView']['setUint8'](this['bytePosition']+b,a[b]);}return this['shift'](a['length']);}['write16'](a){return this['ensureSizeOrGrow'](0x2),this['dataView']['setUint16'](this['bytePosition'],Number(a),!![]),this['shift'](0x2);}['write32'](a){return this['ensureSizeOrGrow'](0x4),this['dataView']['setUint32'](this['bytePosition'],Number(a),!![]),this['shift'](0x4);}['write64'](a){return toLittleEndian(BigInt(a),0x8)['forEach'](b=>this['write8'](b)),this;}['write128'](a){return toLittleEndian(BigInt(a),0x10)['forEach'](b=>this['write8'](b)),this;}['write256'](a){return toLittleEndian(BigInt(a),0x20)['forEach'](b=>this['write8'](b)),this;}['writeULEB'](a){return ulebEncode(a)['forEach'](b=>this['write8'](b)),this;}['writeVec'](a,b){return this['writeULEB'](a['length']),Array['from'](a)['forEach']((c,d)=>b(this,c,d,a['length'])),this;}*[Symbol['iterator']](){for(let a=0x0;a<this['bytePosition'];a++){yield this['dataView']['getUint8'](a);}return this['toBytes']();}['toBytes'](){return new Uint8Array(this['dataView']['buffer']['slice'](0x0,this['bytePosition']));}['toString'](a){return encodeStr(this['toBytes'](),a);}}function toLittleEndian(a,b){const c=new Uint8Array(b);let d=0x0;while(a>0x0){c[d]=Number(a%BigInt(0x100)),a=a/BigInt(0x100),d+=0x1;}return c;}

package/dist/cjs/_deps/utils/b58.d.ts

@@ -0,0 +1,2 @@
+export declare const toBase58: (buffer: Uint8Array) => string;
+export declare const fromBase58: (str: string) => Uint8Array<ArrayBuffer>;

package/dist/cjs/_deps/utils/b58.js

@@ -0,0 +1 @@
+import{base58}from'@scure/base';export const toBase58=a=>base58['encode'](a);export const fromBase58=a=>base58['decode'](a);

package/dist/cjs/_deps/utils/b64.d.ts

@@ -0,0 +1,2 @@
+export declare function fromBase64(base64String: string): Uint8Array<ArrayBuffer>;
+export declare function toBase64(bytes: Uint8Array): string;

package/dist/cjs/_deps/utils/b64.js

@@ -0,0 +1 @@
+export function fromBase64(a){return Uint8Array['from'](atob(a),b=>b['charCodeAt'](0x0));}const CHUNK_SIZE=0x2000;export function toBase64(a){if(a['length']<CHUNK_SIZE)return btoa(String['fromCharCode'](...a));let b='';for(var c=0x0;c<a['length'];c+=CHUNK_SIZE){const d=a['slice'](c,c+CHUNK_SIZE);b+=String['fromCharCode'](...d);}return btoa(b);}

package/dist/cjs/_deps/utils/chunk.d.ts

@@ -0,0 +1 @@
+export declare function chunk<T>(array: readonly T[], size: number): T[][];

package/dist/cjs/_deps/utils/chunk.js

@@ -0,0 +1 @@
+export function chunk(a,b){return Array['from']({'length':Math['ceil'](a['length']/b)},(c,d)=>{return a['slice'](d*b,(d+0x1)*b);});}

package/dist/cjs/_deps/utils/dataloader.d.ts

@@ -0,0 +1,43 @@
+export declare class DataLoader<K, V, C = K> {
+    constructor(batchLoadFn: DataLoader.BatchLoadFn<K, V>, options?: DataLoader.Options<K, V, C>);
+    _batchLoadFn: DataLoader.BatchLoadFn<K, V>;
+    _maxBatchSize: number;
+    _batchScheduleFn: (cb: () => void) => void;
+    _cacheKeyFn: (key: K) => C;
+    _cacheMap: DataLoader.CacheMap<C, Promise<V>> | null;
+    _batch: Batch<K, V> | null;
+    load(key: K): Promise<V>;
+    loadMany(keys: ReadonlyArray<K>): Promise<Array<V | Error>>;
+    clear(key: K): this;
+    clearAll(): this;
+    prime(key: K, value: V | Promise<V> | Error): this;
+    name: string | null;
+}
+type Batch<K, V> = {
+    hasDispatched: boolean;
+    keys: Array<K>;
+    callbacks: Array<{
+        resolve: (value: V) => void;
+        reject: (error: Error) => void;
+    }>;
+    cacheHits?: Array<() => void>;
+};
+export declare namespace DataLoader {
+    type CacheMap<K, V> = {
+        get(key: K): V | void;
+        set(key: K, value: V): any;
+        delete(key: K): any;
+        clear(): any;
+    };
+    type BatchLoadFn<K, V> = (keys: ReadonlyArray<K>) => PromiseLike<ArrayLike<V | Error>>;
+    type Options<K, V, C = K> = {
+        batch?: boolean;
+        maxBatchSize?: number;
+        batchScheduleFn?: (callback: () => void) => void;
+        cache?: boolean;
+        cacheKeyFn?: (key: K) => C;
+        cacheMap?: CacheMap<C, Promise<V>> | null;
+        name?: string | null;
+    };
+}
+export {};

package/dist/cjs/_deps/utils/dataloader.js

@@ -0,0 +1 @@
+export class DataLoader{constructor(a,b){if(typeof a!=='function')throw new TypeError('DataLoader\x20must\x20be\x20constructed\x20with\x20a\x20function\x20which\x20accepts\x20'+('Array<key>\x20and\x20returns\x20Promise<Array<value>>,\x20but\x20got:\x20'+a+'.'));this['_batchLoadFn']=a,this['_maxBatchSize']=getValidMaxBatchSize(b),this['_batchScheduleFn']=getValidBatchScheduleFn(b),this['_cacheKeyFn']=getValidCacheKeyFn(b),this['_cacheMap']=getValidCacheMap(b),this['_batch']=null,this['name']=getValidName(b);}['_batchLoadFn'];['_maxBatchSize'];['_batchScheduleFn'];['_cacheKeyFn'];['_cacheMap'];['_batch'];['load'](a){if(a===null||a===undefined)throw new TypeError('The\x20loader.load()\x20function\x20must\x20be\x20called\x20with\x20a\x20value,\x20but\x20got:\x20'+String(a)+'.');const b=getCurrentBatch(this),c=this['_cacheMap'];let d;if(c){d=this['_cacheKeyFn'](a);const f=c['get'](d);if(f){const g=b['cacheHits']||(b['cacheHits']=[]);return new Promise(h=>{g['push'](()=>{h(f);});});}}b['keys']['push'](a);const e=new Promise((h,i)=>{b['callbacks']['push']({'resolve':h,'reject':i});});return c&&c['set'](d,e),e;}['loadMany'](a){if(!isArrayLike(a))throw new TypeError('The\x20loader.loadMany()\x20function\x20must\x20be\x20called\x20with\x20Array<key>,\x20but\x20got:\x20'+a+'.');const b=[];for(let c=0x0;c<a['length'];c++){b['push'](this['load'](a[c])['catch'](d=>d));}return Promise['all'](b);}['clear'](a){const b=this['_cacheMap'];if(b){const c=this['_cacheKeyFn'](a);b['delete'](c);}return this;}['clearAll'](){const a=this['_cacheMap'];return a&&a['clear'](),this;}['prime'](a,b){const c=this['_cacheMap'];if(c){const d=this['_cacheKeyFn'](a);if(c['get'](d)===undefined){let e;b instanceof Error?(e=Promise['reject'](b),e['catch'](()=>{})):e=Promise['resolve'](b),c['set'](d,e);}}return this;}['name'];}const enqueuePostPromiseJob=typeof process==='object'&&typeof process['nextTick']==='function'?function(a){!resolvedPromise&&(resolvedPromise=Promise['resolve']()),resolvedPromise['then'](()=>{process['nextTick'](a);});}:typeof setImmediate==='function'?function(a){setImmediate(a);}:function(a){setTimeout(a);};let resolvedPromise;function getCurrentBatch(a){const b=a['_batch'];if(b!==null&&!b['hasDispatched']&&b['keys']['length']<a['_maxBatchSize'])return b;const c={'hasDispatched':![],'keys':[],'callbacks':[]};return a['_batch']=c,a['_batchScheduleFn'](()=>{dispatchBatch(a,c);}),c;}function dispatchBatch(a,b){b['hasDispatched']=!![];if(b['keys']['length']===0x0){resolveCacheHits(b);return;}let c;try{c=a['_batchLoadFn'](b['keys']);}catch(d){return failedDispatch(a,b,new TypeError('DataLoader\x20must\x20be\x20constructed\x20with\x20a\x20function\x20which\x20accepts\x20'+'Array<key>\x20and\x20returns\x20Promise<Array<value>>,\x20but\x20the\x20function\x20'+('errored\x20synchronously:\x20'+String(d)+'.')));}if(!c||typeof c['then']!=='function')return failedDispatch(a,b,new TypeError('DataLoader\x20must\x20be\x20constructed\x20with\x20a\x20function\x20which\x20accepts\x20'+'Array<key>\x20and\x20returns\x20Promise<Array<value>>,\x20but\x20the\x20function\x20did\x20'+('not\x20return\x20a\x20Promise:\x20'+String(c)+'.')));Promise['resolve'](c)['then'](f=>{if(!isArrayLike(f))throw new TypeError('DataLoader\x20must\x20be\x20constructed\x20with\x20a\x20function\x20which\x20accepts\x20'+'Array<key>\x20and\x20returns\x20Promise<Array<value>>,\x20but\x20the\x20function\x20did\x20'+('not\x20return\x20a\x20Promise\x20of\x20an\x20Array:\x20'+String(f)+'.'));if(f['length']!==b['keys']['length'])throw new TypeError('DataLoader\x20must\x20be\x20constructed\x20with\x20a\x20function\x20which\x20accepts\x20'+'Array<key>\x20and\x20returns\x20Promise<Array<value>>,\x20but\x20the\x20function\x20did\x20'+'not\x20return\x20a\x20Promise\x20of\x20an\x20Array\x20of\x20the\x20same\x20length\x20as\x20the\x20Array\x20'+'of\x20keys.'+('\x0a\x0aKeys:\x0a'+String(b['keys']))+('\x0a\x0aValues:\x0a'+String(f)));resolveCacheHits(b);for(let g=0x0;g<b['callbacks']['length'];g++){const h=f[g];h instanceof Error?b['callbacks'][g]['reject'](h):b['callbacks'][g]['resolve'](h);}})['catch'](f=>{failedDispatch(a,b,f);});}function failedDispatch(a,b,c){resolveCacheHits(b);for(let d=0x0;d<b['keys']['length'];d++){a['clear'](b['keys'][d]),b['callbacks'][d]['reject'](c);}}function resolveCacheHits(a){if(a['cacheHits'])for(let b=0x0;b<a['cacheHits']['length'];b++){a['cacheHits'][b]();}}function getValidMaxBatchSize(a){const b=!a||a['batch']!==![];if(!b)return 0x1;const c=a&&a['maxBatchSize'];if(c===undefined)return Infinity;if(typeof c!=='number'||c<0x1)throw new TypeError('maxBatchSize\x20must\x20be\x20a\x20positive\x20number:\x20'+c);return c;}function getValidBatchScheduleFn(a){const b=a&&a['batchScheduleFn'];if(b===undefined)return enqueuePostPromiseJob;if(typeof b!=='function')throw new TypeError('batchScheduleFn\x20must\x20be\x20a\x20function:\x20'+b);return b;}function getValidCacheKeyFn(a){const b=a&&a['cacheKeyFn'];if(b===undefined)return c=>c;if(typeof b!=='function')throw new TypeError('cacheKeyFn\x20must\x20be\x20a\x20function:\x20'+b);return b;}function getValidCacheMap(a){const b=!a||a['cache']!==![];if(!b)return null;const c=a&&a['cacheMap'];if(c===undefined)return new Map();if(c!==null){const d=['get','set','delete','clear'],e=d['filter'](f=>c&&typeof c[f]!=='function');if(e['length']!==0x0)throw new TypeError('Custom\x20cacheMap\x20missing\x20methods:\x20'+e['join'](',\x20'));}return c;}function getValidName(a){if(a&&a['name'])return a['name'];return null;}function isArrayLike(a){return typeof a==='object'&&a!==null&&'length'in a&&typeof a['length']==='number'&&(a['length']===0x0||a['length']>0x0&&Object['prototype']['hasOwnProperty']['call'](a,a['length']-0x1));}

package/dist/cjs/_deps/utils/hex.d.ts

@@ -0,0 +1,2 @@
+export declare function fromHex(hexStr: string): Uint8Array<ArrayBuffer>;
+export declare function toHex(bytes: Uint8Array): string;

package/dist/cjs/_deps/utils/hex.js

@@ -0,0 +1 @@
+export function fromHex(a){const b=a['startsWith']('0x')?a['slice'](0x2):a,c=b['length']%0x2===0x0?b:'0'+b,d=c['match'](/[0-9a-fA-F]{2}/g)?.['map'](e=>parseInt(e,0x10))??[];if(d['length']!==c['length']/0x2)throw new Error('Invalid\x20hex\x20string\x20'+a);return Uint8Array['from'](d);}export function toHex(a){return a['reduce']((b,c)=>b+c['toString'](0x10)['padStart'](0x2,'0'),'');}

package/dist/cjs/_deps/utils/index.d.ts

@@ -0,0 +1,7 @@
+export { fromBase58, toBase58 } from "./b58.js";
+export { fromBase64, toBase64 } from "./b64.js";
+export { fromHex, toHex } from "./hex.js";
+export type { Simplify, UnionToIntersection } from "./types.js";
+export { chunk } from "./chunk.js";
+export { promiseWithResolvers, type PromiseWithResolvers, } from "./with-resolver.js";
+export { DataLoader } from "./dataloader.js";

package/dist/cjs/_deps/utils/index.js

@@ -0,0 +1 @@
+export{fromBase58,toBase58}from'./b58.js';export{fromBase64,toBase64}from'./b64.js';export{fromHex,toHex}from'./hex.js';export{chunk}from'./chunk.js';export{promiseWithResolvers}from'./with-resolver.js';export{DataLoader}from'./dataloader.js';

package/dist/cjs/_deps/utils/types.d.ts

@@ -0,0 +1,4 @@
+export type Simplify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;

package/dist/cjs/_deps/utils/with-resolver.d.ts

@@ -0,0 +1,6 @@
+export interface PromiseWithResolvers<T> {
+    promise: Promise<T>;
+    resolve: (value: T) => void;
+    reject: (error: unknown) => void;
+}
+export declare function promiseWithResolvers<T>(): PromiseWithResolvers<T>;

package/dist/cjs/_deps/utils/with-resolver.js

@@ -0,0 +1 @@
+export function promiseWithResolvers(){let a,b;const c=new Promise((d,e)=>{a=d,b=e;});return{'promise':c,'resolve':a,'reject':b};}