@xyo-network/sdk-protocol 7.0.4

package/dist/_pkg/schema-payload-plugin/neutral/index.mjs

@@ -0,0 +1,60 @@
+// src/Payload.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { isPayloadOfSchemaTypeWithSources, PayloadZodOfSchema } from "../../payload-model/neutral/index.mjs";
+import * as z from "zod/mini";
+
+// src/Schema.ts
+import { asSchema } from "../../payload-model/neutral/index.mjs";
+var SchemaSchema = asSchema("network.xyo.schema", true);
+
+// src/Payload.ts
+var optionalStringZod = z.optional(z.string());
+var schemaDefinitionZod = z.looseObject({ $id: optionalStringZod });
+var SchemaPayloadZod = z.extend(PayloadZodOfSchema(SchemaSchema), {
+  /** The schema definition body (JSON Schema); `$id`, when present, identifies the schema */
+  definition: schemaDefinitionZod,
+  /** The schema this schema extends (if any) */
+  extends: z.optional(z.string()),
+  /** @deprecated use definition.$id instead */
+  name: z.optional(z.string()),
+  /** The version of the schema major * 1,000,000 + minor * 1,000 + patch */
+  version: z.optional(z.number())
+});
+var isSchemaPayload = zodIsFactory(SchemaPayloadZod);
+var asSchemaPayload = zodAsFactory(SchemaPayloadZod, "asSchemaPayload");
+var toSchemaPayload = zodToFactory(SchemaPayloadZod, "toSchemaPayload");
+var isSchemaPayloadWithSources = isPayloadOfSchemaTypeWithSources(SchemaSchema);
+
+// src/Plugin.ts
+import { createPayloadPlugin } from "../../payload-plugin/neutral/index.mjs";
+
+// src/Template.ts
+var schemaPayloadTemplate = () => ({
+  definition: {
+    $id: "",
+    $schema: "http://json-schema.org/draft-07/schema#"
+  },
+  schema: SchemaSchema
+});
+
+// src/Plugin.ts
+var SchemaPayloadPlugin = () => createPayloadPlugin({
+  schema: SchemaSchema,
+  template: schemaPayloadTemplate
+});
+export {
+  SchemaPayloadPlugin,
+  SchemaPayloadZod,
+  SchemaSchema,
+  asSchemaPayload,
+  SchemaPayloadPlugin as default,
+  isSchemaPayload,
+  isSchemaPayloadWithSources,
+  schemaPayloadTemplate,
+  toSchemaPayload
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/sdk-utils/neutral/api.d.ts

@@ -0,0 +1,5 @@
+export * from '../../api/neutral/index.ts';
+export * from '../../api-models/neutral/index.ts';
+export * from '../../dns/neutral/index.ts';
+export * from '../../network/neutral/index.ts';
+//# sourceMappingURL=api.d.ts.map

package/dist/_pkg/sdk-utils/neutral/api.mjs

@@ -0,0 +1,6 @@
+// src/api.ts
+export * from "../../api/neutral/index.mjs";
+export * from "../../api-models/neutral/index.mjs";
+export * from "../../dns/neutral/index.mjs";
+export * from "../../network/neutral/index.mjs";
+//# sourceMappingURL=api.mjs.map

package/dist/_pkg/sdk-utils/neutral/index.d.ts

@@ -0,0 +1,9 @@
+export * from '../../api/neutral/index.ts';
+export * from '../../api-models/neutral/index.ts';
+export * from '../../dns/neutral/index.ts';
+export * from '../../metamask-connector/browser/index.ts';
+export * from '../../network/neutral/index.ts';
+export * from '../../payload-plugin/neutral/index.ts';
+export * from '../../quadkey/neutral/index.ts';
+export * from '../../schema-cache/neutral/index.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/sdk-utils/neutral/index.mjs

@@ -0,0 +1,10 @@
+// src/index.ts
+export * from "../../api/neutral/index.mjs";
+export * from "../../api-models/neutral/index.mjs";
+export * from "../../dns/neutral/index.mjs";
+export * from "../../metamask-connector/browser/index.mjs";
+export * from "../../network/neutral/index.mjs";
+export * from "../../payload-plugin/neutral/index.mjs";
+export * from "../../quadkey/neutral/index.mjs";
+export * from "../../schema-cache/neutral/index.mjs";
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/sdk-utils/neutral/integrations.d.ts

@@ -0,0 +1,3 @@
+export * from '../../metamask-connector/browser/index.ts';
+export * from '../../quadkey/neutral/index.ts';
+//# sourceMappingURL=integrations.d.ts.map

package/dist/_pkg/sdk-utils/neutral/integrations.mjs

@@ -0,0 +1,4 @@
+// src/integrations.ts
+export * from "../../metamask-connector/browser/index.mjs";
+export * from "../../quadkey/neutral/index.mjs";
+//# sourceMappingURL=integrations.mjs.map

package/dist/_pkg/sdk-utils/neutral/plugins.d.ts

@@ -0,0 +1,2 @@
+export * from '../../payload-plugin/neutral/index.ts';
+//# sourceMappingURL=plugins.d.ts.map

package/dist/_pkg/sdk-utils/neutral/plugins.mjs

@@ -0,0 +1,3 @@
+// src/plugins.ts
+export * from "../../payload-plugin/neutral/index.mjs";
+//# sourceMappingURL=plugins.mjs.map

package/dist/_pkg/sdk-utils/neutral/validation.d.ts

@@ -0,0 +1,2 @@
+export * from '../../schema-cache/neutral/index.ts';
+//# sourceMappingURL=validation.d.ts.map

package/dist/_pkg/sdk-utils/neutral/validation.mjs

@@ -0,0 +1,3 @@
+// src/validation.ts
+export * from "../../schema-cache/neutral/index.mjs";
+//# sourceMappingURL=validation.mjs.map

package/dist/_pkg/value-payload-plugin/neutral/Payload.d.ts

@@ -0,0 +1,46 @@
+import type { JsonValue } from '@xylabs/sdk';
+import * as z from 'zod/mini';
+export declare const ValuePayloadZod: z.ZodMiniObject<{
+    schema: z.ZodMiniLiteral<"network.xyo.value" & {
+        readonly __schema: true;
+    }>;
+    value: z.ZodMiniCustom<unknown, unknown>;
+}, z.core.$strip>;
+export type Value<T extends JsonValue = JsonValue> = z.infer<typeof ValuePayloadZod> & {
+    value: T;
+};
+export declare const isValuePayload: <T>(value: T) => value is T & {
+    schema: "network.xyo.value" & {
+        readonly __schema: true;
+    };
+    value: unknown;
+};
+export declare const asValuePayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.value" & {
+            readonly __schema: true;
+        };
+        value: unknown;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.value" & {
+            readonly __schema: true;
+        };
+        value: unknown;
+    };
+};
+export declare const toValuePayload: {
+    <T>(value: T): (T & {
+        schema: "network.xyo.value" & {
+            readonly __schema: true;
+        };
+        value: unknown;
+    }) | undefined;
+    <T>(value: T, assert: import("@xylabs/sdk").ZodFactoryConfig): T & {
+        schema: "network.xyo.value" & {
+            readonly __schema: true;
+        };
+        value: unknown;
+    };
+};
+//# sourceMappingURL=Payload.d.ts.map

package/dist/_pkg/value-payload-plugin/neutral/Plugin.d.ts

@@ -0,0 +1,3 @@
+import type { Value } from './Payload.ts';
+export declare const ValuePayloadPlugin: () => import("../../payload-plugin/neutral/index.ts").PayloadPlugin<Value>;
+//# sourceMappingURL=Plugin.d.ts.map

package/dist/_pkg/value-payload-plugin/neutral/Schema.d.ts

@@ -0,0 +1,5 @@
+export declare const ValueSchema: "network.xyo.value" & {
+    readonly __schema: true;
+};
+export type ValueSchema = typeof ValueSchema;
+//# sourceMappingURL=Schema.d.ts.map

package/dist/_pkg/value-payload-plugin/neutral/Template.d.ts

@@ -0,0 +1,3 @@
+import type { Value } from './Payload.ts';
+export declare const valuePayloadTemplate: () => Value;
+//# sourceMappingURL=Template.d.ts.map

package/dist/_pkg/value-payload-plugin/neutral/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Payload.ts';
+export { ValuePayloadPlugin as default, ValuePayloadPlugin } from './Plugin.ts';
+export * from './Schema.ts';
+export * from './Template.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/value-payload-plugin/neutral/index.mjs

@@ -0,0 +1,44 @@
+// src/Payload.ts
+import {
+  zodAsFactory,
+  zodIsFactory,
+  zodToFactory
+} from "@xylabs/sdk";
+import { PayloadZodOfSchema } from "../../payload-model/neutral/index.mjs";
+import * as z from "zod/mini";
+
+// src/Schema.ts
+import { asSchema } from "../../payload-model/neutral/index.mjs";
+var ValueSchema = asSchema("network.xyo.value", true);
+
+// src/Payload.ts
+var ValuePayloadZod = z.extend(PayloadZodOfSchema(ValueSchema), { value: z.custom() });
+var isValuePayload = zodIsFactory(ValuePayloadZod);
+var asValuePayload = zodAsFactory(ValuePayloadZod, "asValuePayload");
+var toValuePayload = zodToFactory(ValuePayloadZod, "toValuePayload");
+
+// src/Plugin.ts
+import { createPayloadPlugin } from "../../payload-plugin/neutral/index.mjs";
+
+// src/Template.ts
+var valuePayloadTemplate = () => ({
+  schema: ValueSchema,
+  value: null
+});
+
+// src/Plugin.ts
+var ValuePayloadPlugin = () => createPayloadPlugin({
+  schema: ValueSchema,
+  template: valuePayloadTemplate
+});
+export {
+  ValuePayloadPlugin,
+  ValuePayloadZod,
+  ValueSchema,
+  asValuePayload,
+  ValuePayloadPlugin as default,
+  isValuePayload,
+  toValuePayload,
+  valuePayloadTemplate
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/wallet/neutral/HDWallet.d.ts

@@ -0,0 +1,38 @@
+import type { Hex } from '@xylabs/sdk';
+import { Account } from '../../account/neutral/index.ts';
+import type { AccountConfig } from '../../account-model/neutral/index.ts';
+import type { XyoAddress } from '../../address/neutral/index.ts';
+import type { PrivateKeyInstance } from '../../key-model/neutral/index.ts';
+import type { WalletInstance } from '../../wallet-model/neutral/index.ts';
+import { HDNodeWallet, Mnemonic } from 'ethers';
+export declare class HDWallet extends Account implements WalletInstance {
+    static readonly uniqueName: string;
+    protected static _addressMap: Record<XyoAddress, WeakRef<WalletInstance>>;
+    protected readonly node: HDNodeWallet;
+    neuter: () => HDWallet;
+    constructor(key: symbol, node: HDNodeWallet, privateKey: PrivateKeyInstance);
+    protected static createFromNodeInternal(node: HDNodeWallet, previousHash?: string): Promise<WalletInstance>;
+    protected static getCachedWalletOrCacheNewWallet(createdWallet: WalletInstance): WalletInstance;
+    static create(opts?: AccountConfig): Promise<WalletInstance>;
+    static createFromNode(node: HDNodeWallet, previousHash?: string): Promise<WalletInstance>;
+    static fromExtendedKey(key: string): Promise<WalletInstance>;
+    static fromMnemonic(mnemonic: Mnemonic, path?: string): Promise<WalletInstance>;
+    static fromPhrase(phrase: string, path?: string): Promise<WalletInstance>;
+    static fromSeed(seed: string | ArrayBufferLike): Promise<WalletInstance>;
+    static generateMnemonic(wordlist?: string[], strength?: number): string;
+    static random(): Promise<WalletInstance>;
+    get address(): XyoAddress;
+    get addressBytes(): ArrayBufferLike;
+    get chainCode(): string;
+    get depth(): number;
+    get extendedKey(): string;
+    get fingerprint(): string;
+    get index(): number;
+    get mnemonic(): Mnemonic | null;
+    get parentFingerprint(): string;
+    get path(): string | null;
+    get privateKey(): Hex;
+    get publicKey(): Hex;
+    derivePath(path: string): Promise<WalletInstance>;
+}
+//# sourceMappingURL=HDWallet.d.ts.map

package/dist/_pkg/wallet/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './HDWallet.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/wallet/neutral/index.mjs

@@ -0,0 +1,157 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/HDWallet.ts
+import { generateMnemonic } from "@scure/bip39";
+import { wordlist as englishWordlist } from "@scure/bip39/wordlists/english.js";
+import {
+  asAddress,
+  assertEx,
+  globallyUnique,
+  hexFromHexString,
+  staticImplements,
+  toUint8Array
+} from "@xylabs/sdk";
+import { Account, PrivateKey } from "../../account/neutral/index.mjs";
+import {
+  isMnemonicInitializationConfig,
+  isPhraseInitializationConfig,
+  isPrivateKeyInitializationConfig
+} from "../../account-model/neutral/index.mjs";
+import {
+  defaultPath,
+  HDNodeWallet,
+  Mnemonic
+} from "ethers";
+var HDWallet = class extends Account {
+  node;
+  neuter = () => {
+    this.node.neuter();
+    return this;
+  };
+  constructor(key, node, privateKey) {
+    super(key, privateKey);
+    this.node = node;
+  }
+  static async createFromNodeInternal(node, previousHash) {
+    const privateKey = toUint8Array(node.privateKey.replace("0x", ""));
+    assertEx(privateKey.length === 32, () => `Private key must be 32 bytes [${privateKey?.length}]`);
+    const key = await PrivateKey.create(privateKey.buffer);
+    const wallet = new HDWallet(super._protectedConstructorKey, node, key);
+    const newWallet = await wallet.loadPreviousHash(previousHash);
+    return this._addressMap[newWallet.address]?.deref() ?? newWallet;
+  }
+  static getCachedWalletOrCacheNewWallet(createdWallet) {
+    const existingWallet = this._addressMap[createdWallet.address]?.deref();
+    if (existingWallet) {
+      return existingWallet;
+    }
+    const ref = new WeakRef(createdWallet);
+    this._addressMap[createdWallet.address] = ref;
+    return createdWallet;
+  }
+  static async create(opts) {
+    if (isPhraseInitializationConfig(opts)) {
+      return await this.fromPhrase(opts.phrase);
+    }
+    if (isMnemonicInitializationConfig(opts)) {
+      return await this.fromPhrase(opts.mnemonic, opts.path);
+    }
+    if (isPrivateKeyInitializationConfig(opts)) {
+      throw new Error("Invalid initialization config. from privateKey not supported.  Use Account.fromPrivateKey instead.");
+    }
+    throw new Error("Invalid initialization config");
+  }
+  static async createFromNode(node, previousHash) {
+    return await this.createFromNodeInternal(node, previousHash);
+  }
+  static async fromExtendedKey(key) {
+    const node = HDNodeWallet.fromExtendedKey(key);
+    return await this.createFromNode(node);
+  }
+  static async fromMnemonic(mnemonic, path = defaultPath) {
+    const node = HDNodeWallet.fromMnemonic(mnemonic, path);
+    const createdWallet = await this.createFromNodeInternal(node);
+    return this.getCachedWalletOrCacheNewWallet(createdWallet);
+  }
+  static async fromPhrase(phrase, path = defaultPath) {
+    return await this.fromMnemonic(Mnemonic.fromPhrase(phrase), path);
+  }
+  static async fromSeed(seed) {
+    const node = HDNodeWallet.fromSeed(toUint8Array(seed));
+    const createdWallet = await this.createFromNodeInternal(node);
+    return this.getCachedWalletOrCacheNewWallet(createdWallet);
+  }
+  static generateMnemonic(wordlist = englishWordlist, strength = 256) {
+    return generateMnemonic(wordlist, strength);
+  }
+  static async random() {
+    return await this.fromMnemonic(Mnemonic.fromPhrase(this.generateMnemonic()));
+  }
+  get address() {
+    return asAddress(hexFromHexString(this.node.address, { prefix: false }), true);
+  }
+  get addressBytes() {
+    return toUint8Array(this.address, void 0, 16).buffer;
+  }
+  get chainCode() {
+    return this.node.chainCode;
+  }
+  get depth() {
+    return this.node.depth;
+  }
+  get extendedKey() {
+    return this.node.extendedKey;
+  }
+  get fingerprint() {
+    return this.node.fingerprint;
+  }
+  get index() {
+    return this.node.index;
+  }
+  get mnemonic() {
+    return this.node.mnemonic;
+  }
+  get parentFingerprint() {
+    return this.node.parentFingerprint;
+  }
+  get path() {
+    return this.node.path;
+  }
+  get privateKey() {
+    return this.node.privateKey.toLowerCase();
+  }
+  get publicKey() {
+    return this.node.publicKey.toLowerCase();
+  }
+  async derivePath(path) {
+    if (path.startsWith("m/")) {
+      const parentPath = this.path;
+      if (parentPath !== null && path.startsWith(parentPath)) {
+        const childPath = path.slice(parentPath.length + 1);
+        return await HDWallet.createFromNode(this.node.derivePath(childPath));
+      }
+      throw new Error(`Invalid absolute path ${path} for wallet with path ${parentPath}`);
+    }
+    return await HDWallet.createFromNode(this.node.derivePath(path));
+  }
+};
+__publicField(HDWallet, "uniqueName", globallyUnique("HDWallet", HDWallet, "xyo"));
+__publicField(HDWallet, "_addressMap", {});
+HDWallet = __decorateClass([
+  staticImplements()
+], HDWallet);
+export {
+  HDWallet
+};
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/wallet-model/neutral/Mnemonic.d.ts

@@ -0,0 +1,27 @@
+import type { WordlistInstance } from './Wordlist.ts';
+export interface MnemonicInstance {
+    /**
+     *  The underlying entropy which the mnemonic encodes.
+     */
+    entropy: string;
+    /**
+     *  The password used for this mnemonic. If no password is used this
+     *  is the empty string (i.e. ``""``) as per the specification.
+     */
+    password: string;
+    /**
+     *  The mnemonic phrase of 12, 15, 18, 21 or 24 words.
+     *
+     *  Use the [[wordlist]] ``split`` method to get the individual words.
+     */
+    phrase: string;
+    /**
+     *  The wordlist for this mnemonic.
+     */
+    wordlist: WordlistInstance;
+    /**
+     *  Returns the seed for the mnemonic.
+     */
+    computeSeed(): string;
+}
+//# sourceMappingURL=Mnemonic.d.ts.map

package/dist/_pkg/wallet-model/neutral/Wallet.d.ts

@@ -0,0 +1,26 @@
+import type { Hex } from '@xylabs/sdk';
+import type { AccountConfig, AccountInstance, AccountStatic } from '../../account-model/neutral/index.ts';
+import type { MnemonicInstance } from './Mnemonic.ts';
+export interface WalletInstance extends AccountInstance {
+    readonly chainCode: string;
+    readonly depth: number;
+    readonly derivePath: (path: string) => Promise<WalletInstance>;
+    readonly extendedKey: string;
+    readonly fingerprint: string;
+    readonly index: number;
+    readonly mnemonic?: MnemonicInstance | null;
+    readonly neuter: () => WalletInstance;
+    readonly parentFingerprint: string;
+    readonly path: string | null;
+    readonly privateKey: Hex;
+    readonly publicKey: Hex;
+}
+export interface WalletStatic<T extends WalletInstance = WalletInstance> extends Omit<AccountStatic<T>, 'create'> {
+    create(config: AccountConfig): Promise<T>;
+    fromExtendedKey(key: string): Promise<T>;
+    fromMnemonic(mnemonic: MnemonicInstance): Promise<T>;
+    fromPhrase(mnemonic: string, path?: string): Promise<T>;
+    fromSeed(seed: string | ArrayBufferLike): Promise<T>;
+    random(): any;
+}
+//# sourceMappingURL=Wallet.d.ts.map

package/dist/_pkg/wallet-model/neutral/Wordlist.d.ts

@@ -0,0 +1,24 @@
+export interface WordlistInstance {
+    locale: string;
+    /**
+       *  Maps an 11-bit value into its corresponding word in the list.
+       *
+       *  Sub-classes MUST override this.
+       */
+    getWord(index: number): string;
+    /**
+       *  Maps a word to its corresponding 11-bit value.
+       *
+       *  Sub-classes MUST override this.
+       */
+    getWordIndex(word: string): number;
+    /**
+     *  Sub-classes may override this to provider a language-specific
+     *  method for joining %%words%% into a phrase.
+     *
+     *  By default, %%words%% are joined by a single space.
+     */
+    join(words: string[]): string;
+    split(phrase: string): string[];
+}
+//# sourceMappingURL=Wordlist.d.ts.map

package/dist/_pkg/wallet-model/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Wallet.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/_pkg/wallet-model/neutral/index.mjs

@@ -0,0 +1 @@
+//# sourceMappingURL=index.mjs.map

package/dist/_pkg/wasm/neutral/WasmSupport.d.ts

@@ -0,0 +1,110 @@
+export declare const WasmFeatureDetectors: {
+    readonly bigInt: () => Promise<boolean>;
+    readonly bulkMemory: () => Promise<boolean>;
+    readonly exceptions: () => Promise<boolean>;
+    readonly extendedConst: () => Promise<boolean>;
+    readonly gc: () => Promise<boolean>;
+    readonly memory64: () => Promise<boolean>;
+    readonly multiValue: () => Promise<boolean>;
+    readonly mutableGlobals: () => Promise<boolean>;
+    readonly referenceTypes: () => {
+        new (executor: (resolve: (value: boolean | PromiseLike<boolean>) => void, reject: (reason?: any) => void) => void): Promise<boolean>;
+        all<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>;
+        all<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;
+        race<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
+        race<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
+        readonly prototype: Promise<any>;
+        reject<T = never>(reason?: any): Promise<T>;
+        resolve(): Promise<void>;
+        resolve<T>(value: T): Promise<Awaited<T>>;
+        resolve<T>(value: T | PromiseLike<T>): Promise<Awaited<T>>;
+        allSettled<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>; }>;
+        allSettled<T>(values: Iterable<T | PromiseLike<T>>): Promise<PromiseSettledResult<Awaited<T>>[]>;
+        any<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
+        any<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>>;
+        withResolvers<T>(): PromiseWithResolvers<T>;
+        try<T, U extends unknown[]>(callbackFn: (...args: U) => T | PromiseLike<T>, ...args: U): Promise<Awaited<T>>;
+        readonly [Symbol.species]: PromiseConstructor;
+    };
+    readonly relaxedSimd: () => Promise<boolean>;
+    readonly saturatedFloatToInt: () => Promise<boolean>;
+    readonly signExtensions: () => Promise<boolean>;
+    readonly simd: () => Promise<boolean>;
+    readonly streamingCompilation: () => Promise<boolean>;
+    readonly tailCall: () => Promise<boolean>;
+    readonly threads: () => Promise<boolean>;
+};
+export type WasmFeature = keyof typeof WasmFeatureDetectors;
+export declare class WasmSupport {
+    private _allowWasm;
+    private _featureSupport;
+    private _forceWasm;
+    private _isInitialized;
+    private _isWasmFeatureSetSupported;
+    protected desiredFeatures: WasmFeature[];
+    /**
+     * 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
+     * @param desiredFeatures The desired feature set
+     */
+    constructor(desiredFeatures: WasmFeature[]);
+    /**
+     * Static creation & async initialization for use where
+     * async instantiation is possible
+     * @param desiredFeatures The desired feature set
+     * @returns An initialized instance of the class with detection
+     * for the desired feature set
+     */
+    static create(desiredFeatures: WasmFeature[]): Promise<WasmSupport>;
+    /**
+     * Is WebAssembly allowed
+     */
+    get allowWasm(): boolean;
+    /**
+     * Whether or not to allow WebAssembly usage
+     */
+    set allowWasm(v: boolean);
+    /**
+     * Whether or not WebAssembly should be used based on the desired
+     * feature set, initialization state, or force-use settings
+     */
+    get canUseWasm(): boolean;
+    /**
+     * Returns a object containing a property for each desired WebAssembly feature
+     * with a boolean value indicating whether or not the feature is supported
+     */
+    get featureSupport(): Readonly<Partial<Record<WasmFeature, boolean>>>;
+    /**
+     * Force use of WebAssembly
+     */
+    get forceWasm(): boolean;
+    /**
+     * Whether or not to force WebAssembly usage
+     */
+    set forceWasm(v: boolean);
+    /**
+     * Whether or not WebAssembly is supported based
+     * on the desired feature set
+     */
+    get isDesiredFeatureSetSupported(): boolean;
+    /**
+     * Whether or not WebAssembly detection has been run
+     * for the desired feature set
+     */
+    get isInitialized(): boolean;
+    protected detectDesiredFeatures(): Promise<void>;
+    /**
+     * Checks for specific WebAssembly features
+     * @param features The list of features to check for
+     * @returns True if all the features are supported, false otherwise
+     */
+    featureCheck(features: WasmFeature[]): Promise<boolean>;
+    /**
+     * Does feature detection for the desired feature set
+     */
+    initialize(): Promise<void>;
+}
+//# sourceMappingURL=WasmSupport.d.ts.map

package/dist/_pkg/wasm/neutral/index.d.ts

@@ -0,0 +1,2 @@
+export * from './WasmSupport.ts';
+//# sourceMappingURL=index.d.ts.map