@xyo-network/wasm 2.107.1 → 2.107.4

package/dist/browser/index.cjs

@@ -1,2 +1,173 @@
-"use strict";var o=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var u=(s,t)=>o(s,"name",{value:t,configurable:!0});var p=(s,t)=>{for(var a in t)o(s,a,{get:t[a],enumerable:!0})},h=(s,t,a,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let r of d(t))!c.call(s,r)&&r!==a&&o(s,r,{get:()=>t[r],enumerable:!(i=m(t,r))||i.enumerable});return s};var _=s=>h(o({},"__esModule",{value:!0}),s);var f={};p(f,{WasmFeatureDetectors:()=>l,WasmSupport:()=>n});module.exports=_(f);var e=require("wasm-feature-detect");var l={bigInt:e.bigInt,bulkMemory:e.bulkMemory,exceptions:e.exceptions,extendedConst:e.extendedConst,gc:e.gc,memory64:e.memory64,multiValue:e.multiValue,mutableGlobals:e.mutableGlobals,referenceTypes:e.referenceTypes,relaxedSimd:e.relaxedSimd,saturatedFloatToInt:e.saturatedFloatToInt,signExtensions:e.signExtensions,simd:e.simd,streamingCompilation:e.streamingCompilation,tailCall:e.tailCall,threads:e.threads},n=class s{static{u(this,"WasmSupport")}desiredFeatures;_allowWasm;_featureSupport;_forceWasm;_isInitialized;_isWasmFeatureSetSupported;constructor(t){this.desiredFeatures=t,this._allowWasm=!0,this._featureSupport={},this._forceWasm=!1,this._isInitialized=!1,this._isWasmFeatureSetSupported=!1}get allowWasm(){return this._allowWasm}set allowWasm(t){this._allowWasm=t}get canUseWasm(){return this._forceWasm||this._allowWasm&&!this._isInitialized||this._allowWasm&&this._isInitialized&&this._isWasmFeatureSetSupported}get featureSupport(){return{...this._featureSupport}}get forceWasm(){return this._forceWasm}set forceWasm(t){this._forceWasm=t}get isDesiredFeatureSetSupported(){return this._isWasmFeatureSetSupported}get isInitialized(){return this._isInitialized}static async create(t){let a=new s(t);return await a.initialize(),a}async featureCheck(t){return(await Promise.all(t.map(i=>l[i]).map(async i=>await i()))).every(Boolean)}async initialize(){this._isInitialized||(await this.detectDesiredFeatures(),this._isInitialized=!0)}async detectDesiredFeatures(){for(let t=0;t<this.desiredFeatures.length;t++){let a=this.desiredFeatures[t],i=l[a];this._featureSupport[a]=!!await i()}this._isWasmFeatureSetSupported=Object.values(this._featureSupport).every(Boolean)}};
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 {
+  static {
+    __name(this, "WasmSupport");
+  }
+  desiredFeatures;
+  _allowWasm;
+  _featureSupport;
+  _forceWasm;
+  _isInitialized;
+  _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) {
+    this.desiredFeatures = desiredFeatures;
+    this._allowWasm = true;
+    this._featureSupport = {};
+    this._forceWasm = false;
+    this._isInitialized = false;
+    this._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 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(Boolean);
+  }
+  /**
+  * 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];
+      this._featureSupport[desiredFeature] = await detector() ? true : false;
+    }
+    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean);
+  }
+};
 //# sourceMappingURL=index.cjs.map

package/dist/browser/index.cjs.map

@@ -1 +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 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(Boolean)\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      this._featureSupport[desiredFeature] = (await detector()) ? true : false\n    }\n    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean)\n  }\n}\n"],"mappings":"4dAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,0BAAAE,EAAA,gBAAAC,IAAA,eAAAC,EAAAJ,GCAA,IAAAK,EAiBO,+BAEA,IAAMC,EAAuB,CAClCC,OAAQA,SACRC,WAAYA,aACZC,WAAYA,aACZC,cAAeA,gBACfC,GAAIA,KACJC,SAAUA,WACVC,WAAYA,aACZC,eAAgBA,iBAChBC,eAAgBA,iBAChBC,YAAaA,cACbC,oBAAqBA,sBACrBC,eAAgBA,iBAChBC,KAAMA,OACNC,qBAAsBA,uBACtBC,SAAUA,WACVC,QAASA,SACX,EAIaC,EAAN,MAAMA,CAAAA,CAxCb,MAwCaA,CAAAA,EAAAA,oCACHC,WACAC,gBACAC,WACAC,eACAC,2BAURC,YAAsBC,EAAgC,MAAhCA,gBAAAA,OAddN,WAAa,QACbC,gBAAyD,CAAC,OAC1DC,WAAa,QACbC,eAAiB,QACjBC,2BAA6B,EAUkB,CAKvD,IAAIG,WAAqB,CACvB,OAAO,KAAKP,UACd,CAIA,IAAIO,UAAUC,EAAY,CACxB,KAAKR,WAAaQ,CACpB,CAMA,IAAIC,YAAsB,CACxB,OAEE,KAAKP,YAEJ,KAAKF,YAAc,CAAC,KAAKG,gBAEzB,KAAKH,YAAc,KAAKG,gBAAkB,KAAKC,0BAEpD,CAMA,IAAIM,gBAAkE,CACpE,MAAO,CAAE,GAAG,KAAKT,eAAgB,CACnC,CAKA,IAAIU,WAAqB,CACvB,OAAO,KAAKT,UACd,CAIA,IAAIS,UAAUH,EAAY,CACxB,KAAKN,WAAaM,CACpB,CAMA,IAAII,8BAAwC,CAC1C,OAAO,KAAKR,0BACd,CAMA,IAAIS,eAAyB,CAC3B,OAAO,KAAKV,cACd,CASA,aAAaW,OAAOR,EAAsD,CACxE,IAAMS,EAAW,IAAIhB,EAAYO,CAAAA,EACjC,aAAMS,EAASC,WAAU,EAClBD,CACT,CAOA,MAAME,aAAaC,EAA2C,CAE5D,OADgB,MAAMC,QAAQC,IAAIF,EAASG,IAAKC,GAAYxC,EAAqBwC,CAAAA,CAAQ,EAAED,IAAI,MAAOE,GAAa,MAAMA,EAAAA,CAAAA,CAAAA,GAC1GC,MAAMC,OAAAA,CACvB,CAKA,MAAMT,YAA4B,CAC5B,KAAKb,iBACT,MAAM,KAAKuB,sBAAqB,EAChC,KAAKvB,eAAiB,GAExB,CAEA,MAAgBuB,uBAAuC,CACrD,QAASJ,EAAU,EAAGA,EAAU,KAAKhB,gBAAgBqB,OAAQL,IAAW,CACtE,IAAMM,EAAiB,KAAKtB,gBAAgBgB,CAAAA,EACtCC,EAAWzC,EAAqB8C,CAAAA,EACtC,KAAK3B,gBAAgB2B,CAAAA,EAAmB,QAAML,EAAAA,CAChD,CACA,KAAKnB,2BAA6ByB,OAAOC,OAAO,KAAK7B,eAAe,EAAEuB,MAAMC,OAAAA,CAC9E,CACF","names":["src_exports","__export","WasmFeatureDetectors","WasmSupport","__toCommonJS","import_wasm_feature_detect","WasmFeatureDetectors","bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmSupport","_allowWasm","_featureSupport","_forceWasm","_isInitialized","_isWasmFeatureSetSupported","constructor","desiredFeatures","allowWasm","v","canUseWasm","featureSupport","forceWasm","isDesiredFeatureSetSupported","isInitialized","create","instance","initialize","featureCheck","features","Promise","all","map","feature","detector","every","Boolean","detectDesiredFeatures","length","desiredFeature","Object","values"]}
+{"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 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(Boolean)\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      this._featureSupport[desiredFeature] = (await detector()) ? true : false\n    }\n    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;ACAA,iCAiBO;AAEA,IAAMA,uBAAuB;EAClCC,QAAQA;EACRC,YAAYA;EACZC,YAAYA;EACZC,eAAeA;EACfC,IAAIA;EACJC,UAAUA;EACVC,YAAYA;EACZC,gBAAgBA;EAChBC,gBAAgBA;EAChBC,aAAaA;EACbC,qBAAqBA;EACrBC,gBAAgBA;EAChBC,MAAMA;EACNC,sBAAsBA;EACtBC,UAAUA;EACVC,SAASA;AACX;AAIO,IAAMC,cAAN,MAAMA,aAAAA;EAxCb,OAwCaA;;;;EACHC;EACAC;EACAC;EACAC;EACAC;;;;;;;;;EAURC,YAAsBC,iBAAgC;SAAhCA,kBAAAA;SAddN,aAAa;SACbC,kBAAyD,CAAC;SAC1DC,aAAa;SACbC,iBAAiB;SACjBC,6BAA6B;EAUkB;;;;EAKvD,IAAIG,YAAqB;AACvB,WAAO,KAAKP;EACd;;;;EAIA,IAAIO,UAAUC,GAAY;AACxB,SAAKR,aAAaQ;EACpB;;;;;EAMA,IAAIC,aAAsB;AACxB;;MAEE,KAAKP;MAEJ,KAAKF,cAAc,CAAC,KAAKG;MAEzB,KAAKH,cAAc,KAAKG,kBAAkB,KAAKC;;EAEpD;;;;;EAMA,IAAIM,iBAAkE;AACpE,WAAO;MAAE,GAAG,KAAKT;IAAgB;EACnC;;;;EAKA,IAAIU,YAAqB;AACvB,WAAO,KAAKT;EACd;;;;EAIA,IAAIS,UAAUH,GAAY;AACxB,SAAKN,aAAaM;EACpB;;;;;EAMA,IAAII,+BAAwC;AAC1C,WAAO,KAAKR;EACd;;;;;EAMA,IAAIS,gBAAyB;AAC3B,WAAO,KAAKV;EACd;;;;;;;;EASA,aAAaW,OAAOR,iBAAsD;AACxE,UAAMS,WAAW,IAAIhB,aAAYO,eAAAA;AACjC,UAAMS,SAASC,WAAU;AACzB,WAAOD;EACT;;;;;;EAOA,MAAME,aAAaC,UAA2C;AAC5D,UAAMC,UAAU,MAAMC,QAAQC,IAAIH,SAASI,IAAI,CAACC,YAAYzC,qBAAqByC,OAAAA,CAAQ,EAAED,IAAI,OAAOE,aAAa,MAAMA,SAAAA,CAAAA,CAAAA;AACzH,WAAOL,QAAQM,MAAMC,OAAAA;EACvB;;;;EAKA,MAAMV,aAA4B;AAChC,QAAI,KAAKb,eAAgB;AACzB,UAAM,KAAKwB,sBAAqB;AAChC,SAAKxB,iBAAiB;AACtB;EACF;EAEA,MAAgBwB,wBAAuC;AACrD,aAASJ,UAAU,GAAGA,UAAU,KAAKjB,gBAAgBsB,QAAQL,WAAW;AACtE,YAAMM,iBAAiB,KAAKvB,gBAAgBiB,OAAAA;AAC5C,YAAMC,WAAW1C,qBAAqB+C,cAAAA;AACtC,WAAK5B,gBAAgB4B,cAAAA,IAAmB,MAAML,SAAAA,IAAc,OAAO;IACrE;AACA,SAAKpB,6BAA6B0B,OAAOC,OAAO,KAAK9B,eAAe,EAAEwB,MAAMC,OAAAA;EAC9E;AACF;","names":["WasmFeatureDetectors","bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmSupport","_allowWasm","_featureSupport","_forceWasm","_isInitialized","_isWasmFeatureSetSupported","constructor","desiredFeatures","allowWasm","v","canUseWasm","featureSupport","forceWasm","isDesiredFeatureSetSupported","isInitialized","create","instance","initialize","featureCheck","features","results","Promise","all","map","feature","detector","every","Boolean","detectDesiredFeatures","length","desiredFeature","Object","values"]}

package/dist/browser/index.js

@@ -1,2 +1,152 @@
-var l=Object.defineProperty;var i=(a,e)=>l(a,"name",{value:e,configurable:!0});import{bigInt as n,bulkMemory as u,exceptions as m,extendedConst as d,gc as c,memory64 as p,multiValue as h,mutableGlobals as _,referenceTypes as f,relaxedSimd as W,saturatedFloatToInt as S,signExtensions as F,simd as g,streamingCompilation as w,tailCall as y,threads as I}from"wasm-feature-detect";var r={bigInt:n,bulkMemory:u,exceptions:m,extendedConst:d,gc:c,memory64:p,multiValue:h,mutableGlobals:_,referenceTypes:f,relaxedSimd:W,saturatedFloatToInt:S,signExtensions:F,simd:g,streamingCompilation:w,tailCall:y,threads:I},o=class a{static{i(this,"WasmSupport")}desiredFeatures;_allowWasm;_featureSupport;_forceWasm;_isInitialized;_isWasmFeatureSetSupported;constructor(e){this.desiredFeatures=e,this._allowWasm=!0,this._featureSupport={},this._forceWasm=!1,this._isInitialized=!1,this._isWasmFeatureSetSupported=!1}get allowWasm(){return this._allowWasm}set allowWasm(e){this._allowWasm=e}get canUseWasm(){return this._forceWasm||this._allowWasm&&!this._isInitialized||this._allowWasm&&this._isInitialized&&this._isWasmFeatureSetSupported}get featureSupport(){return{...this._featureSupport}}get forceWasm(){return this._forceWasm}set forceWasm(e){this._forceWasm=e}get isDesiredFeatureSetSupported(){return this._isWasmFeatureSetSupported}get isInitialized(){return this._isInitialized}static async create(e){let t=new a(e);return await t.initialize(),t}async featureCheck(e){return(await Promise.all(e.map(s=>r[s]).map(async s=>await s()))).every(Boolean)}async initialize(){this._isInitialized||(await this.detectDesiredFeatures(),this._isInitialized=!0)}async detectDesiredFeatures(){for(let e=0;e<this.desiredFeatures.length;e++){let t=this.desiredFeatures[e],s=r[t];this._featureSupport[t]=!!await s()}this._isWasmFeatureSetSupported=Object.values(this._featureSupport).every(Boolean)}};export{r as WasmFeatureDetectors,o as WasmSupport};
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/WasmSupport.ts
+import { bigInt, bulkMemory, exceptions, extendedConst, gc, memory64, multiValue, mutableGlobals, referenceTypes, relaxedSimd, saturatedFloatToInt, signExtensions, simd, streamingCompilation, tailCall, threads } from "wasm-feature-detect";
+var WasmFeatureDetectors = {
+  bigInt,
+  bulkMemory,
+  exceptions,
+  extendedConst,
+  gc,
+  memory64,
+  multiValue,
+  mutableGlobals,
+  referenceTypes,
+  relaxedSimd,
+  saturatedFloatToInt,
+  signExtensions,
+  simd,
+  streamingCompilation,
+  tailCall,
+  threads
+};
+var WasmSupport = class _WasmSupport {
+  static {
+    __name(this, "WasmSupport");
+  }
+  desiredFeatures;
+  _allowWasm;
+  _featureSupport;
+  _forceWasm;
+  _isInitialized;
+  _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) {
+    this.desiredFeatures = desiredFeatures;
+    this._allowWasm = true;
+    this._featureSupport = {};
+    this._forceWasm = false;
+    this._isInitialized = false;
+    this._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 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(Boolean);
+  }
+  /**
+  * 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];
+      this._featureSupport[desiredFeature] = await detector() ? true : false;
+    }
+    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean);
+  }
+};
+export {
+  WasmFeatureDetectors,
+  WasmSupport
+};
 //# sourceMappingURL=index.js.map

package/dist/browser/index.js.map

@@ -1 +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 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(Boolean)\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      this._featureSupport[desiredFeature] = (await detector()) ? true : false\n    }\n    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean)\n  }\n}\n"],"mappings":"+EAAA,OACEA,UAAAA,EACAC,cAAAA,EACAC,cAAAA,EACAC,iBAAAA,EACAC,MAAAA,EACAC,YAAAA,EACAC,cAAAA,EACAC,kBAAAA,EACAC,kBAAAA,EACAC,eAAAA,EACAC,uBAAAA,EACAC,kBAAAA,EACAC,QAAAA,EACAC,wBAAAA,EACAC,YAAAA,EACAC,WAAAA,MACK,sBAEA,IAAMC,EAAuB,CAClCC,OAAQA,EACRC,WAAYA,EACZC,WAAYA,EACZC,cAAeA,EACfC,GAAIA,EACJC,SAAUA,EACVC,WAAYA,EACZC,eAAgBA,EAChBC,eAAgBA,EAChBC,YAAaA,EACbC,oBAAqBA,EACrBC,eAAgBA,EAChBC,KAAMA,EACNC,qBAAsBA,EACtBC,SAAUA,EACVC,QAASA,CACX,EAIaC,EAAN,MAAMA,CAAAA,CAxCb,MAwCaA,CAAAA,EAAAA,oCACHC,WACAC,gBACAC,WACAC,eACAC,2BAURC,YAAsBC,EAAgC,MAAhCA,gBAAAA,OAddN,WAAa,QACbC,gBAAyD,CAAC,OAC1DC,WAAa,QACbC,eAAiB,QACjBC,2BAA6B,EAUkB,CAKvD,IAAIG,WAAqB,CACvB,OAAO,KAAKP,UACd,CAIA,IAAIO,UAAUC,EAAY,CACxB,KAAKR,WAAaQ,CACpB,CAMA,IAAIC,YAAsB,CACxB,OAEE,KAAKP,YAEJ,KAAKF,YAAc,CAAC,KAAKG,gBAEzB,KAAKH,YAAc,KAAKG,gBAAkB,KAAKC,0BAEpD,CAMA,IAAIM,gBAAkE,CACpE,MAAO,CAAE,GAAG,KAAKT,eAAgB,CACnC,CAKA,IAAIU,WAAqB,CACvB,OAAO,KAAKT,UACd,CAIA,IAAIS,UAAUH,EAAY,CACxB,KAAKN,WAAaM,CACpB,CAMA,IAAII,8BAAwC,CAC1C,OAAO,KAAKR,0BACd,CAMA,IAAIS,eAAyB,CAC3B,OAAO,KAAKV,cACd,CASA,aAAaW,OAAOR,EAAsD,CACxE,IAAMS,EAAW,IAAIhB,EAAYO,CAAAA,EACjC,aAAMS,EAASC,WAAU,EAClBD,CACT,CAOA,MAAME,aAAaC,EAA2C,CAE5D,OADgB,MAAMC,QAAQC,IAAIF,EAASG,IAAKC,GAAYxC,EAAqBwC,CAAAA,CAAQ,EAAED,IAAI,MAAOE,GAAa,MAAMA,EAAAA,CAAAA,CAAAA,GAC1GC,MAAMC,OAAAA,CACvB,CAKA,MAAMT,YAA4B,CAC5B,KAAKb,iBACT,MAAM,KAAKuB,sBAAqB,EAChC,KAAKvB,eAAiB,GAExB,CAEA,MAAgBuB,uBAAuC,CACrD,QAASJ,EAAU,EAAGA,EAAU,KAAKhB,gBAAgBqB,OAAQL,IAAW,CACtE,IAAMM,EAAiB,KAAKtB,gBAAgBgB,CAAAA,EACtCC,EAAWzC,EAAqB8C,CAAAA,EACtC,KAAK3B,gBAAgB2B,CAAAA,EAAmB,QAAML,EAAAA,CAChD,CACA,KAAKnB,2BAA6ByB,OAAOC,OAAO,KAAK7B,eAAe,EAAEuB,MAAMC,OAAAA,CAC9E,CACF","names":["bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmFeatureDetectors","bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmSupport","_allowWasm","_featureSupport","_forceWasm","_isInitialized","_isWasmFeatureSetSupported","constructor","desiredFeatures","allowWasm","v","canUseWasm","featureSupport","forceWasm","isDesiredFeatureSetSupported","isInitialized","create","instance","initialize","featureCheck","features","Promise","all","map","feature","detector","every","Boolean","detectDesiredFeatures","length","desiredFeature","Object","values"]}
+{"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 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(Boolean)\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      this._featureSupport[desiredFeature] = (await detector()) ? true : false\n    }\n    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean)\n  }\n}\n"],"mappings":";;;;AAAA,SACEA,QACAC,YACAC,YACAC,eACAC,IACAC,UACAC,YACAC,gBACAC,gBACAC,aACAC,qBACAC,gBACAC,MACAC,sBACAC,UACAC,eACK;AAEA,IAAMC,uBAAuB;EAClCC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;AACF;AAIO,IAAMC,cAAN,MAAMA,aAAAA;EAxCb,OAwCaA;;;;EACHC;EACAC;EACAC;EACAC;EACAC;;;;;;;;;EAURC,YAAsBC,iBAAgC;SAAhCA,kBAAAA;SAddN,aAAa;SACbC,kBAAyD,CAAC;SAC1DC,aAAa;SACbC,iBAAiB;SACjBC,6BAA6B;EAUkB;;;;EAKvD,IAAIG,YAAqB;AACvB,WAAO,KAAKP;EACd;;;;EAIA,IAAIO,UAAUC,GAAY;AACxB,SAAKR,aAAaQ;EACpB;;;;;EAMA,IAAIC,aAAsB;AACxB;;MAEE,KAAKP;MAEJ,KAAKF,cAAc,CAAC,KAAKG;MAEzB,KAAKH,cAAc,KAAKG,kBAAkB,KAAKC;;EAEpD;;;;;EAMA,IAAIM,iBAAkE;AACpE,WAAO;MAAE,GAAG,KAAKT;IAAgB;EACnC;;;;EAKA,IAAIU,YAAqB;AACvB,WAAO,KAAKT;EACd;;;;EAIA,IAAIS,UAAUH,GAAY;AACxB,SAAKN,aAAaM;EACpB;;;;;EAMA,IAAII,+BAAwC;AAC1C,WAAO,KAAKR;EACd;;;;;EAMA,IAAIS,gBAAyB;AAC3B,WAAO,KAAKV;EACd;;;;;;;;EASA,aAAaW,OAAOR,iBAAsD;AACxE,UAAMS,WAAW,IAAIhB,aAAYO,eAAAA;AACjC,UAAMS,SAASC,WAAU;AACzB,WAAOD;EACT;;;;;;EAOA,MAAME,aAAaC,UAA2C;AAC5D,UAAMC,UAAU,MAAMC,QAAQC,IAAIH,SAASI,IAAI,CAACC,YAAYzC,qBAAqByC,OAAAA,CAAQ,EAAED,IAAI,OAAOE,aAAa,MAAMA,SAAAA,CAAAA,CAAAA;AACzH,WAAOL,QAAQM,MAAMC,OAAAA;EACvB;;;;EAKA,MAAMV,aAA4B;AAChC,QAAI,KAAKb,eAAgB;AACzB,UAAM,KAAKwB,sBAAqB;AAChC,SAAKxB,iBAAiB;AACtB;EACF;EAEA,MAAgBwB,wBAAuC;AACrD,aAASJ,UAAU,GAAGA,UAAU,KAAKjB,gBAAgBsB,QAAQL,WAAW;AACtE,YAAMM,iBAAiB,KAAKvB,gBAAgBiB,OAAAA;AAC5C,YAAMC,WAAW1C,qBAAqB+C,cAAAA;AACtC,WAAK5B,gBAAgB4B,cAAAA,IAAmB,MAAML,SAAAA,IAAc,OAAO;IACrE;AACA,SAAKpB,6BAA6B0B,OAAOC,OAAO,KAAK9B,eAAe,EAAEwB,MAAMC,OAAAA;EAC9E;AACF;","names":["bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmFeatureDetectors","bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmSupport","_allowWasm","_featureSupport","_forceWasm","_isInitialized","_isWasmFeatureSetSupported","constructor","desiredFeatures","allowWasm","v","canUseWasm","featureSupport","forceWasm","isDesiredFeatureSetSupported","isInitialized","create","instance","initialize","featureCheck","features","results","Promise","all","map","feature","detector","every","Boolean","detectDesiredFeatures","length","desiredFeature","Object","values"]}

package/dist/neutral/index.cjs

@@ -1,2 +1,173 @@
-"use strict";var o=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var u=(s,t)=>o(s,"name",{value:t,configurable:!0});var p=(s,t)=>{for(var a in t)o(s,a,{get:t[a],enumerable:!0})},h=(s,t,a,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let r of d(t))!c.call(s,r)&&r!==a&&o(s,r,{get:()=>t[r],enumerable:!(i=m(t,r))||i.enumerable});return s};var _=s=>h(o({},"__esModule",{value:!0}),s);var f={};p(f,{WasmFeatureDetectors:()=>l,WasmSupport:()=>n});module.exports=_(f);var e=require("wasm-feature-detect");var l={bigInt:e.bigInt,bulkMemory:e.bulkMemory,exceptions:e.exceptions,extendedConst:e.extendedConst,gc:e.gc,memory64:e.memory64,multiValue:e.multiValue,mutableGlobals:e.mutableGlobals,referenceTypes:e.referenceTypes,relaxedSimd:e.relaxedSimd,saturatedFloatToInt:e.saturatedFloatToInt,signExtensions:e.signExtensions,simd:e.simd,streamingCompilation:e.streamingCompilation,tailCall:e.tailCall,threads:e.threads},n=class s{static{u(this,"WasmSupport")}desiredFeatures;_allowWasm;_featureSupport;_forceWasm;_isInitialized;_isWasmFeatureSetSupported;constructor(t){this.desiredFeatures=t,this._allowWasm=!0,this._featureSupport={},this._forceWasm=!1,this._isInitialized=!1,this._isWasmFeatureSetSupported=!1}get allowWasm(){return this._allowWasm}set allowWasm(t){this._allowWasm=t}get canUseWasm(){return this._forceWasm||this._allowWasm&&!this._isInitialized||this._allowWasm&&this._isInitialized&&this._isWasmFeatureSetSupported}get featureSupport(){return{...this._featureSupport}}get forceWasm(){return this._forceWasm}set forceWasm(t){this._forceWasm=t}get isDesiredFeatureSetSupported(){return this._isWasmFeatureSetSupported}get isInitialized(){return this._isInitialized}static async create(t){let a=new s(t);return await a.initialize(),a}async featureCheck(t){return(await Promise.all(t.map(i=>l[i]).map(async i=>await i()))).every(Boolean)}async initialize(){this._isInitialized||(await this.detectDesiredFeatures(),this._isInitialized=!0)}async detectDesiredFeatures(){for(let t=0;t<this.desiredFeatures.length;t++){let a=this.desiredFeatures[t],i=l[a];this._featureSupport[a]=!!await i()}this._isWasmFeatureSetSupported=Object.values(this._featureSupport).every(Boolean)}};
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 {
+  static {
+    __name(this, "WasmSupport");
+  }
+  desiredFeatures;
+  _allowWasm;
+  _featureSupport;
+  _forceWasm;
+  _isInitialized;
+  _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) {
+    this.desiredFeatures = desiredFeatures;
+    this._allowWasm = true;
+    this._featureSupport = {};
+    this._forceWasm = false;
+    this._isInitialized = false;
+    this._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 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(Boolean);
+  }
+  /**
+  * 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];
+      this._featureSupport[desiredFeature] = await detector() ? true : false;
+    }
+    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean);
+  }
+};
 //# sourceMappingURL=index.cjs.map

package/dist/neutral/index.cjs.map

@@ -1 +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 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(Boolean)\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      this._featureSupport[desiredFeature] = (await detector()) ? true : false\n    }\n    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean)\n  }\n}\n"],"mappings":"4dAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,0BAAAE,EAAA,gBAAAC,IAAA,eAAAC,EAAAJ,GCAA,IAAAK,EAiBO,+BAEA,IAAMC,EAAuB,CAClCC,OAAQA,SACRC,WAAYA,aACZC,WAAYA,aACZC,cAAeA,gBACfC,GAAIA,KACJC,SAAUA,WACVC,WAAYA,aACZC,eAAgBA,iBAChBC,eAAgBA,iBAChBC,YAAaA,cACbC,oBAAqBA,sBACrBC,eAAgBA,iBAChBC,KAAMA,OACNC,qBAAsBA,uBACtBC,SAAUA,WACVC,QAASA,SACX,EAIaC,EAAN,MAAMA,CAAAA,CAxCb,MAwCaA,CAAAA,EAAAA,oCACHC,WACAC,gBACAC,WACAC,eACAC,2BAURC,YAAsBC,EAAgC,MAAhCA,gBAAAA,OAddN,WAAa,QACbC,gBAAyD,CAAC,OAC1DC,WAAa,QACbC,eAAiB,QACjBC,2BAA6B,EAUkB,CAKvD,IAAIG,WAAqB,CACvB,OAAO,KAAKP,UACd,CAIA,IAAIO,UAAUC,EAAY,CACxB,KAAKR,WAAaQ,CACpB,CAMA,IAAIC,YAAsB,CACxB,OAEE,KAAKP,YAEJ,KAAKF,YAAc,CAAC,KAAKG,gBAEzB,KAAKH,YAAc,KAAKG,gBAAkB,KAAKC,0BAEpD,CAMA,IAAIM,gBAAkE,CACpE,MAAO,CAAE,GAAG,KAAKT,eAAgB,CACnC,CAKA,IAAIU,WAAqB,CACvB,OAAO,KAAKT,UACd,CAIA,IAAIS,UAAUH,EAAY,CACxB,KAAKN,WAAaM,CACpB,CAMA,IAAII,8BAAwC,CAC1C,OAAO,KAAKR,0BACd,CAMA,IAAIS,eAAyB,CAC3B,OAAO,KAAKV,cACd,CASA,aAAaW,OAAOR,EAAsD,CACxE,IAAMS,EAAW,IAAIhB,EAAYO,CAAAA,EACjC,aAAMS,EAASC,WAAU,EAClBD,CACT,CAOA,MAAME,aAAaC,EAA2C,CAE5D,OADgB,MAAMC,QAAQC,IAAIF,EAASG,IAAKC,GAAYxC,EAAqBwC,CAAAA,CAAQ,EAAED,IAAI,MAAOE,GAAa,MAAMA,EAAAA,CAAAA,CAAAA,GAC1GC,MAAMC,OAAAA,CACvB,CAKA,MAAMT,YAA4B,CAC5B,KAAKb,iBACT,MAAM,KAAKuB,sBAAqB,EAChC,KAAKvB,eAAiB,GAExB,CAEA,MAAgBuB,uBAAuC,CACrD,QAASJ,EAAU,EAAGA,EAAU,KAAKhB,gBAAgBqB,OAAQL,IAAW,CACtE,IAAMM,EAAiB,KAAKtB,gBAAgBgB,CAAAA,EACtCC,EAAWzC,EAAqB8C,CAAAA,EACtC,KAAK3B,gBAAgB2B,CAAAA,EAAmB,QAAML,EAAAA,CAChD,CACA,KAAKnB,2BAA6ByB,OAAOC,OAAO,KAAK7B,eAAe,EAAEuB,MAAMC,OAAAA,CAC9E,CACF","names":["src_exports","__export","WasmFeatureDetectors","WasmSupport","__toCommonJS","import_wasm_feature_detect","WasmFeatureDetectors","bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmSupport","_allowWasm","_featureSupport","_forceWasm","_isInitialized","_isWasmFeatureSetSupported","constructor","desiredFeatures","allowWasm","v","canUseWasm","featureSupport","forceWasm","isDesiredFeatureSetSupported","isInitialized","create","instance","initialize","featureCheck","features","Promise","all","map","feature","detector","every","Boolean","detectDesiredFeatures","length","desiredFeature","Object","values"]}
+{"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 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(Boolean)\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      this._featureSupport[desiredFeature] = (await detector()) ? true : false\n    }\n    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;ACAA,iCAiBO;AAEA,IAAMA,uBAAuB;EAClCC,QAAQA;EACRC,YAAYA;EACZC,YAAYA;EACZC,eAAeA;EACfC,IAAIA;EACJC,UAAUA;EACVC,YAAYA;EACZC,gBAAgBA;EAChBC,gBAAgBA;EAChBC,aAAaA;EACbC,qBAAqBA;EACrBC,gBAAgBA;EAChBC,MAAMA;EACNC,sBAAsBA;EACtBC,UAAUA;EACVC,SAASA;AACX;AAIO,IAAMC,cAAN,MAAMA,aAAAA;EAxCb,OAwCaA;;;;EACHC;EACAC;EACAC;EACAC;EACAC;;;;;;;;;EAURC,YAAsBC,iBAAgC;SAAhCA,kBAAAA;SAddN,aAAa;SACbC,kBAAyD,CAAC;SAC1DC,aAAa;SACbC,iBAAiB;SACjBC,6BAA6B;EAUkB;;;;EAKvD,IAAIG,YAAqB;AACvB,WAAO,KAAKP;EACd;;;;EAIA,IAAIO,UAAUC,GAAY;AACxB,SAAKR,aAAaQ;EACpB;;;;;EAMA,IAAIC,aAAsB;AACxB;;MAEE,KAAKP;MAEJ,KAAKF,cAAc,CAAC,KAAKG;MAEzB,KAAKH,cAAc,KAAKG,kBAAkB,KAAKC;;EAEpD;;;;;EAMA,IAAIM,iBAAkE;AACpE,WAAO;MAAE,GAAG,KAAKT;IAAgB;EACnC;;;;EAKA,IAAIU,YAAqB;AACvB,WAAO,KAAKT;EACd;;;;EAIA,IAAIS,UAAUH,GAAY;AACxB,SAAKN,aAAaM;EACpB;;;;;EAMA,IAAII,+BAAwC;AAC1C,WAAO,KAAKR;EACd;;;;;EAMA,IAAIS,gBAAyB;AAC3B,WAAO,KAAKV;EACd;;;;;;;;EASA,aAAaW,OAAOR,iBAAsD;AACxE,UAAMS,WAAW,IAAIhB,aAAYO,eAAAA;AACjC,UAAMS,SAASC,WAAU;AACzB,WAAOD;EACT;;;;;;EAOA,MAAME,aAAaC,UAA2C;AAC5D,UAAMC,UAAU,MAAMC,QAAQC,IAAIH,SAASI,IAAI,CAACC,YAAYzC,qBAAqByC,OAAAA,CAAQ,EAAED,IAAI,OAAOE,aAAa,MAAMA,SAAAA,CAAAA,CAAAA;AACzH,WAAOL,QAAQM,MAAMC,OAAAA;EACvB;;;;EAKA,MAAMV,aAA4B;AAChC,QAAI,KAAKb,eAAgB;AACzB,UAAM,KAAKwB,sBAAqB;AAChC,SAAKxB,iBAAiB;AACtB;EACF;EAEA,MAAgBwB,wBAAuC;AACrD,aAASJ,UAAU,GAAGA,UAAU,KAAKjB,gBAAgBsB,QAAQL,WAAW;AACtE,YAAMM,iBAAiB,KAAKvB,gBAAgBiB,OAAAA;AAC5C,YAAMC,WAAW1C,qBAAqB+C,cAAAA;AACtC,WAAK5B,gBAAgB4B,cAAAA,IAAmB,MAAML,SAAAA,IAAc,OAAO;IACrE;AACA,SAAKpB,6BAA6B0B,OAAOC,OAAO,KAAK9B,eAAe,EAAEwB,MAAMC,OAAAA;EAC9E;AACF;","names":["WasmFeatureDetectors","bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmSupport","_allowWasm","_featureSupport","_forceWasm","_isInitialized","_isWasmFeatureSetSupported","constructor","desiredFeatures","allowWasm","v","canUseWasm","featureSupport","forceWasm","isDesiredFeatureSetSupported","isInitialized","create","instance","initialize","featureCheck","features","results","Promise","all","map","feature","detector","every","Boolean","detectDesiredFeatures","length","desiredFeature","Object","values"]}

package/dist/neutral/index.js

@@ -1,2 +1,152 @@
-var l=Object.defineProperty;var i=(a,e)=>l(a,"name",{value:e,configurable:!0});import{bigInt as n,bulkMemory as u,exceptions as m,extendedConst as d,gc as c,memory64 as p,multiValue as h,mutableGlobals as _,referenceTypes as f,relaxedSimd as W,saturatedFloatToInt as S,signExtensions as F,simd as g,streamingCompilation as w,tailCall as y,threads as I}from"wasm-feature-detect";var r={bigInt:n,bulkMemory:u,exceptions:m,extendedConst:d,gc:c,memory64:p,multiValue:h,mutableGlobals:_,referenceTypes:f,relaxedSimd:W,saturatedFloatToInt:S,signExtensions:F,simd:g,streamingCompilation:w,tailCall:y,threads:I},o=class a{static{i(this,"WasmSupport")}desiredFeatures;_allowWasm;_featureSupport;_forceWasm;_isInitialized;_isWasmFeatureSetSupported;constructor(e){this.desiredFeatures=e,this._allowWasm=!0,this._featureSupport={},this._forceWasm=!1,this._isInitialized=!1,this._isWasmFeatureSetSupported=!1}get allowWasm(){return this._allowWasm}set allowWasm(e){this._allowWasm=e}get canUseWasm(){return this._forceWasm||this._allowWasm&&!this._isInitialized||this._allowWasm&&this._isInitialized&&this._isWasmFeatureSetSupported}get featureSupport(){return{...this._featureSupport}}get forceWasm(){return this._forceWasm}set forceWasm(e){this._forceWasm=e}get isDesiredFeatureSetSupported(){return this._isWasmFeatureSetSupported}get isInitialized(){return this._isInitialized}static async create(e){let t=new a(e);return await t.initialize(),t}async featureCheck(e){return(await Promise.all(e.map(s=>r[s]).map(async s=>await s()))).every(Boolean)}async initialize(){this._isInitialized||(await this.detectDesiredFeatures(),this._isInitialized=!0)}async detectDesiredFeatures(){for(let e=0;e<this.desiredFeatures.length;e++){let t=this.desiredFeatures[e],s=r[t];this._featureSupport[t]=!!await s()}this._isWasmFeatureSetSupported=Object.values(this._featureSupport).every(Boolean)}};export{r as WasmFeatureDetectors,o as WasmSupport};
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/WasmSupport.ts
+import { bigInt, bulkMemory, exceptions, extendedConst, gc, memory64, multiValue, mutableGlobals, referenceTypes, relaxedSimd, saturatedFloatToInt, signExtensions, simd, streamingCompilation, tailCall, threads } from "wasm-feature-detect";
+var WasmFeatureDetectors = {
+  bigInt,
+  bulkMemory,
+  exceptions,
+  extendedConst,
+  gc,
+  memory64,
+  multiValue,
+  mutableGlobals,
+  referenceTypes,
+  relaxedSimd,
+  saturatedFloatToInt,
+  signExtensions,
+  simd,
+  streamingCompilation,
+  tailCall,
+  threads
+};
+var WasmSupport = class _WasmSupport {
+  static {
+    __name(this, "WasmSupport");
+  }
+  desiredFeatures;
+  _allowWasm;
+  _featureSupport;
+  _forceWasm;
+  _isInitialized;
+  _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) {
+    this.desiredFeatures = desiredFeatures;
+    this._allowWasm = true;
+    this._featureSupport = {};
+    this._forceWasm = false;
+    this._isInitialized = false;
+    this._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 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(Boolean);
+  }
+  /**
+  * 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];
+      this._featureSupport[desiredFeature] = await detector() ? true : false;
+    }
+    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean);
+  }
+};
+export {
+  WasmFeatureDetectors,
+  WasmSupport
+};
 //# sourceMappingURL=index.js.map

package/dist/neutral/index.js.map

@@ -1 +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 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(Boolean)\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      this._featureSupport[desiredFeature] = (await detector()) ? true : false\n    }\n    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean)\n  }\n}\n"],"mappings":"+EAAA,OACEA,UAAAA,EACAC,cAAAA,EACAC,cAAAA,EACAC,iBAAAA,EACAC,MAAAA,EACAC,YAAAA,EACAC,cAAAA,EACAC,kBAAAA,EACAC,kBAAAA,EACAC,eAAAA,EACAC,uBAAAA,EACAC,kBAAAA,EACAC,QAAAA,EACAC,wBAAAA,EACAC,YAAAA,EACAC,WAAAA,MACK,sBAEA,IAAMC,EAAuB,CAClCC,OAAQA,EACRC,WAAYA,EACZC,WAAYA,EACZC,cAAeA,EACfC,GAAIA,EACJC,SAAUA,EACVC,WAAYA,EACZC,eAAgBA,EAChBC,eAAgBA,EAChBC,YAAaA,EACbC,oBAAqBA,EACrBC,eAAgBA,EAChBC,KAAMA,EACNC,qBAAsBA,EACtBC,SAAUA,EACVC,QAASA,CACX,EAIaC,EAAN,MAAMA,CAAAA,CAxCb,MAwCaA,CAAAA,EAAAA,oCACHC,WACAC,gBACAC,WACAC,eACAC,2BAURC,YAAsBC,EAAgC,MAAhCA,gBAAAA,OAddN,WAAa,QACbC,gBAAyD,CAAC,OAC1DC,WAAa,QACbC,eAAiB,QACjBC,2BAA6B,EAUkB,CAKvD,IAAIG,WAAqB,CACvB,OAAO,KAAKP,UACd,CAIA,IAAIO,UAAUC,EAAY,CACxB,KAAKR,WAAaQ,CACpB,CAMA,IAAIC,YAAsB,CACxB,OAEE,KAAKP,YAEJ,KAAKF,YAAc,CAAC,KAAKG,gBAEzB,KAAKH,YAAc,KAAKG,gBAAkB,KAAKC,0BAEpD,CAMA,IAAIM,gBAAkE,CACpE,MAAO,CAAE,GAAG,KAAKT,eAAgB,CACnC,CAKA,IAAIU,WAAqB,CACvB,OAAO,KAAKT,UACd,CAIA,IAAIS,UAAUH,EAAY,CACxB,KAAKN,WAAaM,CACpB,CAMA,IAAII,8BAAwC,CAC1C,OAAO,KAAKR,0BACd,CAMA,IAAIS,eAAyB,CAC3B,OAAO,KAAKV,cACd,CASA,aAAaW,OAAOR,EAAsD,CACxE,IAAMS,EAAW,IAAIhB,EAAYO,CAAAA,EACjC,aAAMS,EAASC,WAAU,EAClBD,CACT,CAOA,MAAME,aAAaC,EAA2C,CAE5D,OADgB,MAAMC,QAAQC,IAAIF,EAASG,IAAKC,GAAYxC,EAAqBwC,CAAAA,CAAQ,EAAED,IAAI,MAAOE,GAAa,MAAMA,EAAAA,CAAAA,CAAAA,GAC1GC,MAAMC,OAAAA,CACvB,CAKA,MAAMT,YAA4B,CAC5B,KAAKb,iBACT,MAAM,KAAKuB,sBAAqB,EAChC,KAAKvB,eAAiB,GAExB,CAEA,MAAgBuB,uBAAuC,CACrD,QAASJ,EAAU,EAAGA,EAAU,KAAKhB,gBAAgBqB,OAAQL,IAAW,CACtE,IAAMM,EAAiB,KAAKtB,gBAAgBgB,CAAAA,EACtCC,EAAWzC,EAAqB8C,CAAAA,EACtC,KAAK3B,gBAAgB2B,CAAAA,EAAmB,QAAML,EAAAA,CAChD,CACA,KAAKnB,2BAA6ByB,OAAOC,OAAO,KAAK7B,eAAe,EAAEuB,MAAMC,OAAAA,CAC9E,CACF","names":["bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmFeatureDetectors","bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmSupport","_allowWasm","_featureSupport","_forceWasm","_isInitialized","_isWasmFeatureSetSupported","constructor","desiredFeatures","allowWasm","v","canUseWasm","featureSupport","forceWasm","isDesiredFeatureSetSupported","isInitialized","create","instance","initialize","featureCheck","features","Promise","all","map","feature","detector","every","Boolean","detectDesiredFeatures","length","desiredFeature","Object","values"]}
+{"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 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(Boolean)\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      this._featureSupport[desiredFeature] = (await detector()) ? true : false\n    }\n    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean)\n  }\n}\n"],"mappings":";;;;AAAA,SACEA,QACAC,YACAC,YACAC,eACAC,IACAC,UACAC,YACAC,gBACAC,gBACAC,aACAC,qBACAC,gBACAC,MACAC,sBACAC,UACAC,eACK;AAEA,IAAMC,uBAAuB;EAClCC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;AACF;AAIO,IAAMC,cAAN,MAAMA,aAAAA;EAxCb,OAwCaA;;;;EACHC;EACAC;EACAC;EACAC;EACAC;;;;;;;;;EAURC,YAAsBC,iBAAgC;SAAhCA,kBAAAA;SAddN,aAAa;SACbC,kBAAyD,CAAC;SAC1DC,aAAa;SACbC,iBAAiB;SACjBC,6BAA6B;EAUkB;;;;EAKvD,IAAIG,YAAqB;AACvB,WAAO,KAAKP;EACd;;;;EAIA,IAAIO,UAAUC,GAAY;AACxB,SAAKR,aAAaQ;EACpB;;;;;EAMA,IAAIC,aAAsB;AACxB;;MAEE,KAAKP;MAEJ,KAAKF,cAAc,CAAC,KAAKG;MAEzB,KAAKH,cAAc,KAAKG,kBAAkB,KAAKC;;EAEpD;;;;;EAMA,IAAIM,iBAAkE;AACpE,WAAO;MAAE,GAAG,KAAKT;IAAgB;EACnC;;;;EAKA,IAAIU,YAAqB;AACvB,WAAO,KAAKT;EACd;;;;EAIA,IAAIS,UAAUH,GAAY;AACxB,SAAKN,aAAaM;EACpB;;;;;EAMA,IAAII,+BAAwC;AAC1C,WAAO,KAAKR;EACd;;;;;EAMA,IAAIS,gBAAyB;AAC3B,WAAO,KAAKV;EACd;;;;;;;;EASA,aAAaW,OAAOR,iBAAsD;AACxE,UAAMS,WAAW,IAAIhB,aAAYO,eAAAA;AACjC,UAAMS,SAASC,WAAU;AACzB,WAAOD;EACT;;;;;;EAOA,MAAME,aAAaC,UAA2C;AAC5D,UAAMC,UAAU,MAAMC,QAAQC,IAAIH,SAASI,IAAI,CAACC,YAAYzC,qBAAqByC,OAAAA,CAAQ,EAAED,IAAI,OAAOE,aAAa,MAAMA,SAAAA,CAAAA,CAAAA;AACzH,WAAOL,QAAQM,MAAMC,OAAAA;EACvB;;;;EAKA,MAAMV,aAA4B;AAChC,QAAI,KAAKb,eAAgB;AACzB,UAAM,KAAKwB,sBAAqB;AAChC,SAAKxB,iBAAiB;AACtB;EACF;EAEA,MAAgBwB,wBAAuC;AACrD,aAASJ,UAAU,GAAGA,UAAU,KAAKjB,gBAAgBsB,QAAQL,WAAW;AACtE,YAAMM,iBAAiB,KAAKvB,gBAAgBiB,OAAAA;AAC5C,YAAMC,WAAW1C,qBAAqB+C,cAAAA;AACtC,WAAK5B,gBAAgB4B,cAAAA,IAAmB,MAAML,SAAAA,IAAc,OAAO;IACrE;AACA,SAAKpB,6BAA6B0B,OAAOC,OAAO,KAAK9B,eAAe,EAAEwB,MAAMC,OAAAA;EAC9E;AACF;","names":["bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmFeatureDetectors","bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmSupport","_allowWasm","_featureSupport","_forceWasm","_isInitialized","_isWasmFeatureSetSupported","constructor","desiredFeatures","allowWasm","v","canUseWasm","featureSupport","forceWasm","isDesiredFeatureSetSupported","isInitialized","create","instance","initialize","featureCheck","features","results","Promise","all","map","feature","detector","every","Boolean","detectDesiredFeatures","length","desiredFeature","Object","values"]}

package/dist/node/index.cjs

@@ -1,2 +1,177 @@
-"use strict";var o=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var d=(a,t)=>o(a,"name",{value:t,configurable:!0});var h=(a,t)=>{for(var s in t)o(a,s,{get:t[s],enumerable:!0})},_=(a,t,s,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let r of c(t))!p.call(a,r)&&r!==s&&o(a,r,{get:()=>t[r],enumerable:!(i=m(t,r))||i.enumerable});return a};var f=a=>_(o({},"__esModule",{value:!0}),a);var W={};h(W,{WasmFeatureDetectors:()=>n,WasmSupport:()=>u});module.exports=f(W);var e=require("wasm-feature-detect");var n={bigInt:e.bigInt,bulkMemory:e.bulkMemory,exceptions:e.exceptions,extendedConst:e.extendedConst,gc:e.gc,memory64:e.memory64,multiValue:e.multiValue,mutableGlobals:e.mutableGlobals,referenceTypes:e.referenceTypes,relaxedSimd:e.relaxedSimd,saturatedFloatToInt:e.saturatedFloatToInt,signExtensions:e.signExtensions,simd:e.simd,streamingCompilation:e.streamingCompilation,tailCall:e.tailCall,threads:e.threads},l=class l{desiredFeatures;_allowWasm;_featureSupport;_forceWasm;_isInitialized;_isWasmFeatureSetSupported;constructor(t){this.desiredFeatures=t,this._allowWasm=!0,this._featureSupport={},this._forceWasm=!1,this._isInitialized=!1,this._isWasmFeatureSetSupported=!1}get allowWasm(){return this._allowWasm}set allowWasm(t){this._allowWasm=t}get canUseWasm(){return this._forceWasm||this._allowWasm&&!this._isInitialized||this._allowWasm&&this._isInitialized&&this._isWasmFeatureSetSupported}get featureSupport(){return{...this._featureSupport}}get forceWasm(){return this._forceWasm}set forceWasm(t){this._forceWasm=t}get isDesiredFeatureSetSupported(){return this._isWasmFeatureSetSupported}get isInitialized(){return this._isInitialized}static async create(t){let s=new l(t);return await s.initialize(),s}async featureCheck(t){return(await Promise.all(t.map(i=>n[i]).map(async i=>await i()))).every(Boolean)}async initialize(){this._isInitialized||(await this.detectDesiredFeatures(),this._isInitialized=!0)}async detectDesiredFeatures(){for(let t=0;t<this.desiredFeatures.length;t++){let s=this.desiredFeatures[t],i=n[s];this._featureSupport[s]=!!await i()}this._isWasmFeatureSetSupported=Object.values(this._featureSupport).every(Boolean)}};d(l,"WasmSupport");var u=l;0&&(module.exports={WasmFeatureDetectors,WasmSupport});
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 {
+  desiredFeatures;
+  _allowWasm;
+  _featureSupport;
+  _forceWasm;
+  _isInitialized;
+  _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) {
+    this.desiredFeatures = desiredFeatures;
+    this._allowWasm = true;
+    this._featureSupport = {};
+    this._forceWasm = false;
+    this._isInitialized = false;
+    this._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 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(Boolean);
+  }
+  /**
+  * 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];
+      this._featureSupport[desiredFeature] = await detector() ? true : false;
+    }
+    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean);
+  }
+};
+__name(_WasmSupport, "WasmSupport");
+var WasmSupport = _WasmSupport;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WasmFeatureDetectors,
+  WasmSupport
+});
 //# sourceMappingURL=index.cjs.map

package/dist/node/index.cjs.map

@@ -1 +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 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(Boolean)\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      this._featureSupport[desiredFeature] = (await detector()) ? true : false\n    }\n    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean)\n  }\n}\n"],"mappings":"4dAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,0BAAAE,EAAA,gBAAAC,IAAA,eAAAC,EAAAJ,GCAA,IAAAK,EAiBO,+BAEA,IAAMC,EAAuB,CAClCC,OAAQA,SACRC,WAAYA,aACZC,WAAYA,aACZC,cAAeA,gBACfC,GAAIA,KACJC,SAAUA,WACVC,WAAYA,aACZC,eAAgBA,iBAChBC,eAAgBA,iBAChBC,YAAaA,cACbC,oBAAqBA,sBACrBC,eAAgBA,iBAChBC,KAAMA,OACNC,qBAAsBA,uBACtBC,SAAUA,WACVC,QAASA,SACX,EAIaC,EAAN,MAAMA,CAAAA,iBACHC,WACAC,gBACAC,WACAC,eACAC,2BAURC,YAAsBC,EAAgC,MAAhCA,gBAAAA,OAddN,WAAa,QACbC,gBAAyD,CAAC,OAC1DC,WAAa,QACbC,eAAiB,QACjBC,2BAA6B,EAUkB,CAKvD,IAAIG,WAAqB,CACvB,OAAO,KAAKP,UACd,CAIA,IAAIO,UAAUC,EAAY,CACxB,KAAKR,WAAaQ,CACpB,CAMA,IAAIC,YAAsB,CACxB,OAEE,KAAKP,YAEJ,KAAKF,YAAc,CAAC,KAAKG,gBAEzB,KAAKH,YAAc,KAAKG,gBAAkB,KAAKC,0BAEpD,CAMA,IAAIM,gBAAkE,CACpE,MAAO,CAAE,GAAG,KAAKT,eAAgB,CACnC,CAKA,IAAIU,WAAqB,CACvB,OAAO,KAAKT,UACd,CAIA,IAAIS,UAAUH,EAAY,CACxB,KAAKN,WAAaM,CACpB,CAMA,IAAII,8BAAwC,CAC1C,OAAO,KAAKR,0BACd,CAMA,IAAIS,eAAyB,CAC3B,OAAO,KAAKV,cACd,CASA,aAAaW,OAAOR,EAAsD,CACxE,IAAMS,EAAW,IAAIhB,EAAYO,CAAAA,EACjC,aAAMS,EAASC,WAAU,EAClBD,CACT,CAOA,MAAME,aAAaC,EAA2C,CAE5D,OADgB,MAAMC,QAAQC,IAAIF,EAASG,IAAKC,GAAYxC,EAAqBwC,CAAAA,CAAQ,EAAED,IAAI,MAAOE,GAAa,MAAMA,EAAAA,CAAAA,CAAAA,GAC1GC,MAAMC,OAAAA,CACvB,CAKA,MAAMT,YAA4B,CAC5B,KAAKb,iBACT,MAAM,KAAKuB,sBAAqB,EAChC,KAAKvB,eAAiB,GAExB,CAEA,MAAgBuB,uBAAuC,CACrD,QAASJ,EAAU,EAAGA,EAAU,KAAKhB,gBAAgBqB,OAAQL,IAAW,CACtE,IAAMM,EAAiB,KAAKtB,gBAAgBgB,CAAAA,EACtCC,EAAWzC,EAAqB8C,CAAAA,EACtC,KAAK3B,gBAAgB2B,CAAAA,EAAmB,QAAML,EAAAA,CAChD,CACA,KAAKnB,2BAA6ByB,OAAOC,OAAO,KAAK7B,eAAe,EAAEuB,MAAMC,OAAAA,CAC9E,CACF,EA3Ha1B,EAAAA,EAAAA,eAAN,IAAMA,EAANgC","names":["src_exports","__export","WasmFeatureDetectors","WasmSupport","__toCommonJS","import_wasm_feature_detect","WasmFeatureDetectors","bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmSupport","_allowWasm","_featureSupport","_forceWasm","_isInitialized","_isWasmFeatureSetSupported","constructor","desiredFeatures","allowWasm","v","canUseWasm","featureSupport","forceWasm","isDesiredFeatureSetSupported","isInitialized","create","instance","initialize","featureCheck","features","Promise","all","map","feature","detector","every","Boolean","detectDesiredFeatures","length","desiredFeature","Object","values","_WasmSupport"]}
+{"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 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(Boolean)\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      this._featureSupport[desiredFeature] = (await detector()) ? true : false\n    }\n    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;ACAA,iCAiBO;AAEA,IAAMA,uBAAuB;EAClCC,QAAQA;EACRC,YAAYA;EACZC,YAAYA;EACZC,eAAeA;EACfC,IAAIA;EACJC,UAAUA;EACVC,YAAYA;EACZC,gBAAgBA;EAChBC,gBAAgBA;EAChBC,aAAaA;EACbC,qBAAqBA;EACrBC,gBAAgBA;EAChBC,MAAMA;EACNC,sBAAsBA;EACtBC,UAAUA;EACVC,SAASA;AACX;AAIO,IAAMC,eAAN,MAAMA,aAAAA;;EACHC;EACAC;EACAC;EACAC;EACAC;;;;;;;;;EAURC,YAAsBC,iBAAgC;SAAhCA,kBAAAA;SAddN,aAAa;SACbC,kBAAyD,CAAC;SAC1DC,aAAa;SACbC,iBAAiB;SACjBC,6BAA6B;EAUkB;;;;EAKvD,IAAIG,YAAqB;AACvB,WAAO,KAAKP;EACd;;;;EAIA,IAAIO,UAAUC,GAAY;AACxB,SAAKR,aAAaQ;EACpB;;;;;EAMA,IAAIC,aAAsB;AACxB;;MAEE,KAAKP;MAEJ,KAAKF,cAAc,CAAC,KAAKG;MAEzB,KAAKH,cAAc,KAAKG,kBAAkB,KAAKC;;EAEpD;;;;;EAMA,IAAIM,iBAAkE;AACpE,WAAO;MAAE,GAAG,KAAKT;IAAgB;EACnC;;;;EAKA,IAAIU,YAAqB;AACvB,WAAO,KAAKT;EACd;;;;EAIA,IAAIS,UAAUH,GAAY;AACxB,SAAKN,aAAaM;EACpB;;;;;EAMA,IAAII,+BAAwC;AAC1C,WAAO,KAAKR;EACd;;;;;EAMA,IAAIS,gBAAyB;AAC3B,WAAO,KAAKV;EACd;;;;;;;;EASA,aAAaW,OAAOR,iBAAsD;AACxE,UAAMS,WAAW,IAAIhB,aAAYO,eAAAA;AACjC,UAAMS,SAASC,WAAU;AACzB,WAAOD;EACT;;;;;;EAOA,MAAME,aAAaC,UAA2C;AAC5D,UAAMC,UAAU,MAAMC,QAAQC,IAAIH,SAASI,IAAI,CAACC,YAAYzC,qBAAqByC,OAAAA,CAAQ,EAAED,IAAI,OAAOE,aAAa,MAAMA,SAAAA,CAAAA,CAAAA;AACzH,WAAOL,QAAQM,MAAMC,OAAAA;EACvB;;;;EAKA,MAAMV,aAA4B;AAChC,QAAI,KAAKb,eAAgB;AACzB,UAAM,KAAKwB,sBAAqB;AAChC,SAAKxB,iBAAiB;AACtB;EACF;EAEA,MAAgBwB,wBAAuC;AACrD,aAASJ,UAAU,GAAGA,UAAU,KAAKjB,gBAAgBsB,QAAQL,WAAW;AACtE,YAAMM,iBAAiB,KAAKvB,gBAAgBiB,OAAAA;AAC5C,YAAMC,WAAW1C,qBAAqB+C,cAAAA;AACtC,WAAK5B,gBAAgB4B,cAAAA,IAAmB,MAAML,SAAAA,IAAc,OAAO;IACrE;AACA,SAAKpB,6BAA6B0B,OAAOC,OAAO,KAAK9B,eAAe,EAAEwB,MAAMC,OAAAA;EAC9E;AACF;AA3Ha3B;AAAN,IAAMA,cAAN;","names":["WasmFeatureDetectors","bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmSupport","_allowWasm","_featureSupport","_forceWasm","_isInitialized","_isWasmFeatureSetSupported","constructor","desiredFeatures","allowWasm","v","canUseWasm","featureSupport","forceWasm","isDesiredFeatureSetSupported","isInitialized","create","instance","initialize","featureCheck","features","results","Promise","all","map","feature","detector","every","Boolean","detectDesiredFeatures","length","desiredFeature","Object","values"]}

package/dist/node/index.js

@@ -1,2 +1,151 @@
-var n=Object.defineProperty;var i=(l,e)=>n(l,"name",{value:e,configurable:!0});import{bigInt as u,bulkMemory as d,exceptions as m,extendedConst as c,gc as p,memory64 as h,multiValue as _,mutableGlobals as f,referenceTypes as W,relaxedSimd as S,saturatedFloatToInt as F,signExtensions as g,simd as w,streamingCompilation as y,tailCall as I,threads as x}from"wasm-feature-detect";var r={bigInt:u,bulkMemory:d,exceptions:m,extendedConst:c,gc:p,memory64:h,multiValue:_,mutableGlobals:f,referenceTypes:W,relaxedSimd:S,saturatedFloatToInt:F,signExtensions:g,simd:w,streamingCompilation:y,tailCall:I,threads:x},a=class a{desiredFeatures;_allowWasm;_featureSupport;_forceWasm;_isInitialized;_isWasmFeatureSetSupported;constructor(e){this.desiredFeatures=e,this._allowWasm=!0,this._featureSupport={},this._forceWasm=!1,this._isInitialized=!1,this._isWasmFeatureSetSupported=!1}get allowWasm(){return this._allowWasm}set allowWasm(e){this._allowWasm=e}get canUseWasm(){return this._forceWasm||this._allowWasm&&!this._isInitialized||this._allowWasm&&this._isInitialized&&this._isWasmFeatureSetSupported}get featureSupport(){return{...this._featureSupport}}get forceWasm(){return this._forceWasm}set forceWasm(e){this._forceWasm=e}get isDesiredFeatureSetSupported(){return this._isWasmFeatureSetSupported}get isInitialized(){return this._isInitialized}static async create(e){let t=new a(e);return await t.initialize(),t}async featureCheck(e){return(await Promise.all(e.map(s=>r[s]).map(async s=>await s()))).every(Boolean)}async initialize(){this._isInitialized||(await this.detectDesiredFeatures(),this._isInitialized=!0)}async detectDesiredFeatures(){for(let e=0;e<this.desiredFeatures.length;e++){let t=this.desiredFeatures[e],s=r[t];this._featureSupport[t]=!!await s()}this._isWasmFeatureSetSupported=Object.values(this._featureSupport).every(Boolean)}};i(a,"WasmSupport");var o=a;export{r as WasmFeatureDetectors,o as WasmSupport};
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/WasmSupport.ts
+import { bigInt, bulkMemory, exceptions, extendedConst, gc, memory64, multiValue, mutableGlobals, referenceTypes, relaxedSimd, saturatedFloatToInt, signExtensions, simd, streamingCompilation, tailCall, threads } from "wasm-feature-detect";
+var WasmFeatureDetectors = {
+  bigInt,
+  bulkMemory,
+  exceptions,
+  extendedConst,
+  gc,
+  memory64,
+  multiValue,
+  mutableGlobals,
+  referenceTypes,
+  relaxedSimd,
+  saturatedFloatToInt,
+  signExtensions,
+  simd,
+  streamingCompilation,
+  tailCall,
+  threads
+};
+var _WasmSupport = class _WasmSupport {
+  desiredFeatures;
+  _allowWasm;
+  _featureSupport;
+  _forceWasm;
+  _isInitialized;
+  _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) {
+    this.desiredFeatures = desiredFeatures;
+    this._allowWasm = true;
+    this._featureSupport = {};
+    this._forceWasm = false;
+    this._isInitialized = false;
+    this._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 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(Boolean);
+  }
+  /**
+  * 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];
+      this._featureSupport[desiredFeature] = await detector() ? true : false;
+    }
+    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean);
+  }
+};
+__name(_WasmSupport, "WasmSupport");
+var WasmSupport = _WasmSupport;
+export {
+  WasmFeatureDetectors,
+  WasmSupport
+};
 //# sourceMappingURL=index.js.map

package/dist/node/index.js.map

@@ -1 +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 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(Boolean)\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      this._featureSupport[desiredFeature] = (await detector()) ? true : false\n    }\n    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean)\n  }\n}\n"],"mappings":"+EAAA,OACEA,UAAAA,EACAC,cAAAA,EACAC,cAAAA,EACAC,iBAAAA,EACAC,MAAAA,EACAC,YAAAA,EACAC,cAAAA,EACAC,kBAAAA,EACAC,kBAAAA,EACAC,eAAAA,EACAC,uBAAAA,EACAC,kBAAAA,EACAC,QAAAA,EACAC,wBAAAA,EACAC,YAAAA,EACAC,WAAAA,MACK,sBAEA,IAAMC,EAAuB,CAClCC,OAAQA,EACRC,WAAYA,EACZC,WAAYA,EACZC,cAAeA,EACfC,GAAIA,EACJC,SAAUA,EACVC,WAAYA,EACZC,eAAgBA,EAChBC,eAAgBA,EAChBC,YAAaA,EACbC,oBAAqBA,EACrBC,eAAgBA,EAChBC,KAAMA,EACNC,qBAAsBA,EACtBC,SAAUA,EACVC,QAASA,CACX,EAIaC,EAAN,MAAMA,CAAAA,iBACHC,WACAC,gBACAC,WACAC,eACAC,2BAURC,YAAsBC,EAAgC,MAAhCA,gBAAAA,OAddN,WAAa,QACbC,gBAAyD,CAAC,OAC1DC,WAAa,QACbC,eAAiB,QACjBC,2BAA6B,EAUkB,CAKvD,IAAIG,WAAqB,CACvB,OAAO,KAAKP,UACd,CAIA,IAAIO,UAAUC,EAAY,CACxB,KAAKR,WAAaQ,CACpB,CAMA,IAAIC,YAAsB,CACxB,OAEE,KAAKP,YAEJ,KAAKF,YAAc,CAAC,KAAKG,gBAEzB,KAAKH,YAAc,KAAKG,gBAAkB,KAAKC,0BAEpD,CAMA,IAAIM,gBAAkE,CACpE,MAAO,CAAE,GAAG,KAAKT,eAAgB,CACnC,CAKA,IAAIU,WAAqB,CACvB,OAAO,KAAKT,UACd,CAIA,IAAIS,UAAUH,EAAY,CACxB,KAAKN,WAAaM,CACpB,CAMA,IAAII,8BAAwC,CAC1C,OAAO,KAAKR,0BACd,CAMA,IAAIS,eAAyB,CAC3B,OAAO,KAAKV,cACd,CASA,aAAaW,OAAOR,EAAsD,CACxE,IAAMS,EAAW,IAAIhB,EAAYO,CAAAA,EACjC,aAAMS,EAASC,WAAU,EAClBD,CACT,CAOA,MAAME,aAAaC,EAA2C,CAE5D,OADgB,MAAMC,QAAQC,IAAIF,EAASG,IAAKC,GAAYxC,EAAqBwC,CAAAA,CAAQ,EAAED,IAAI,MAAOE,GAAa,MAAMA,EAAAA,CAAAA,CAAAA,GAC1GC,MAAMC,OAAAA,CACvB,CAKA,MAAMT,YAA4B,CAC5B,KAAKb,iBACT,MAAM,KAAKuB,sBAAqB,EAChC,KAAKvB,eAAiB,GAExB,CAEA,MAAgBuB,uBAAuC,CACrD,QAASJ,EAAU,EAAGA,EAAU,KAAKhB,gBAAgBqB,OAAQL,IAAW,CACtE,IAAMM,EAAiB,KAAKtB,gBAAgBgB,CAAAA,EACtCC,EAAWzC,EAAqB8C,CAAAA,EACtC,KAAK3B,gBAAgB2B,CAAAA,EAAmB,QAAML,EAAAA,CAChD,CACA,KAAKnB,2BAA6ByB,OAAOC,OAAO,KAAK7B,eAAe,EAAEuB,MAAMC,OAAAA,CAC9E,CACF,EA3Ha1B,EAAAA,EAAAA,eAAN,IAAMA,EAANgC","names":["bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmFeatureDetectors","bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmSupport","_allowWasm","_featureSupport","_forceWasm","_isInitialized","_isWasmFeatureSetSupported","constructor","desiredFeatures","allowWasm","v","canUseWasm","featureSupport","forceWasm","isDesiredFeatureSetSupported","isInitialized","create","instance","initialize","featureCheck","features","Promise","all","map","feature","detector","every","Boolean","detectDesiredFeatures","length","desiredFeature","Object","values","_WasmSupport"]}
+{"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 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(Boolean)\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      this._featureSupport[desiredFeature] = (await detector()) ? true : false\n    }\n    this._isWasmFeatureSetSupported = Object.values(this._featureSupport).every(Boolean)\n  }\n}\n"],"mappings":";;;;AAAA,SACEA,QACAC,YACAC,YACAC,eACAC,IACAC,UACAC,YACAC,gBACAC,gBACAC,aACAC,qBACAC,gBACAC,MACAC,sBACAC,UACAC,eACK;AAEA,IAAMC,uBAAuB;EAClCC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;EACAC;AACF;AAIO,IAAMC,eAAN,MAAMA,aAAAA;;EACHC;EACAC;EACAC;EACAC;EACAC;;;;;;;;;EAURC,YAAsBC,iBAAgC;SAAhCA,kBAAAA;SAddN,aAAa;SACbC,kBAAyD,CAAC;SAC1DC,aAAa;SACbC,iBAAiB;SACjBC,6BAA6B;EAUkB;;;;EAKvD,IAAIG,YAAqB;AACvB,WAAO,KAAKP;EACd;;;;EAIA,IAAIO,UAAUC,GAAY;AACxB,SAAKR,aAAaQ;EACpB;;;;;EAMA,IAAIC,aAAsB;AACxB;;MAEE,KAAKP;MAEJ,KAAKF,cAAc,CAAC,KAAKG;MAEzB,KAAKH,cAAc,KAAKG,kBAAkB,KAAKC;;EAEpD;;;;;EAMA,IAAIM,iBAAkE;AACpE,WAAO;MAAE,GAAG,KAAKT;IAAgB;EACnC;;;;EAKA,IAAIU,YAAqB;AACvB,WAAO,KAAKT;EACd;;;;EAIA,IAAIS,UAAUH,GAAY;AACxB,SAAKN,aAAaM;EACpB;;;;;EAMA,IAAII,+BAAwC;AAC1C,WAAO,KAAKR;EACd;;;;;EAMA,IAAIS,gBAAyB;AAC3B,WAAO,KAAKV;EACd;;;;;;;;EASA,aAAaW,OAAOR,iBAAsD;AACxE,UAAMS,WAAW,IAAIhB,aAAYO,eAAAA;AACjC,UAAMS,SAASC,WAAU;AACzB,WAAOD;EACT;;;;;;EAOA,MAAME,aAAaC,UAA2C;AAC5D,UAAMC,UAAU,MAAMC,QAAQC,IAAIH,SAASI,IAAI,CAACC,YAAYzC,qBAAqByC,OAAAA,CAAQ,EAAED,IAAI,OAAOE,aAAa,MAAMA,SAAAA,CAAAA,CAAAA;AACzH,WAAOL,QAAQM,MAAMC,OAAAA;EACvB;;;;EAKA,MAAMV,aAA4B;AAChC,QAAI,KAAKb,eAAgB;AACzB,UAAM,KAAKwB,sBAAqB;AAChC,SAAKxB,iBAAiB;AACtB;EACF;EAEA,MAAgBwB,wBAAuC;AACrD,aAASJ,UAAU,GAAGA,UAAU,KAAKjB,gBAAgBsB,QAAQL,WAAW;AACtE,YAAMM,iBAAiB,KAAKvB,gBAAgBiB,OAAAA;AAC5C,YAAMC,WAAW1C,qBAAqB+C,cAAAA;AACtC,WAAK5B,gBAAgB4B,cAAAA,IAAmB,MAAML,SAAAA,IAAc,OAAO;IACrE;AACA,SAAKpB,6BAA6B0B,OAAOC,OAAO,KAAK9B,eAAe,EAAEwB,MAAMC,OAAAA;EAC9E;AACF;AA3Ha3B;AAAN,IAAMA,cAAN;","names":["bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmFeatureDetectors","bigInt","bulkMemory","exceptions","extendedConst","gc","memory64","multiValue","mutableGlobals","referenceTypes","relaxedSimd","saturatedFloatToInt","signExtensions","simd","streamingCompilation","tailCall","threads","WasmSupport","_allowWasm","_featureSupport","_forceWasm","_isInitialized","_isWasmFeatureSetSupported","constructor","desiredFeatures","allowWasm","v","canUseWasm","featureSupport","forceWasm","isDesiredFeatureSetSupported","isInitialized","create","instance","initialize","featureCheck","features","results","Promise","all","map","feature","detector","every","Boolean","detectDesiredFeatures","length","desiredFeature","Object","values"]}

package/package.json

@@ -14,8 +14,8 @@
   },
   "description": "Primary SDK for using XYO Protocol 2.0",
   "devDependencies": {
-    "@xylabs/ts-scripts-yarn3": "^3.11.9",
-    "@xylabs/tsconfig": "^3.11.9",
+    "@xylabs/ts-scripts-yarn3": "^3.11.10",
+    "@xylabs/tsconfig": "^3.11.10",
     "typescript": "^5.5.2"
   },
   "exports": {
@@ -56,6 +56,6 @@
     "url": "https://github.com/XYOracleNetwork/sdk-xyo-client-js.git"
   },
   "sideEffects": false,
-  "version": "2.107.1",
+  "version": "2.107.4",
   "type": "module"
 }