@xyo-network/core 5.3.25 → 5.3.26

package/README.md

@@ -1,23 +1,2009 @@
+[![logo][]](https://xyo.network)
+
 # @xyo-network/core
 
-[![logo][]](https://xyo.network)
+[![npm][npm-badge]][npm-link]
+[![license][license-badge]][license-link]
+
+> Primary SDK for using XYO Protocol 2.0
+
+## Install
+
+Using npm:
+
+```sh
+npm install {{name}}
+```
+
+Using yarn:
 
-Version: 5.0.2
+```sh
+yarn add {{name}}
+```
 
-Primary SDK for using XYO Protocol 2.0
+Using pnpm:
 
-## Documentation
+```sh
+pnpm add {{name}}
+```
 
-[TypeDoc Generated Documentation](https://gitbook.xyo.network/xyo-data-lab/xyo-reference/package-documentation/xyo-network__core)
+Using bun:
+
+```sh
+bun add {{name}}
+```
 
-Part of [sdk-xyo-client-js](https://www.npmjs.com/package/@xyo-network/sdk-xyo-client-js)
 
 ## License
 
-> See the [LICENSE](LICENSE) file for license details
+See the [LICENSE](LICENSE) file for license rights and limitations (LGPL-3.0-only).
+
+## Reference
+
+### packages
+
+  ### protocol
+
+    ### packages
+
+      ### core
+
+        ### .temp-typedoc
+
+          ### classes
+
+            ### <a id="AbstractData"></a>AbstractData
+
+[**@xyo-network/core**](#../README)
+
+***
+
+## Extended by
+
+- [`Data`](#Data)
+
+## Implements
+
+- [`DataInstance`](#../interfaces/DataInstance)
+
+## Constructors
+
+### Constructor
+
+```ts
+new AbstractData(): AbstractData;
+```
+
+### Returns
+
+`AbstractData`
+
+## Accessors
+
+### length
+
+### Get Signature
+
+```ts
+get length(): number;
+```
+
+#### Returns
+
+`number`
+
+***
+
+### base58
+
+### Get Signature
+
+```ts
+get abstract base58(): string;
+```
+
+#### Returns
+
+`string`
+
+### Implementation of
+
+[`DataInstance`](#../interfaces/DataInstance).[`base58`](../interfaces/DataInstance.md#base58)
+
+***
+
+### bytes
+
+### Get Signature
+
+```ts
+get abstract bytes(): ArrayBufferLike;
+```
+
+#### Returns
+
+`ArrayBufferLike`
+
+### Implementation of
+
+[`DataInstance`](#../interfaces/DataInstance).[`bytes`](../interfaces/DataInstance.md#bytes)
+
+***
+
+### hex
+
+### Get Signature
+
+```ts
+get abstract hex(): BrandedHex;
+```
+
+#### Returns
+
+`BrandedHex`
+
+### Implementation of
+
+[`DataInstance`](#../interfaces/DataInstance).[`hex`](../interfaces/DataInstance.md#hex)
+
+***
+
+### keccak256
+
+### Get Signature
+
+```ts
+get abstract keccak256(): ArrayBufferLike;
+```
+
+#### Returns
+
+`ArrayBufferLike`
+
+### Implementation of
+
+[`DataInstance`](#../interfaces/DataInstance).[`keccak256`](../interfaces/DataInstance.md#keccak256)
+
+## Methods
+
+### is()
+
+```ts
+static is(value): value is AbstractData;
+```
+
+### Parameters
+
+#### value
+
+`unknown`
+
+### Returns
+
+`value is AbstractData`
+
+            ### <a id="Data"></a>Data
+
+[**@xyo-network/core**](#../README)
+
+***
+
+## Extends
+
+- [`AbstractData`](#AbstractData)
+
+## Constructors
+
+### Constructor
+
+```ts
+new Data(
+   length, 
+   bytes?, 
+   base?): Data;
+```
+
+### Parameters
+
+#### length
+
+`number`
+
+#### bytes?
+
+`ArrayBufferLike`
+
+#### base?
+
+`number`
+
+### Returns
+
+`Data`
+
+### Overrides
+
+[`AbstractData`](#AbstractData).[`constructor`](AbstractData.md#constructor)
+
+## Accessors
+
+### length
+
+### Get Signature
+
+```ts
+get length(): number;
+```
+
+#### Returns
+
+`number`
+
+### Inherited from
+
+[`AbstractData`](#AbstractData).[`length`](AbstractData.md#length)
+
+***
+
+### base58
+
+### Get Signature
+
+```ts
+get base58(): string;
+```
+
+#### Returns
+
+`string`
+
+### Overrides
+
+[`AbstractData`](#AbstractData).[`base58`](AbstractData.md#base58)
+
+***
+
+### bytes
+
+### Get Signature
+
+```ts
+get bytes(): ArrayBuffer | SharedArrayBuffer;
+```
+
+#### Returns
+
+`ArrayBuffer` \| `SharedArrayBuffer`
+
+### Overrides
+
+[`AbstractData`](#AbstractData).[`bytes`](AbstractData.md#bytes)
+
+***
+
+### hex
+
+### Get Signature
+
+```ts
+get hex(): BrandedHex;
+```
+
+#### Returns
+
+`BrandedHex`
+
+### Overrides
+
+[`AbstractData`](#AbstractData).[`hex`](AbstractData.md#hex)
+
+***
+
+### keccak256
+
+### Get Signature
+
+```ts
+get keccak256(): ArrayBufferLike;
+```
+
+#### Returns
+
+`ArrayBufferLike`
+
+### Overrides
+
+[`AbstractData`](#AbstractData).[`keccak256`](AbstractData.md#keccak256)
+
+## Methods
+
+### is()
+
+```ts
+static is(value): value is AbstractData;
+```
+
+### Parameters
+
+#### value
+
+`unknown`
+
+### Returns
+
+`value is AbstractData`
+
+### Inherited from
+
+[`AbstractData`](#AbstractData).[`is`](AbstractData.md#is)
+
+***
+
+### from()
+
+```ts
+static from(data): Data | undefined;
+```
+
+### Parameters
+
+#### data
+
+`ArrayBuffer` \| `undefined`
+
+### Returns
+
+`Data` \| `undefined`
+
+            ### <a id="ObjectHasher"></a>ObjectHasher
+
+[**@xyo-network/core**](#../README)
+
+***
+
+## Extends
+
+- `ObjectHasher`\<`T`\>
+
+## Type Parameters
+
+### T
+
+`T` *extends* `EmptyObject` = `EmptyObject`
+
+## Constructors
+
+### Constructor
+
+```ts
+new ObjectHasher<T>(obj): NodeObjectHasher<T>;
+```
+
+### Parameters
+
+#### obj
+
+`T`
+
+### Returns
+
+`NodeObjectHasher`\<`T`\>
+
+### Inherited from
+
+```ts
+ObjectHasher<T>.constructor
+```
+
+## Properties
+
+### createNodeWorker
+
+```ts
+readonly static createNodeWorker: (func?) => Worker;
+```
+
+### Parameters
+
+#### func?
+
+() => `unknown`
+
+### Returns
+
+`Worker`
+
+### Overrides
+
+```ts
+ObjectHasher.createNodeWorker
+```
+
+***
+
+### allowHashPooling
+
+```ts
+static allowHashPooling: boolean;
+```
+
+### Inherited from
+
+```ts
+ObjectHasher.allowHashPooling
+```
+
+***
+
+### allowSubtle
+
+```ts
+static allowSubtle: boolean;
+```
+
+### Inherited from
+
+```ts
+ObjectHasher.allowSubtle
+```
+
+***
+
+### createBrowserWorker?
+
+```ts
+static optional createBrowserWorker?: (url?) => Worker | undefined;
+```
+
+### Parameters
+
+#### url?
+
+`URL`
+
+### Returns
+
+`Worker` \| `undefined`
+
+### Inherited from
+
+```ts
+ObjectHasher.createBrowserWorker
+```
+
+***
+
+### subtleHashWorkerUrl?
+
+```ts
+readonly static optional subtleHashWorkerUrl?: URL;
+```
+
+### Inherited from
+
+```ts
+ObjectHasher.subtleHashWorkerUrl
+```
+
+***
+
+### warnIfUsingJsHash
+
+```ts
+static warnIfUsingJsHash: boolean;
+```
+
+### Inherited from
+
+```ts
+ObjectHasher.warnIfUsingJsHash
+```
+
+***
+
+### wasmHashWorkerUrl?
+
+```ts
+readonly static optional wasmHashWorkerUrl?: URL;
+```
+
+### Inherited from
+
+```ts
+ObjectHasher.wasmHashWorkerUrl
+```
+
+***
+
+### wasmInitialized
+
+```ts
+readonly static wasmInitialized: Promise<void>;
+```
+
+### Inherited from
+
+```ts
+ObjectHasher.wasmInitialized
+```
+
+***
+
+### wasmSupport
+
+```ts
+readonly static wasmSupport: WasmSupport;
+```
+
+### Inherited from
+
+```ts
+ObjectHasher.wasmSupport
+```
+
+## Methods
+
+### createWorker()
+
+```ts
+static createWorker(url?, func?): Worker;
+```
+
+### Parameters
+
+#### url?
+
+`URL`
+
+#### func?
+
+() => `unknown`
+
+### Returns
+
+`Worker`
+
+### Inherited from
+
+```ts
+ObjectHasher.createWorker
+```
+
+***
+
+### filterExcludeByHash()
+
+```ts
+static filterExcludeByHash<T>(objs, hash): Promise<T[]>;
+```
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+### Parameters
+
+#### objs
+
+`T`[] \| `undefined`
+
+#### hash
+
+`BrandedHash` \| `BrandedHash`[]
+
+### Returns
+
+`Promise`\<`T`[]\>
+
+### Inherited from
+
+```ts
+ObjectHasher.filterExcludeByHash
+```
+
+***
+
+### filterIncludeByHash()
+
+```ts
+static filterIncludeByHash<T>(objs, hash): Promise<T[]>;
+```
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+### Parameters
+
+#### objs
+
+`T`[] \| `undefined`
+
+#### hash
+
+`BrandedHash` \| `BrandedHash`[]
+
+### Returns
+
+`Promise`\<`T`[]\>
+
+### Inherited from
+
+```ts
+ObjectHasher.filterIncludeByHash
+```
+
+***
+
+### findByHash()
+
+```ts
+static findByHash<T>(objs, hash): Promise<T | undefined>;
+```
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+### Parameters
+
+#### objs
+
+`T`[] \| `undefined`
+
+#### hash
+
+`BrandedHash`
+
+### Returns
+
+`Promise`\<`T` \| `undefined`\>
+
+### Inherited from
+
+```ts
+ObjectHasher.findByHash
+```
+
+***
+
+### hash()
+
+```ts
+static hash<T>(obj): Promise<BrandedHash>;
+```
+
+Asynchronously hashes a payload
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+### Parameters
+
+#### obj
+
+`T`
+
+A payload
+
+### Returns
+
+`Promise`\<`BrandedHash`\>
+
+The payload hash
+
+### Inherited from
+
+```ts
+ObjectHasher.hash
+```
+
+***
+
+### hashBytes()
+
+```ts
+static hashBytes(bytes): Promise<BrandedHash>;
+```
+
+### Parameters
+
+#### bytes
+
+`ArrayBuffer` \| `Uint8Array`\<`ArrayBufferLike`\>
+
+### Returns
+
+`Promise`\<`BrandedHash`\>
+
+### Inherited from
+
+```ts
+ObjectHasher.hashBytes
+```
+
+***
+
+### hashFields()
+
+```ts
+static hashFields<T>(obj): T;
+```
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+### Parameters
+
+#### obj
+
+`T`
+
+### Returns
+
+`T`
+
+### Inherited from
+
+```ts
+ObjectHasher.hashFields
+```
+
+***
+
+### hashPairs()
+
+```ts
+static hashPairs<T>(objs): Promise<[T, BrandedHash][]>;
+```
+
+Creates an array of payload/hash tuples based on the payloads passed in
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+### Parameters
+
+#### objs
+
+`T`[]
+
+Any array of payloads
+
+### Returns
+
+`Promise`\<\[`T`, `BrandedHash`\][]\>
+
+An array of payload/hash tuples
+
+### Inherited from
+
+```ts
+ObjectHasher.hashPairs
+```
+
+***
+
+### hashes()
+
+```ts
+static hashes<T>(objs?): Promise<BrandedHash[] | undefined>;
+```
+
+Creates an array of payload hashes based on the payloads passed in
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+### Parameters
+
+#### objs?
+
+`T`[]
+
+Any array of payloads
+
+### Returns
+
+`Promise`\<`BrandedHash`[] \| `undefined`\>
+
+An array of payload hashes
+
+### Inherited from
+
+```ts
+ObjectHasher.hashes
+```
+
+***
+
+### json()
+
+```ts
+static json<T>(payload, meta?): T;
+```
+
+Returns a clone of the payload that is JSON safe
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+### Parameters
+
+#### payload
+
+`T`
+
+#### meta?
+
+`boolean`
+
+Keeps underscore (meta) fields if set to true
+
+### Returns
+
+`T`
+
+Returns a clone of the payload that is JSON safe
+
+### Inherited from
+
+```ts
+ObjectHasher.json
+```
+
+***
+
+### ~~jsonPayload()~~
+
+```ts
+static jsonPayload<T>(payload, meta?): T;
+```
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+### Parameters
+
+#### payload
+
+`T`
+
+#### meta?
+
+`boolean`
+
+### Returns
+
+`T`
+
+### Deprecated
+
+us json instead
+
+### Inherited from
+
+```ts
+ObjectHasher.jsonPayload
+```
+
+***
+
+### stringifyHashFields()
+
+```ts
+static stringifyHashFields<T>(obj): string;
+```
+
+### Type Parameters
+
+#### T
+
+`T` *extends* `object`
+
+### Parameters
+
+#### obj
+
+`T`
+
+### Returns
+
+`string`
+
+### Inherited from
+
+```ts
+ObjectHasher.stringifyHashFields
+```
+
+***
+
+### subtleHash()
+
+```ts
+static subtleHash(data): Promise<ArrayBuffer>;
+```
+
+### Parameters
+
+#### data
+
+`Uint8Array`\<`ArrayBuffer`\>
+
+### Returns
+
+`Promise`\<`ArrayBuffer`\>
+
+### Inherited from
+
+```ts
+ObjectHasher.subtleHash
+```
+
+***
+
+### wasmHash()
+
+```ts
+static wasmHash(data): Promise<BrandedHash>;
+```
+
+### Parameters
+
+#### data
+
+`Uint8Array`
+
+### Returns
+
+`Promise`\<`BrandedHash`\>
+
+### Inherited from
+
+```ts
+ObjectHasher.wasmHash
+```
+
+***
+
+### hash()
+
+```ts
+hash(): Promise<BrandedHash>;
+```
+
+### Returns
+
+`Promise`\<`BrandedHash`\>
+
+### Inherited from
+
+```ts
+ObjectHasher.hash
+```
+
+***
+
+### json()
+
+```ts
+json(meta?): T;
+```
+
+Returns a clone of the payload that is JSON safe
+
+### Parameters
+
+#### meta?
+
+`boolean`
+
+Keeps underscore (meta) fields if set to true
+
+### Returns
+
+`T`
+
+Returns a clone of the payload that is JSON safe
+
+### Inherited from
+
+```ts
+ObjectHasher.json
+```
+
+            ### <a id="WasmSupport"></a>WasmSupport
+
+[**@xyo-network/core**](#../README)
+
+***
+
+## Constructors
+
+### Constructor
+
+```ts
+new WasmSupport(desiredFeatures): WasmSupport;
+```
+
+Instance constructor for use where async instantiation
+is not possible. Where possible, prefer the static
+create method over use of this constructor directly
+as no initialization (feature detection) is able to
+be done here
+
+### Parameters
+
+#### desiredFeatures
+
+(
+  \| `"bigInt"`
+  \| `"bulkMemory"`
+  \| `"exceptions"`
+  \| `"extendedConst"`
+  \| `"gc"`
+  \| `"memory64"`
+  \| `"multiValue"`
+  \| `"mutableGlobals"`
+  \| `"referenceTypes"`
+  \| `"relaxedSimd"`
+  \| `"saturatedFloatToInt"`
+  \| `"signExtensions"`
+  \| `"simd"`
+  \| `"streamingCompilation"`
+  \| `"tailCall"`
+  \| `"threads"`)[]
+
+The desired feature set
+
+### Returns
+
+`WasmSupport`
+
+## Properties
+
+### desiredFeatures
+
+```ts
+protected desiredFeatures: (
+  | "bigInt"
+  | "bulkMemory"
+  | "exceptions"
+  | "extendedConst"
+  | "gc"
+  | "memory64"
+  | "multiValue"
+  | "mutableGlobals"
+  | "referenceTypes"
+  | "relaxedSimd"
+  | "saturatedFloatToInt"
+  | "signExtensions"
+  | "simd"
+  | "streamingCompilation"
+  | "tailCall"
+  | "threads")[];
+```
+
+## Accessors
+
+### allowWasm
+
+### Get Signature
+
+```ts
+get allowWasm(): boolean;
+```
+
+Is Wasm allowed
+
+#### Returns
+
+`boolean`
+
+### Set Signature
+
+```ts
+set allowWasm(v): void;
+```
+
+Whether or not to allow WASM usage
+
+#### Parameters
+
+##### v
+
+`boolean`
+
+#### Returns
+
+`void`
+
+***
+
+### canUseWasm
+
+### Get Signature
+
+```ts
+get canUseWasm(): boolean;
+```
+
+Whether or not Wasm should be used based on the desired
+feature set, initialization state, or force-use settings
+
+#### Returns
+
+`boolean`
+
+***
+
+### featureSupport
+
+### Get Signature
+
+```ts
+get featureSupport(): Readonly<Partial<Record<WasmFeature, boolean>>>;
+```
+
+Returns a object containing a property for each desired wasm feature
+with a boolean value indicating whether or not the feature is supported
+
+#### Returns
+
+`Readonly`\<`Partial`\<`Record`\<[`WasmFeature`](#../type-aliases/WasmFeature), `boolean`\>\>\>
+
+***
+
+### forceWasm
+
+### Get Signature
+
+```ts
+get forceWasm(): boolean;
+```
+
+Force use of Wasm
+
+#### Returns
+
+`boolean`
+
+### Set Signature
+
+```ts
+set forceWasm(v): void;
+```
+
+Whether or not to force Wasm usage
+
+#### Parameters
+
+##### v
+
+`boolean`
+
+#### Returns
+
+`void`
+
+***
+
+### isDesiredFeatureSetSupported
+
+### Get Signature
+
+```ts
+get isDesiredFeatureSetSupported(): boolean;
+```
+
+Whether or not Wasm is supported based
+on the desired feature set
+
+#### Returns
+
+`boolean`
+
+***
+
+### isInitialized
+
+### Get Signature
+
+```ts
+get isInitialized(): boolean;
+```
+
+Whether or not Wasm detection has been run
+for the desired feature set
+
+#### Returns
+
+`boolean`
+
+## Methods
+
+### create()
+
+```ts
+static create(desiredFeatures): Promise<WasmSupport>;
+```
+
+Static creation & async initialization for use where
+async instantiation is possible
+
+### Parameters
+
+#### desiredFeatures
+
+(
+  \| `"bigInt"`
+  \| `"bulkMemory"`
+  \| `"exceptions"`
+  \| `"extendedConst"`
+  \| `"gc"`
+  \| `"memory64"`
+  \| `"multiValue"`
+  \| `"mutableGlobals"`
+  \| `"referenceTypes"`
+  \| `"relaxedSimd"`
+  \| `"saturatedFloatToInt"`
+  \| `"signExtensions"`
+  \| `"simd"`
+  \| `"streamingCompilation"`
+  \| `"tailCall"`
+  \| `"threads"`)[]
+
+The desired feature set
+
+### Returns
+
+`Promise`\<`WasmSupport`\>
+
+An initialized instance of the class with detection
+for the desired feature set
+
+***
+
+### featureCheck()
+
+```ts
+featureCheck(features): Promise<boolean>;
+```
+
+Checks for specific wasm features
+
+### Parameters
+
+#### features
+
+(
+  \| `"bigInt"`
+  \| `"bulkMemory"`
+  \| `"exceptions"`
+  \| `"extendedConst"`
+  \| `"gc"`
+  \| `"memory64"`
+  \| `"multiValue"`
+  \| `"mutableGlobals"`
+  \| `"referenceTypes"`
+  \| `"relaxedSimd"`
+  \| `"saturatedFloatToInt"`
+  \| `"signExtensions"`
+  \| `"simd"`
+  \| `"streamingCompilation"`
+  \| `"tailCall"`
+  \| `"threads"`)[]
+
+The list of features to check for
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+True if all the features are supported, false otherwise
+
+***
+
+### initialize()
+
+```ts
+initialize(): Promise<void>;
+```
+
+Does feature detection for the desired feature set
+
+### Returns
+
+`Promise`\<`void`\>
+
+***
+
+### detectDesiredFeatures()
+
+```ts
+protected detectDesiredFeatures(): Promise<void>;
+```
+
+### Returns
+
+`Promise`\<`void`\>
+
+          ### interfaces
+
+            ### <a id="DataInstance"></a>DataInstance
+
+[**@xyo-network/core**](#../README)
+
+***
+
+## Properties
+
+### base58
+
+```ts
+base58: string;
+```
+
+***
+
+### bytes
+
+```ts
+bytes: ArrayBufferLike;
+```
+
+***
+
+### hex
+
+```ts
+hex: BrandedHex;
+```
+
+***
+
+### keccak256
+
+```ts
+keccak256: ArrayBufferLike;
+```
+
+          ### type-aliases
+
+            ### <a id="WasmFeature"></a>WasmFeature
+
+[**@xyo-network/core**](#../README)
+
+***
+
+```ts
+type WasmFeature = keyof typeof WasmFeatureDetectors;
+```
+
+          ### variables
+
+            ### <a id="WasmFeatureDetectors"></a>WasmFeatureDetectors
+
+[**@xyo-network/core**](#../README)
+
+***
+
+```ts
+const WasmFeatureDetectors: object;
+```
+
+## Type Declaration
+
+### bigInt
+
+```ts
+readonly bigInt: () => Promise<boolean>;
+```
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+### bulkMemory
+
+```ts
+readonly bulkMemory: () => Promise<boolean>;
+```
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+### exceptions
+
+```ts
+readonly exceptions: () => Promise<boolean>;
+```
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+### extendedConst
+
+```ts
+readonly extendedConst: () => Promise<boolean>;
+```
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+### gc
+
+```ts
+readonly gc: () => Promise<boolean>;
+```
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+### memory64
+
+```ts
+readonly memory64: () => Promise<boolean>;
+```
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+### multiValue
+
+```ts
+readonly multiValue: () => Promise<boolean>;
+```
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+### mutableGlobals
+
+```ts
+readonly mutableGlobals: () => Promise<boolean>;
+```
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+### referenceTypes
+
+```ts
+readonly referenceTypes: () => {
+(executor): Promise<boolean>;
+  all: Promise<Awaited<T>[]>;
+  race: Promise<Awaited<T>>;
+  prototype: Promise<any>;
+  reject: Promise<T>;
+  resolve: Promise<void>;
+  allSettled: Promise<{ -readonly [P in string | number | symbol]: PromiseSettledResult<Awaited<T[P]>> }>;
+  any: Promise<Awaited<T[number]>>;
+  withResolvers: PromiseWithResolvers<T>;
+  try: Promise<Awaited<T>>;
+  [species]: PromiseConstructor;
+};
+```
+
+### Returns
+
+\{
+(`executor`): `Promise`\<`boolean`\>;
+  `all`: `Promise`\<`Awaited`\<`T`\>[]\>;
+  `race`: `Promise`\<`Awaited`\<`T`\>\>;
+  `prototype`: `Promise`\<`any`\>;
+  `reject`: `Promise`\<`T`\>;
+  `resolve`: `Promise`\<`void`\>;
+  `allSettled`: `Promise`\<\{ -readonly \[P in string \| number \| symbol\]: PromiseSettledResult\<Awaited\<T\[P\]\>\> \}\>;
+  `any`: `Promise`\<`Awaited`\<`T`\[`number`\]\>\>;
+  `withResolvers`: `PromiseWithResolvers`\<`T`\>;
+  `try`: `Promise`\<`Awaited`\<`T`\>\>;
+  `[species]`: `PromiseConstructor`;
+\}
+
+#### all()
+
+##### Call Signature
+
+```ts
+all<T>(values): Promise<Awaited<T>[]>;
+```
+
+##### Type Parameters
+
+##### T
+
+`T`
+
+##### Parameters
+
+##### values
+
+`Iterable`\<`T` \| `PromiseLike`\<`T`\>\>
+
+##### Returns
+
+`Promise`\<`Awaited`\<`T`\>[]\>
+
+##### Call Signature
+
+```ts
+all<T>(values): Promise<{ -readonly [P in string | number | symbol]: Awaited<T[P]> }>;
+```
+
+##### Type Parameters
+
+##### T
+
+`T` *extends* readonly `unknown`[] \| \[\]
+
+##### Parameters
+
+##### values
+
+`T`
+
+##### Returns
+
+`Promise`\<\{ -readonly \[P in string \| number \| symbol\]: Awaited\<T\[P\]\> \}\>
+
+#### race()
+
+##### Call Signature
+
+```ts
+race<T>(values): Promise<Awaited<T>>;
+```
+
+##### Type Parameters
+
+##### T
+
+`T`
+
+##### Parameters
+
+##### values
+
+`Iterable`\<`T` \| `PromiseLike`\<`T`\>\>
+
+##### Returns
+
+`Promise`\<`Awaited`\<`T`\>\>
+
+##### Call Signature
+
+```ts
+race<T>(values): Promise<Awaited<T[number]>>;
+```
+
+##### Type Parameters
+
+##### T
+
+`T` *extends* readonly `unknown`[] \| \[\]
+
+##### Parameters
+
+##### values
+
+`T`
+
+##### Returns
+
+`Promise`\<`Awaited`\<`T`\[`number`\]\>\>
+
+#### prototype
+
+```ts
+readonly prototype: Promise<any>;
+```
+
+#### reject()
+
+```ts
+reject<T>(reason?): Promise<T>;
+```
+
+##### Type Parameters
+
+##### T
+
+`T` = `never`
+
+##### Parameters
+
+##### reason?
+
+`any`
+
+##### Returns
+
+`Promise`\<`T`\>
+
+#### resolve()
+
+##### Call Signature
+
+```ts
+resolve(): Promise<void>;
+```
+
+##### Returns
+
+`Promise`\<`void`\>
+
+##### Call Signature
+
+```ts
+resolve<T>(value): Promise<Awaited<T>>;
+```
+
+##### Type Parameters
+
+##### T
+
+`T`
+
+##### Parameters
+
+##### value
+
+`T`
+
+##### Returns
+
+`Promise`\<`Awaited`\<`T`\>\>
+
+##### Call Signature
+
+```ts
+resolve<T>(value): Promise<Awaited<T>>;
+```
+
+##### Type Parameters
+
+##### T
+
+`T`
+
+##### Parameters
+
+##### value
+
+`T` \| `PromiseLike`\<`T`\>
+
+##### Returns
+
+`Promise`\<`Awaited`\<`T`\>\>
+
+#### allSettled()
+
+##### Call Signature
+
+```ts
+allSettled<T>(values): Promise<{ -readonly [P in string | number | symbol]: PromiseSettledResult<Awaited<T[P]>> }>;
+```
+
+##### Type Parameters
+
+##### T
+
+`T` *extends* readonly `unknown`[] \| \[\]
+
+##### Parameters
+
+##### values
+
+`T`
+
+##### Returns
+
+`Promise`\<\{ -readonly \[P in string \| number \| symbol\]: PromiseSettledResult\<Awaited\<T\[P\]\>\> \}\>
+
+##### Call Signature
+
+```ts
+allSettled<T>(values): Promise<PromiseSettledResult<Awaited<T>>[]>;
+```
+
+##### Type Parameters
+
+##### T
+
+`T`
+
+##### Parameters
+
+##### values
+
+`Iterable`\<`T` \| `PromiseLike`\<`T`\>\>
+
+##### Returns
+
+`Promise`\<`PromiseSettledResult`\<`Awaited`\<`T`\>\>[]\>
+
+#### any()
+
+##### Call Signature
+
+```ts
+any<T>(values): Promise<Awaited<T[number]>>;
+```
+
+##### Type Parameters
+
+##### T
+
+`T` *extends* readonly `unknown`[] \| \[\]
+
+##### Parameters
+
+##### values
+
+`T`
+
+##### Returns
+
+`Promise`\<`Awaited`\<`T`\[`number`\]\>\>
+
+##### Call Signature
+
+```ts
+any<T>(values): Promise<Awaited<T>>;
+```
+
+##### Type Parameters
+
+##### T
+
+`T`
+
+##### Parameters
+
+##### values
+
+`Iterable`\<`T` \| `PromiseLike`\<`T`\>\>
+
+##### Returns
+
+`Promise`\<`Awaited`\<`T`\>\>
+
+#### withResolvers()
+
+```ts
+withResolvers<T>(): PromiseWithResolvers<T>;
+```
+
+##### Type Parameters
+
+##### T
+
+`T`
+
+##### Returns
+
+`PromiseWithResolvers`\<`T`\>
+
+#### try()
+
+```ts
+try<T, U>(callbackFn, ...args): Promise<Awaited<T>>;
+```
+
+##### Type Parameters
+
+##### T
+
+`T`
+
+##### U
+
+`U` *extends* `unknown`[]
+
+##### Parameters
+
+##### callbackFn
+
+(...`args`) => `T` \| `PromiseLike`\<`T`\>
+
+##### args
+
+...`U`
+
+##### Returns
+
+`Promise`\<`Awaited`\<`T`\>\>
+
+#### \[species\]
+
+```ts
+readonly [species]: PromiseConstructor;
+```
+
+### relaxedSimd
+
+```ts
+readonly relaxedSimd: () => Promise<boolean>;
+```
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+### saturatedFloatToInt
+
+```ts
+readonly saturatedFloatToInt: () => Promise<boolean>;
+```
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+### signExtensions
+
+```ts
+readonly signExtensions: () => Promise<boolean>;
+```
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+### simd
+
+```ts
+readonly simd: () => Promise<boolean>;
+```
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+### streamingCompilation
+
+```ts
+readonly streamingCompilation: () => Promise<boolean>;
+```
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+### tailCall
+
+```ts
+readonly tailCall: () => Promise<boolean>;
+```
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+### threads
+
+```ts
+readonly threads: () => Promise<boolean>;
+```
+
+### Returns
+
+`Promise`\<`boolean`\>
+
+            ### <a id="hasEmptyFields"></a>hasEmptyFields
+
+[**@xyo-network/core**](#../README)
+
+***
+
+```ts
+const hasEmptyFields: <T>(obj) => boolean;
+```
+
+## Type Parameters
+
+### T
+
+`T` *extends* `EmptyObject`
+
+## Parameters
+
+### obj
+
+`T`
+
+## Returns
+
+`boolean`
+
+            ### <a id="removeEmptyFields"></a>removeEmptyFields
+
+[**@xyo-network/core**](#../README)
+
+***
+
+```ts
+const removeEmptyFields: <T>(obj) => T;
+```
+
+## Type Parameters
+
+### T
+
+`T` *extends* `EmptyObject`
+
+## Parameters
+
+### obj
+
+`T`
+
+## Returns
+
+`T`
+
+            ### <a id="sortFields"></a>sortFields
+
+[**@xyo-network/core**](#../README)
+
+***
+
+```ts
+const sortFields: <T>(obj) => T;
+```
+
+## Type Parameters
+
+### T
+
+`T` *extends* `EmptyObject`
+
+## Parameters
+
+### obj
+
+`T`
+
+## Returns
 
-## Credits
+`T`
 
-[Made with 🔥 and ❄️ by XYO](https://xyo.network)
 
-[logo]: https://cdn.xy.company/img/brand/XYO_full_colored.png
+[logo]: https://cdn.xy.company/img/brand/XYO_full_colored.png
+[npm-badge]: https://img.shields.io/npm/v/@xyo-network/core.svg
+[npm-link]: https://www.npmjs.com/package/@xyo-network/core
+[license-badge]: https://img.shields.io/npm/l/@xyo-network/core.svg
+[license-link]: https://github.com/xylabs/sdk-js/blob/main/LICENSE