@xyo-network/wasm 2.74.5 → 2.75.1

package/dist/browser/WasmSupport.cjs

@@ -0,0 +1,164 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/WasmSupport.ts
+var WasmSupport_exports = {};
+__export(WasmSupport_exports, {
+  WasmFeatureDetectors: () => WasmFeatureDetectors,
+  WasmSupport: () => WasmSupport
+});
+module.exports = __toCommonJS(WasmSupport_exports);
+var import_wasm_feature_detect = require("wasm-feature-detect");
+var WasmFeatureDetectors = {
+  bigInt: import_wasm_feature_detect.bigInt,
+  bulkMemory: import_wasm_feature_detect.bulkMemory,
+  exceptions: import_wasm_feature_detect.exceptions,
+  extendedConst: import_wasm_feature_detect.extendedConst,
+  gc: import_wasm_feature_detect.gc,
+  memory64: import_wasm_feature_detect.memory64,
+  multiValue: import_wasm_feature_detect.multiValue,
+  mutableGlobals: import_wasm_feature_detect.mutableGlobals,
+  referenceTypes: import_wasm_feature_detect.referenceTypes,
+  relaxedSimd: import_wasm_feature_detect.relaxedSimd,
+  saturatedFloatToInt: import_wasm_feature_detect.saturatedFloatToInt,
+  signExtensions: import_wasm_feature_detect.signExtensions,
+  simd: import_wasm_feature_detect.simd,
+  streamingCompilation: import_wasm_feature_detect.streamingCompilation,
+  tailCall: import_wasm_feature_detect.tailCall,
+  threads: import_wasm_feature_detect.threads
+};
+var WasmSupport = class _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
+   * @param desiredFeatures The desired feature set
+   */
+  constructor(desiredFeatures) {
+    this.desiredFeatures = desiredFeatures;
+  }
+  _allowWasm = true;
+  _featureSupport = {};
+  _forceWasm = false;
+  _isInitialized = false;
+  _isWasmFeatureSetSupported = false;
+  /**
+   * Is Wasm allowed
+   */
+  get allowWasm() {
+    return this._allowWasm;
+  }
+  /**
+   * Whether or not to allow WASM usage
+   */
+  set allowWasm(v) {
+    this._allowWasm = v;
+  }
+  /**
+   * Whether or not Wasm should be used based on the desired
+   * feature set, initialization state, or force-use settings
+   */
+  get canUseWasm() {
+    return (
+      // Just force WASM
+      this._forceWasm || // Or if we haven't checked be optimistic
+      this._allowWasm && !this._isInitialized || // Or if we have checked and WASM is not supported, be realistic
+      this._allowWasm && this._isInitialized && this._isWasmFeatureSetSupported
+    );
+  }
+  /**
+   * Returns a object containing a property for each desired wasm feature
+   * with a boolean value indicating whether or not the feature is supported
+   */
+  get featureSupport() {
+    return { ...this._featureSupport };
+  }
+  /**
+   * Force use of Wasm
+   */
+  get forceWasm() {
+    return this._forceWasm;
+  }
+  /**
+   * Whether or not to force Wasm usage
+   */
+  set forceWasm(v) {
+    this._forceWasm = v;
+  }
+  /**
+   * Whether or not Wasm is supported based
+   * on the desired feature set
+   */
+  get isDesiredFeatureSetSupported() {
+    return this._isWasmFeatureSetSupported;
+  }
+  /**
+   * Whether or not Wasm detection has been run
+   * for the desired feature set
+   */
+  get isInitialized() {
+    return this._isInitialized;
+  }
+  /**
+   * 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 async create(desiredFeatures) {
+    const instance = new _WasmSupport(desiredFeatures);
+    await instance.initialize();
+    return Promise.resolve(instance);
+  }
+  /**
+   * Checks for specific wasm features
+   * @param features The list of features to check for
+   * @returns True if all the features are supported, false otherwise
+   */
+  async featureCheck(features) {
+    const results = await Promise.all(features.map((feature) => WasmFeatureDetectors[feature]).map(async (detector) => await detector()));
+    return results.every((result) => result);
+  }
+  /**
+   * Does feature detection for the desired feature set
+   */
+  async initialize() {
+    if (this._isInitialized)
+      return;
+    await this.detectDesiredFeatures();
+    this._isInitialized = true;
+    return;
+  }
+  async detectDesiredFeatures() {
+    for (let feature = 0; feature < this.desiredFeatures.length; feature++) {
+      const desiredFeature = this.desiredFeatures[feature];
+      const detector = WasmFeatureDetectors[desiredFeature];
+      if (!await detector()) {
+        this._featureSupport[desiredFeature] = false;
+      } else {
+        this._featureSupport[desiredFeature] = true;
+      }
+    }
+    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every((v) => v);
+  }
+};
+//# sourceMappingURL=WasmSupport.cjs.map

package/dist/browser/WasmSupport.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/WasmSupport.ts"],"sourcesContent":["import {\n  bigInt,\n  bulkMemory,\n  exceptions,\n  extendedConst,\n  gc,\n  memory64,\n  multiValue,\n  mutableGlobals,\n  referenceTypes,\n  relaxedSimd,\n  saturatedFloatToInt,\n  signExtensions,\n  simd,\n  streamingCompilation,\n  tailCall,\n  threads,\n} from 'wasm-feature-detect'\n\nexport const WasmFeatureDetectors = {\n  bigInt: bigInt,\n  bulkMemory: bulkMemory,\n  exceptions: exceptions,\n  extendedConst: extendedConst,\n  gc: gc,\n  memory64: memory64,\n  multiValue: multiValue,\n  mutableGlobals: mutableGlobals,\n  referenceTypes: referenceTypes,\n  relaxedSimd: relaxedSimd,\n  saturatedFloatToInt: saturatedFloatToInt,\n  signExtensions: signExtensions,\n  simd: simd,\n  streamingCompilation: streamingCompilation,\n  tailCall: tailCall,\n  threads: threads,\n} as const\n\nexport type WasmFeature = keyof typeof WasmFeatureDetectors\n\nexport class WasmSupport {\n  private _allowWasm = true\n  private _featureSupport: Partial<Record<WasmFeature, boolean>> = {}\n  private _forceWasm = false\n  private _isInitialized = false\n  private _isWasmFeatureSetSupported = false\n\n  /**\n   * Instance constructor for use where async instantiation\n   * is not possible. Where possible, prefer the static\n   * create method over use of this constructor directly\n   * as no initialization (feature detection) is able to\n   * be done here\n   * @param desiredFeatures The desired feature set\n   */\n  constructor(protected desiredFeatures: WasmFeature[]) {}\n\n  /**\n   * Is Wasm allowed\n   */\n  get allowWasm(): boolean {\n    return this._allowWasm\n  }\n  /**\n   * Whether or not to allow WASM usage\n   */\n  set allowWasm(v: boolean) {\n    this._allowWasm = v\n  }\n\n  /**\n   * Whether or not Wasm should be used based on the desired\n   * feature set, initialization state, or force-use settings\n   */\n  get canUseWasm(): boolean {\n    return (\n      // Just force WASM\n      this._forceWasm ||\n      // Or if we haven't checked be optimistic\n      (this._allowWasm && !this._isInitialized) ||\n      // Or if we have checked and WASM is not supported, be realistic\n      (this._allowWasm && this._isInitialized && this._isWasmFeatureSetSupported)\n    )\n  }\n\n  /**\n   * Returns a object containing a property for each desired wasm feature\n   * with a boolean value indicating whether or not the feature is supported\n   */\n  get featureSupport(): Readonly<Partial<Record<WasmFeature, boolean>>> {\n    return { ...this._featureSupport }\n  }\n\n  /**\n   * Force use of Wasm\n   */\n  get forceWasm(): boolean {\n    return this._forceWasm\n  }\n  /**\n   * Whether or not to force Wasm usage\n   */\n  set forceWasm(v: boolean) {\n    this._forceWasm = v\n  }\n\n  /**\n   * Whether or not Wasm is supported based\n   * on the desired feature set\n   */\n  get isDesiredFeatureSetSupported(): boolean {\n    return this._isWasmFeatureSetSupported\n  }\n\n  /**\n   * Whether or not Wasm detection has been run\n   * for the desired feature set\n   */\n  get isInitialized(): boolean {\n    return this._isInitialized\n  }\n\n  /**\n   * Static creation & async initialization for use where\n   * async instantiation is possible\n   * @param desiredFeatures The desired feature set\n   * @returns An initialized instance of the class with detection\n   * for the desired feature set\n   */\n  static async create(desiredFeatures: WasmFeature[]): Promise<WasmSupport> {\n    const instance = new WasmSupport(desiredFeatures)\n    await instance.initialize()\n    return Promise.resolve(instance)\n  }\n\n  /**\n   * Checks for specific wasm features\n   * @param features The list of features to check for\n   * @returns True if all the features are supported, false otherwise\n   */\n  async featureCheck(features: WasmFeature[]): Promise<boolean> {\n    const results = await Promise.all(features.map((feature) => WasmFeatureDetectors[feature]).map(async (detector) => await detector()))\n    return results.every((result) => result)\n  }\n\n  /**\n   * Does feature detection for the desired feature set\n   */\n  async initialize(): Promise<void> {\n    if (this._isInitialized) return\n    await this.detectDesiredFeatures()\n    this._isInitialized = true\n    return\n  }\n\n  protected async detectDesiredFeatures(): Promise<void> {\n    for (let feature = 0; feature < this.desiredFeatures.length; feature++) {\n      const desiredFeature = this.desiredFeatures[feature]\n      const detector = WasmFeatureDetectors[desiredFeature]\n      if (!(await detector())) {\n        this._featureSupport[desiredFeature] = false\n      } else {\n        this._featureSupport[desiredFeature] = true\n      }\n    }\n    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every((v) => v)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iCAiBO;AAEA,IAAM,uBAAuB;AAAA,EAClC,QAAQ;AAAA,EACR,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,eAAe;AAAA,EACf,IAAI;AAAA,EACJ,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,gBAAgB;AAAA,EAChB,aAAa;AAAA,EACb,qBAAqB;AAAA,EACrB,gBAAgB;AAAA,EAChB,MAAM;AAAA,EACN,sBAAsB;AAAA,EACtB,UAAU;AAAA,EACV,SAAS;AACX;AAIO,IAAM,cAAN,MAAM,aAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAevB,YAAsB,iBAAgC;AAAhC;AAAA,EAAiC;AAAA,EAd/C,aAAa;AAAA,EACb,kBAAyD,CAAC;AAAA,EAC1D,aAAa;AAAA,EACb,iBAAiB;AAAA,EACjB,6BAA6B;AAAA;AAAA;AAAA;AAAA,EAerC,IAAI,YAAqB;AACvB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,UAAU,GAAY;AACxB,SAAK,aAAa;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAI,aAAsB;AACxB;AAAA;AAAA,MAEE,KAAK;AAAA,MAEJ,KAAK,cAAc,CAAC,KAAK;AAAA,MAEzB,KAAK,cAAc,KAAK,kBAAkB,KAAK;AAAA;AAAA,EAEpD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAI,iBAAkE;AACpE,WAAO,EAAE,GAAG,KAAK,gBAAgB;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,YAAqB;AACvB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,UAAU,GAAY;AACxB,SAAK,aAAa;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAI,+BAAwC;AAC1C,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAI,gBAAyB;AAC3B,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,aAAa,OAAO,iBAAsD;AACxE,UAAM,WAAW,IAAI,aAAY,eAAe;AAChD,UAAM,SAAS,WAAW;AAC1B,WAAO,QAAQ,QAAQ,QAAQ;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,aAAa,UAA2C;AAC5D,UAAM,UAAU,MAAM,QAAQ,IAAI,SAAS,IAAI,CAAC,YAAY,qBAAqB,OAAO,CAAC,EAAE,IAAI,OAAO,aAAa,MAAM,SAAS,CAAC,CAAC;AACpI,WAAO,QAAQ,MAAM,CAAC,WAAW,MAAM;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,aAA4B;AAChC,QAAI,KAAK;AAAgB;AACzB,UAAM,KAAK,sBAAsB;AACjC,SAAK,iBAAiB;AACtB;AAAA,EACF;AAAA,EAEA,MAAgB,wBAAuC;AACrD,aAAS,UAAU,GAAG,UAAU,KAAK,gBAAgB,QAAQ,WAAW;AACtE,YAAM,iBAAiB,KAAK,gBAAgB,OAAO;AACnD,YAAM,WAAW,qBAAqB,cAAc;AACpD,UAAI,CAAE,MAAM,SAAS,GAAI;AACvB,aAAK,gBAAgB,cAAc,IAAI;AAAA,MACzC,OAAO;AACL,aAAK,gBAAgB,cAAc,IAAI;AAAA,MACzC;AAAA,IACF;AACA,SAAK,6BAA6B,OAAO,OAAO,KAAK,eAAe,EAAE,MAAM,CAAC,MAAM,CAAC;AAAA,EACtF;AACF;","names":[]}

package/dist/browser/WasmSupport.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WasmSupport.d.ts","sourceRoot":"","sources":["../../src/WasmSupport.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;CAiBvB,CAAA;AAEV,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,oBAAoB,CAAA;AAE3D,qBAAa,WAAW;IAeV,SAAS,CAAC,eAAe,EAAE,WAAW,EAAE;IAdpD,OAAO,CAAC,UAAU,CAAO;IACzB,OAAO,CAAC,eAAe,CAA4C;IACnE,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,0BAA0B,CAAQ;IAE1C;;;;;;;OAOG;gBACmB,eAAe,EAAE,WAAW,EAAE;IAEpD;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IACD;;OAEG;IACH,IAAI,SAAS,CAAC,CAAC,EAAE,OAAO,EAEvB;IAED;;;OAGG;IACH,IAAI,UAAU,IAAI,OAAO,CASxB;IAED;;;OAGG;IACH,IAAI,cAAc,IAAI,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,CAEpE;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IACD;;OAEG;IACH,IAAI,SAAS,CAAC,CAAC,EAAE,OAAO,EAEvB;IAED;;;OAGG;IACH,IAAI,4BAA4B,IAAI,OAAO,CAE1C;IAED;;;OAGG;IACH,IAAI,aAAa,IAAI,OAAO,CAE3B;IAED;;;;;;OAMG;WACU,MAAM,CAAC,eAAe,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAMzE;;;;OAIG;IACG,YAAY,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAK7D;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;cAOjB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;CAYvD"}

package/dist/browser/WasmSupport.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WasmSupport.d.ts","sourceRoot":"","sources":["../../src/WasmSupport.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;CAiBvB,CAAA;AAEV,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,oBAAoB,CAAA;AAE3D,qBAAa,WAAW;IAeV,SAAS,CAAC,eAAe,EAAE,WAAW,EAAE;IAdpD,OAAO,CAAC,UAAU,CAAO;IACzB,OAAO,CAAC,eAAe,CAA4C;IACnE,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,0BAA0B,CAAQ;IAE1C;;;;;;;OAOG;gBACmB,eAAe,EAAE,WAAW,EAAE;IAEpD;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IACD;;OAEG;IACH,IAAI,SAAS,CAAC,CAAC,EAAE,OAAO,EAEvB;IAED;;;OAGG;IACH,IAAI,UAAU,IAAI,OAAO,CASxB;IAED;;;OAGG;IACH,IAAI,cAAc,IAAI,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,CAEpE;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IACD;;OAEG;IACH,IAAI,SAAS,CAAC,CAAC,EAAE,OAAO,EAEvB;IAED;;;OAGG;IACH,IAAI,4BAA4B,IAAI,OAAO,CAE1C;IAED;;;OAGG;IACH,IAAI,aAAa,IAAI,OAAO,CAE3B;IAED;;;;;;OAMG;WACU,MAAM,CAAC,eAAe,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAMzE;;;;OAIG;IACG,YAAY,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAK7D;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;cAOjB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;CAYvD"}

package/dist/browser/WasmSupport.d.ts

@@ -0,0 +1,92 @@
+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: () => Promise<boolean>;
+    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 {
+    protected desiredFeatures: WasmFeature[];
+    private _allowWasm;
+    private _featureSupport;
+    private _forceWasm;
+    private _isInitialized;
+    private _isWasmFeatureSetSupported;
+    /**
+     * 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[]);
+    /**
+     * Is Wasm allowed
+     */
+    get allowWasm(): boolean;
+    /**
+     * Whether or not to allow WASM usage
+     */
+    set allowWasm(v: boolean);
+    /**
+     * Whether or not Wasm 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 wasm feature
+     * with a boolean value indicating whether or not the feature is supported
+     */
+    get featureSupport(): Readonly<Partial<Record<WasmFeature, boolean>>>;
+    /**
+     * Force use of Wasm
+     */
+    get forceWasm(): boolean;
+    /**
+     * Whether or not to force Wasm usage
+     */
+    set forceWasm(v: boolean);
+    /**
+     * Whether or not Wasm is supported based
+     * on the desired feature set
+     */
+    get isDesiredFeatureSetSupported(): boolean;
+    /**
+     * Whether or not Wasm detection has been run
+     * for the desired feature set
+     */
+    get isInitialized(): boolean;
+    /**
+     * 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>;
+    /**
+     * Checks for specific wasm 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>;
+    protected detectDesiredFeatures(): Promise<void>;
+}
+//# sourceMappingURL=WasmSupport.d.ts.map

package/dist/browser/WasmSupport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WasmSupport.d.ts","sourceRoot":"","sources":["../../src/WasmSupport.ts"],"names":[],"mappings":"AAmBA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;CAiBvB,CAAA;AAEV,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,oBAAoB,CAAA;AAE3D,qBAAa,WAAW;IAeV,SAAS,CAAC,eAAe,EAAE,WAAW,EAAE;IAdpD,OAAO,CAAC,UAAU,CAAO;IACzB,OAAO,CAAC,eAAe,CAA4C;IACnE,OAAO,CAAC,UAAU,CAAQ;IAC1B,OAAO,CAAC,cAAc,CAAQ;IAC9B,OAAO,CAAC,0BAA0B,CAAQ;IAE1C;;;;;;;OAOG;gBACmB,eAAe,EAAE,WAAW,EAAE;IAEpD;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IACD;;OAEG;IACH,IAAI,SAAS,CAAC,CAAC,EAAE,OAAO,EAEvB;IAED;;;OAGG;IACH,IAAI,UAAU,IAAI,OAAO,CASxB;IAED;;;OAGG;IACH,IAAI,cAAc,IAAI,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,CAEpE;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAEvB;IACD;;OAEG;IACH,IAAI,SAAS,CAAC,CAAC,EAAE,OAAO,EAEvB;IAED;;;OAGG;IACH,IAAI,4BAA4B,IAAI,OAAO,CAE1C;IAED;;;OAGG;IACH,IAAI,aAAa,IAAI,OAAO,CAE3B;IAED;;;;;;OAMG;WACU,MAAM,CAAC,eAAe,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAMzE;;;;OAIG;IACG,YAAY,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAK7D;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;cAOjB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC;CAYvD"}

package/dist/browser/WasmSupport.js

@@ -0,0 +1,159 @@
+import {
+  bigInt,
+  bulkMemory,
+  exceptions,
+  extendedConst,
+  gc,
+  memory64,
+  multiValue,
+  mutableGlobals,
+  referenceTypes,
+  relaxedSimd,
+  saturatedFloatToInt,
+  signExtensions,
+  simd,
+  streamingCompilation,
+  tailCall,
+  threads
+} from "wasm-feature-detect";
+const WasmFeatureDetectors = {
+  bigInt,
+  bulkMemory,
+  exceptions,
+  extendedConst,
+  gc,
+  memory64,
+  multiValue,
+  mutableGlobals,
+  referenceTypes,
+  relaxedSimd,
+  saturatedFloatToInt,
+  signExtensions,
+  simd,
+  streamingCompilation,
+  tailCall,
+  threads
+};
+class 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
+   * @param desiredFeatures The desired feature set
+   */
+  constructor(desiredFeatures) {
+    this.desiredFeatures = desiredFeatures;
+  }
+  _allowWasm = true;
+  _featureSupport = {};
+  _forceWasm = false;
+  _isInitialized = false;
+  _isWasmFeatureSetSupported = false;
+  /**
+   * Is Wasm allowed
+   */
+  get allowWasm() {
+    return this._allowWasm;
+  }
+  /**
+   * Whether or not to allow WASM usage
+   */
+  set allowWasm(v) {
+    this._allowWasm = v;
+  }
+  /**
+   * Whether or not Wasm should be used based on the desired
+   * feature set, initialization state, or force-use settings
+   */
+  get canUseWasm() {
+    return (
+      // Just force WASM
+      this._forceWasm || // Or if we haven't checked be optimistic
+      this._allowWasm && !this._isInitialized || // Or if we have checked and WASM is not supported, be realistic
+      this._allowWasm && this._isInitialized && this._isWasmFeatureSetSupported
+    );
+  }
+  /**
+   * Returns a object containing a property for each desired wasm feature
+   * with a boolean value indicating whether or not the feature is supported
+   */
+  get featureSupport() {
+    return { ...this._featureSupport };
+  }
+  /**
+   * Force use of Wasm
+   */
+  get forceWasm() {
+    return this._forceWasm;
+  }
+  /**
+   * Whether or not to force Wasm usage
+   */
+  set forceWasm(v) {
+    this._forceWasm = v;
+  }
+  /**
+   * Whether or not Wasm is supported based
+   * on the desired feature set
+   */
+  get isDesiredFeatureSetSupported() {
+    return this._isWasmFeatureSetSupported;
+  }
+  /**
+   * Whether or not Wasm detection has been run
+   * for the desired feature set
+   */
+  get isInitialized() {
+    return this._isInitialized;
+  }
+  /**
+   * 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 async create(desiredFeatures) {
+    const instance = new WasmSupport(desiredFeatures);
+    await instance.initialize();
+    return Promise.resolve(instance);
+  }
+  /**
+   * Checks for specific wasm features
+   * @param features The list of features to check for
+   * @returns True if all the features are supported, false otherwise
+   */
+  async featureCheck(features) {
+    const results = await Promise.all(features.map((feature) => WasmFeatureDetectors[feature]).map(async (detector) => await detector()));
+    return results.every((result) => result);
+  }
+  /**
+   * Does feature detection for the desired feature set
+   */
+  async initialize() {
+    if (this._isInitialized)
+      return;
+    await this.detectDesiredFeatures();
+    this._isInitialized = true;
+    return;
+  }
+  async detectDesiredFeatures() {
+    for (let feature = 0; feature < this.desiredFeatures.length; feature++) {
+      const desiredFeature = this.desiredFeatures[feature];
+      const detector = WasmFeatureDetectors[desiredFeature];
+      if (!await detector()) {
+        this._featureSupport[desiredFeature] = false;
+      } else {
+        this._featureSupport[desiredFeature] = true;
+      }
+    }
+    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every((v) => v);
+  }
+}
+export {
+  WasmFeatureDetectors,
+  WasmSupport
+};
+//# sourceMappingURL=WasmSupport.js.map

package/dist/browser/WasmSupport.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/WasmSupport.ts"],"sourcesContent":["import {\n  bigInt,\n  bulkMemory,\n  exceptions,\n  extendedConst,\n  gc,\n  memory64,\n  multiValue,\n  mutableGlobals,\n  referenceTypes,\n  relaxedSimd,\n  saturatedFloatToInt,\n  signExtensions,\n  simd,\n  streamingCompilation,\n  tailCall,\n  threads,\n} from 'wasm-feature-detect'\n\nexport const WasmFeatureDetectors = {\n  bigInt: bigInt,\n  bulkMemory: bulkMemory,\n  exceptions: exceptions,\n  extendedConst: extendedConst,\n  gc: gc,\n  memory64: memory64,\n  multiValue: multiValue,\n  mutableGlobals: mutableGlobals,\n  referenceTypes: referenceTypes,\n  relaxedSimd: relaxedSimd,\n  saturatedFloatToInt: saturatedFloatToInt,\n  signExtensions: signExtensions,\n  simd: simd,\n  streamingCompilation: streamingCompilation,\n  tailCall: tailCall,\n  threads: threads,\n} as const\n\nexport type WasmFeature = keyof typeof WasmFeatureDetectors\n\nexport class WasmSupport {\n  private _allowWasm = true\n  private _featureSupport: Partial<Record<WasmFeature, boolean>> = {}\n  private _forceWasm = false\n  private _isInitialized = false\n  private _isWasmFeatureSetSupported = false\n\n  /**\n   * Instance constructor for use where async instantiation\n   * is not possible. Where possible, prefer the static\n   * create method over use of this constructor directly\n   * as no initialization (feature detection) is able to\n   * be done here\n   * @param desiredFeatures The desired feature set\n   */\n  constructor(protected desiredFeatures: WasmFeature[]) {}\n\n  /**\n   * Is Wasm allowed\n   */\n  get allowWasm(): boolean {\n    return this._allowWasm\n  }\n  /**\n   * Whether or not to allow WASM usage\n   */\n  set allowWasm(v: boolean) {\n    this._allowWasm = v\n  }\n\n  /**\n   * Whether or not Wasm should be used based on the desired\n   * feature set, initialization state, or force-use settings\n   */\n  get canUseWasm(): boolean {\n    return (\n      // Just force WASM\n      this._forceWasm ||\n      // Or if we haven't checked be optimistic\n      (this._allowWasm && !this._isInitialized) ||\n      // Or if we have checked and WASM is not supported, be realistic\n      (this._allowWasm && this._isInitialized && this._isWasmFeatureSetSupported)\n    )\n  }\n\n  /**\n   * Returns a object containing a property for each desired wasm feature\n   * with a boolean value indicating whether or not the feature is supported\n   */\n  get featureSupport(): Readonly<Partial<Record<WasmFeature, boolean>>> {\n    return { ...this._featureSupport }\n  }\n\n  /**\n   * Force use of Wasm\n   */\n  get forceWasm(): boolean {\n    return this._forceWasm\n  }\n  /**\n   * Whether or not to force Wasm usage\n   */\n  set forceWasm(v: boolean) {\n    this._forceWasm = v\n  }\n\n  /**\n   * Whether or not Wasm is supported based\n   * on the desired feature set\n   */\n  get isDesiredFeatureSetSupported(): boolean {\n    return this._isWasmFeatureSetSupported\n  }\n\n  /**\n   * Whether or not Wasm detection has been run\n   * for the desired feature set\n   */\n  get isInitialized(): boolean {\n    return this._isInitialized\n  }\n\n  /**\n   * Static creation & async initialization for use where\n   * async instantiation is possible\n   * @param desiredFeatures The desired feature set\n   * @returns An initialized instance of the class with detection\n   * for the desired feature set\n   */\n  static async create(desiredFeatures: WasmFeature[]): Promise<WasmSupport> {\n    const instance = new WasmSupport(desiredFeatures)\n    await instance.initialize()\n    return Promise.resolve(instance)\n  }\n\n  /**\n   * Checks for specific wasm features\n   * @param features The list of features to check for\n   * @returns True if all the features are supported, false otherwise\n   */\n  async featureCheck(features: WasmFeature[]): Promise<boolean> {\n    const results = await Promise.all(features.map((feature) => WasmFeatureDetectors[feature]).map(async (detector) => await detector()))\n    return results.every((result) => result)\n  }\n\n  /**\n   * Does feature detection for the desired feature set\n   */\n  async initialize(): Promise<void> {\n    if (this._isInitialized) return\n    await this.detectDesiredFeatures()\n    this._isInitialized = true\n    return\n  }\n\n  protected async detectDesiredFeatures(): Promise<void> {\n    for (let feature = 0; feature < this.desiredFeatures.length; feature++) {\n      const desiredFeature = this.desiredFeatures[feature]\n      const detector = WasmFeatureDetectors[desiredFeature]\n      if (!(await detector())) {\n        this._featureSupport[desiredFeature] = false\n      } else {\n        this._featureSupport[desiredFeature] = true\n      }\n    }\n    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every((v) => v)\n  }\n}\n"],"mappings":"AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEA,MAAM,uBAAuB;AAAA,EAClC;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAIO,MAAM,YAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAevB,YAAsB,iBAAgC;AAAhC;AAAA,EAAiC;AAAA,EAd/C,aAAa;AAAA,EACb,kBAAyD,CAAC;AAAA,EAC1D,aAAa;AAAA,EACb,iBAAiB;AAAA,EACjB,6BAA6B;AAAA;AAAA;AAAA;AAAA,EAerC,IAAI,YAAqB;AACvB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,UAAU,GAAY;AACxB,SAAK,aAAa;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAI,aAAsB;AACxB;AAAA;AAAA,MAEE,KAAK;AAAA,MAEJ,KAAK,cAAc,CAAC,KAAK;AAAA,MAEzB,KAAK,cAAc,KAAK,kBAAkB,KAAK;AAAA;AAAA,EAEpD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAI,iBAAkE;AACpE,WAAO,EAAE,GAAG,KAAK,gBAAgB;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,YAAqB;AACvB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,UAAU,GAAY;AACxB,SAAK,aAAa;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAI,+BAAwC;AAC1C,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAI,gBAAyB;AAC3B,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,aAAa,OAAO,iBAAsD;AACxE,UAAM,WAAW,IAAI,YAAY,eAAe;AAChD,UAAM,SAAS,WAAW;AAC1B,WAAO,QAAQ,QAAQ,QAAQ;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,aAAa,UAA2C;AAC5D,UAAM,UAAU,MAAM,QAAQ,IAAI,SAAS,IAAI,CAAC,YAAY,qBAAqB,OAAO,CAAC,EAAE,IAAI,OAAO,aAAa,MAAM,SAAS,CAAC,CAAC;AACpI,WAAO,QAAQ,MAAM,CAAC,WAAW,MAAM;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,aAA4B;AAChC,QAAI,KAAK;AAAgB;AACzB,UAAM,KAAK,sBAAsB;AACjC,SAAK,iBAAiB;AACtB;AAAA,EACF;AAAA,EAEA,MAAgB,wBAAuC;AACrD,aAAS,UAAU,GAAG,UAAU,KAAK,gBAAgB,QAAQ,WAAW;AACtE,YAAM,iBAAiB,KAAK,gBAAgB,OAAO;AACnD,YAAM,WAAW,qBAAqB,cAAc;AACpD,UAAI,CAAE,MAAM,SAAS,GAAI;AACvB,aAAK,gBAAgB,cAAc,IAAI;AAAA,MACzC,OAAO;AACL,aAAK,gBAAgB,cAAc,IAAI;AAAA,MACzC;AAAA,IACF;AACA,SAAK,6BAA6B,OAAO,OAAO,KAAK,eAAe,EAAE,MAAM,CAAC,MAAM,CAAC;AAAA,EACtF;AACF;","names":[]}

package/dist/browser/index.cjs

@@ -0,0 +1,166 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  WasmFeatureDetectors: () => WasmFeatureDetectors,
+  WasmSupport: () => WasmSupport
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/WasmSupport.ts
+var import_wasm_feature_detect = require("wasm-feature-detect");
+var WasmFeatureDetectors = {
+  bigInt: import_wasm_feature_detect.bigInt,
+  bulkMemory: import_wasm_feature_detect.bulkMemory,
+  exceptions: import_wasm_feature_detect.exceptions,
+  extendedConst: import_wasm_feature_detect.extendedConst,
+  gc: import_wasm_feature_detect.gc,
+  memory64: import_wasm_feature_detect.memory64,
+  multiValue: import_wasm_feature_detect.multiValue,
+  mutableGlobals: import_wasm_feature_detect.mutableGlobals,
+  referenceTypes: import_wasm_feature_detect.referenceTypes,
+  relaxedSimd: import_wasm_feature_detect.relaxedSimd,
+  saturatedFloatToInt: import_wasm_feature_detect.saturatedFloatToInt,
+  signExtensions: import_wasm_feature_detect.signExtensions,
+  simd: import_wasm_feature_detect.simd,
+  streamingCompilation: import_wasm_feature_detect.streamingCompilation,
+  tailCall: import_wasm_feature_detect.tailCall,
+  threads: import_wasm_feature_detect.threads
+};
+var WasmSupport = class _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
+   * @param desiredFeatures The desired feature set
+   */
+  constructor(desiredFeatures) {
+    this.desiredFeatures = desiredFeatures;
+  }
+  _allowWasm = true;
+  _featureSupport = {};
+  _forceWasm = false;
+  _isInitialized = false;
+  _isWasmFeatureSetSupported = false;
+  /**
+   * Is Wasm allowed
+   */
+  get allowWasm() {
+    return this._allowWasm;
+  }
+  /**
+   * Whether or not to allow WASM usage
+   */
+  set allowWasm(v) {
+    this._allowWasm = v;
+  }
+  /**
+   * Whether or not Wasm should be used based on the desired
+   * feature set, initialization state, or force-use settings
+   */
+  get canUseWasm() {
+    return (
+      // Just force WASM
+      this._forceWasm || // Or if we haven't checked be optimistic
+      this._allowWasm && !this._isInitialized || // Or if we have checked and WASM is not supported, be realistic
+      this._allowWasm && this._isInitialized && this._isWasmFeatureSetSupported
+    );
+  }
+  /**
+   * Returns a object containing a property for each desired wasm feature
+   * with a boolean value indicating whether or not the feature is supported
+   */
+  get featureSupport() {
+    return { ...this._featureSupport };
+  }
+  /**
+   * Force use of Wasm
+   */
+  get forceWasm() {
+    return this._forceWasm;
+  }
+  /**
+   * Whether or not to force Wasm usage
+   */
+  set forceWasm(v) {
+    this._forceWasm = v;
+  }
+  /**
+   * Whether or not Wasm is supported based
+   * on the desired feature set
+   */
+  get isDesiredFeatureSetSupported() {
+    return this._isWasmFeatureSetSupported;
+  }
+  /**
+   * Whether or not Wasm detection has been run
+   * for the desired feature set
+   */
+  get isInitialized() {
+    return this._isInitialized;
+  }
+  /**
+   * 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 async create(desiredFeatures) {
+    const instance = new _WasmSupport(desiredFeatures);
+    await instance.initialize();
+    return Promise.resolve(instance);
+  }
+  /**
+   * Checks for specific wasm features
+   * @param features The list of features to check for
+   * @returns True if all the features are supported, false otherwise
+   */
+  async featureCheck(features) {
+    const results = await Promise.all(features.map((feature) => WasmFeatureDetectors[feature]).map(async (detector) => await detector()));
+    return results.every((result) => result);
+  }
+  /**
+   * Does feature detection for the desired feature set
+   */
+  async initialize() {
+    if (this._isInitialized)
+      return;
+    await this.detectDesiredFeatures();
+    this._isInitialized = true;
+    return;
+  }
+  async detectDesiredFeatures() {
+    for (let feature = 0; feature < this.desiredFeatures.length; feature++) {
+      const desiredFeature = this.desiredFeatures[feature];
+      const detector = WasmFeatureDetectors[desiredFeature];
+      if (!await detector()) {
+        this._featureSupport[desiredFeature] = false;
+      } else {
+        this._featureSupport[desiredFeature] = true;
+      }
+    }
+    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every((v) => v);
+  }
+};
+//# sourceMappingURL=index.cjs.map

package/dist/browser/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts","../../src/WasmSupport.ts"],"sourcesContent":["export * from './WasmSupport'\n","import {\n  bigInt,\n  bulkMemory,\n  exceptions,\n  extendedConst,\n  gc,\n  memory64,\n  multiValue,\n  mutableGlobals,\n  referenceTypes,\n  relaxedSimd,\n  saturatedFloatToInt,\n  signExtensions,\n  simd,\n  streamingCompilation,\n  tailCall,\n  threads,\n} from 'wasm-feature-detect'\n\nexport const WasmFeatureDetectors = {\n  bigInt: bigInt,\n  bulkMemory: bulkMemory,\n  exceptions: exceptions,\n  extendedConst: extendedConst,\n  gc: gc,\n  memory64: memory64,\n  multiValue: multiValue,\n  mutableGlobals: mutableGlobals,\n  referenceTypes: referenceTypes,\n  relaxedSimd: relaxedSimd,\n  saturatedFloatToInt: saturatedFloatToInt,\n  signExtensions: signExtensions,\n  simd: simd,\n  streamingCompilation: streamingCompilation,\n  tailCall: tailCall,\n  threads: threads,\n} as const\n\nexport type WasmFeature = keyof typeof WasmFeatureDetectors\n\nexport class WasmSupport {\n  private _allowWasm = true\n  private _featureSupport: Partial<Record<WasmFeature, boolean>> = {}\n  private _forceWasm = false\n  private _isInitialized = false\n  private _isWasmFeatureSetSupported = false\n\n  /**\n   * Instance constructor for use where async instantiation\n   * is not possible. Where possible, prefer the static\n   * create method over use of this constructor directly\n   * as no initialization (feature detection) is able to\n   * be done here\n   * @param desiredFeatures The desired feature set\n   */\n  constructor(protected desiredFeatures: WasmFeature[]) {}\n\n  /**\n   * Is Wasm allowed\n   */\n  get allowWasm(): boolean {\n    return this._allowWasm\n  }\n  /**\n   * Whether or not to allow WASM usage\n   */\n  set allowWasm(v: boolean) {\n    this._allowWasm = v\n  }\n\n  /**\n   * Whether or not Wasm should be used based on the desired\n   * feature set, initialization state, or force-use settings\n   */\n  get canUseWasm(): boolean {\n    return (\n      // Just force WASM\n      this._forceWasm ||\n      // Or if we haven't checked be optimistic\n      (this._allowWasm && !this._isInitialized) ||\n      // Or if we have checked and WASM is not supported, be realistic\n      (this._allowWasm && this._isInitialized && this._isWasmFeatureSetSupported)\n    )\n  }\n\n  /**\n   * Returns a object containing a property for each desired wasm feature\n   * with a boolean value indicating whether or not the feature is supported\n   */\n  get featureSupport(): Readonly<Partial<Record<WasmFeature, boolean>>> {\n    return { ...this._featureSupport }\n  }\n\n  /**\n   * Force use of Wasm\n   */\n  get forceWasm(): boolean {\n    return this._forceWasm\n  }\n  /**\n   * Whether or not to force Wasm usage\n   */\n  set forceWasm(v: boolean) {\n    this._forceWasm = v\n  }\n\n  /**\n   * Whether or not Wasm is supported based\n   * on the desired feature set\n   */\n  get isDesiredFeatureSetSupported(): boolean {\n    return this._isWasmFeatureSetSupported\n  }\n\n  /**\n   * Whether or not Wasm detection has been run\n   * for the desired feature set\n   */\n  get isInitialized(): boolean {\n    return this._isInitialized\n  }\n\n  /**\n   * Static creation & async initialization for use where\n   * async instantiation is possible\n   * @param desiredFeatures The desired feature set\n   * @returns An initialized instance of the class with detection\n   * for the desired feature set\n   */\n  static async create(desiredFeatures: WasmFeature[]): Promise<WasmSupport> {\n    const instance = new WasmSupport(desiredFeatures)\n    await instance.initialize()\n    return Promise.resolve(instance)\n  }\n\n  /**\n   * Checks for specific wasm features\n   * @param features The list of features to check for\n   * @returns True if all the features are supported, false otherwise\n   */\n  async featureCheck(features: WasmFeature[]): Promise<boolean> {\n    const results = await Promise.all(features.map((feature) => WasmFeatureDetectors[feature]).map(async (detector) => await detector()))\n    return results.every((result) => result)\n  }\n\n  /**\n   * Does feature detection for the desired feature set\n   */\n  async initialize(): Promise<void> {\n    if (this._isInitialized) return\n    await this.detectDesiredFeatures()\n    this._isInitialized = true\n    return\n  }\n\n  protected async detectDesiredFeatures(): Promise<void> {\n    for (let feature = 0; feature < this.desiredFeatures.length; feature++) {\n      const desiredFeature = this.desiredFeatures[feature]\n      const detector = WasmFeatureDetectors[desiredFeature]\n      if (!(await detector())) {\n        this._featureSupport[desiredFeature] = false\n      } else {\n        this._featureSupport[desiredFeature] = true\n      }\n    }\n    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every((v) => v)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,iCAiBO;AAEA,IAAM,uBAAuB;AAAA,EAClC,QAAQ;AAAA,EACR,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,eAAe;AAAA,EACf,IAAI;AAAA,EACJ,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,gBAAgB;AAAA,EAChB,aAAa;AAAA,EACb,qBAAqB;AAAA,EACrB,gBAAgB;AAAA,EAChB,MAAM;AAAA,EACN,sBAAsB;AAAA,EACtB,UAAU;AAAA,EACV,SAAS;AACX;AAIO,IAAM,cAAN,MAAM,aAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAevB,YAAsB,iBAAgC;AAAhC;AAAA,EAAiC;AAAA,EAd/C,aAAa;AAAA,EACb,kBAAyD,CAAC;AAAA,EAC1D,aAAa;AAAA,EACb,iBAAiB;AAAA,EACjB,6BAA6B;AAAA;AAAA;AAAA;AAAA,EAerC,IAAI,YAAqB;AACvB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,UAAU,GAAY;AACxB,SAAK,aAAa;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAI,aAAsB;AACxB;AAAA;AAAA,MAEE,KAAK;AAAA,MAEJ,KAAK,cAAc,CAAC,KAAK;AAAA,MAEzB,KAAK,cAAc,KAAK,kBAAkB,KAAK;AAAA;AAAA,EAEpD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAI,iBAAkE;AACpE,WAAO,EAAE,GAAG,KAAK,gBAAgB;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,YAAqB;AACvB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAIA,IAAI,UAAU,GAAY;AACxB,SAAK,aAAa;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAI,+BAAwC;AAC1C,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,IAAI,gBAAyB;AAC3B,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,aAAa,OAAO,iBAAsD;AACxE,UAAM,WAAW,IAAI,aAAY,eAAe;AAChD,UAAM,SAAS,WAAW;AAC1B,WAAO,QAAQ,QAAQ,QAAQ;AAAA,EACjC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,MAAM,aAAa,UAA2C;AAC5D,UAAM,UAAU,MAAM,QAAQ,IAAI,SAAS,IAAI,CAAC,YAAY,qBAAqB,OAAO,CAAC,EAAE,IAAI,OAAO,aAAa,MAAM,SAAS,CAAC,CAAC;AACpI,WAAO,QAAQ,MAAM,CAAC,WAAW,MAAM;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA,EAKA,MAAM,aAA4B;AAChC,QAAI,KAAK;AAAgB;AACzB,UAAM,KAAK,sBAAsB;AACjC,SAAK,iBAAiB;AACtB;AAAA,EACF;AAAA,EAEA,MAAgB,wBAAuC;AACrD,aAAS,UAAU,GAAG,UAAU,KAAK,gBAAgB,QAAQ,WAAW;AACtE,YAAM,iBAAiB,KAAK,gBAAgB,OAAO;AACnD,YAAM,WAAW,qBAAqB,cAAc;AACpD,UAAI,CAAE,MAAM,SAAS,GAAI;AACvB,aAAK,gBAAgB,cAAc,IAAI;AAAA,MACzC,OAAO;AACL,aAAK,gBAAgB,cAAc,IAAI;AAAA,MACzC;AAAA,IACF;AACA,SAAK,6BAA6B,OAAO,OAAO,KAAK,eAAe,EAAE,MAAM,CAAC,MAAM,CAAC;AAAA,EACtF;AACF;","names":[]}

package/dist/browser/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA"}

package/dist/{index.d.mts.map → browser/index.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA"}

package/dist/browser/index.d.ts

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

package/dist/{index.d.ts.map → browser/index.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAA"}

package/dist/browser/index.js

@@ -0,0 +1,2 @@
+export * from "./WasmSupport";
+//# sourceMappingURL=index.js.map

package/dist/browser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["export * from './WasmSupport'\n"],"mappings":"AAAA,cAAc;","names":[]}