@spiffcommerce/preview 3.6.2-rc.4 → 3.6.2-rc.5

package/dist/node_modules/@babylonjs/core/Misc/khronosTextureContainer2.esm.js

@@ -0,0 +1,281 @@
+import { AutoReleaseWorkerPool as S } from "./workerPool.esm.js";
+import { Tools as u } from "./tools.esm.js";
+import { TranscodeTarget as D, EngineFormat as p } from "../Materials/Textures/ktx2decoderTypes.esm.js";
+function m(t) {
+  return t ? u.GetAbsoluteUrl(t) : null;
+}
+function h(t) {
+  t.wasmUASTCToASTC !== null && (KTX2DECODER.LiteTranscoder_UASTC_ASTC.WasmModuleURL = t.wasmUASTCToASTC), t.wasmUASTCToBC7 !== null && (KTX2DECODER.LiteTranscoder_UASTC_BC7.WasmModuleURL = t.wasmUASTCToBC7), t.wasmUASTCToRGBA_UNORM !== null && (KTX2DECODER.LiteTranscoder_UASTC_RGBA_UNORM.WasmModuleURL = t.wasmUASTCToRGBA_UNORM), t.wasmUASTCToRGBA_SRGB !== null && (KTX2DECODER.LiteTranscoder_UASTC_RGBA_SRGB.WasmModuleURL = t.wasmUASTCToRGBA_SRGB), t.wasmUASTCToR8_UNORM !== null && (KTX2DECODER.LiteTranscoder_UASTC_R8_UNORM.WasmModuleURL = t.wasmUASTCToR8_UNORM), t.wasmUASTCToRG8_UNORM !== null && (KTX2DECODER.LiteTranscoder_UASTC_RG8_UNORM.WasmModuleURL = t.wasmUASTCToRG8_UNORM), t.jsMSCTranscoder !== null && (KTX2DECODER.MSCTranscoder.JSModuleURL = t.jsMSCTranscoder), t.wasmMSCTranscoder !== null && (KTX2DECODER.MSCTranscoder.WasmModuleURL = t.wasmMSCTranscoder), t.wasmZSTDDecoder !== null && (KTX2DECODER.ZSTDDecoder.WasmModuleURL = t.wasmZSTDDecoder);
+}
+class _ {
+  constructor() {
+    this._isDirty = !0, this._useRGBAIfOnlyBC1BC3AvailableWhenUASTC = !0, this._ktx2DecoderOptions = {};
+  }
+  /**
+   * Gets the dirty flag
+   */
+  get isDirty() {
+    return this._isDirty;
+  }
+  /**
+   * force a (uncompressed) RGBA transcoded format if transcoding a UASTC source format and ASTC + BC7 are not available as a compressed transcoded format
+   */
+  get useRGBAIfASTCBC7NotAvailableWhenUASTC() {
+    return this._useRGBAIfASTCBC7NotAvailableWhenUASTC;
+  }
+  set useRGBAIfASTCBC7NotAvailableWhenUASTC(e) {
+    this._useRGBAIfASTCBC7NotAvailableWhenUASTC !== e && (this._useRGBAIfASTCBC7NotAvailableWhenUASTC = e, this._isDirty = !0);
+  }
+  /**
+   * force a (uncompressed) RGBA transcoded format if transcoding a UASTC source format and only BC1 or BC3 are available as a compressed transcoded format.
+   * This property is true by default to favor speed over memory, because currently transcoding from UASTC to BC1/3 is slow because the transcoder transcodes
+   * to uncompressed and then recompresses the texture
+   */
+  get useRGBAIfOnlyBC1BC3AvailableWhenUASTC() {
+    return this._useRGBAIfOnlyBC1BC3AvailableWhenUASTC;
+  }
+  set useRGBAIfOnlyBC1BC3AvailableWhenUASTC(e) {
+    this._useRGBAIfOnlyBC1BC3AvailableWhenUASTC !== e && (this._useRGBAIfOnlyBC1BC3AvailableWhenUASTC = e, this._isDirty = !0);
+  }
+  /**
+   * force to always use (uncompressed) RGBA for transcoded format
+   */
+  get forceRGBA() {
+    return this._forceRGBA;
+  }
+  set forceRGBA(e) {
+    this._forceRGBA !== e && (this._forceRGBA = e, this._isDirty = !0);
+  }
+  /**
+   * force to always use (uncompressed) R8 for transcoded format
+   */
+  get forceR8() {
+    return this._forceR8;
+  }
+  set forceR8(e) {
+    this._forceR8 !== e && (this._forceR8 = e, this._isDirty = !0);
+  }
+  /**
+   * force to always use (uncompressed) RG8 for transcoded format
+   */
+  get forceRG8() {
+    return this._forceRG8;
+  }
+  set forceRG8(e) {
+    this._forceRG8 !== e && (this._forceRG8 = e, this._isDirty = !0);
+  }
+  /**
+   * list of transcoders to bypass when looking for a suitable transcoder. The available transcoders are:
+   *      UniversalTranscoder_UASTC_ASTC
+   *      UniversalTranscoder_UASTC_BC7
+   *      UniversalTranscoder_UASTC_RGBA_UNORM
+   *      UniversalTranscoder_UASTC_RGBA_SRGB
+   *      UniversalTranscoder_UASTC_R8_UNORM
+   *      UniversalTranscoder_UASTC_RG8_UNORM
+   *      MSCTranscoder
+   */
+  get bypassTranscoders() {
+    return this._bypassTranscoders;
+  }
+  set bypassTranscoders(e) {
+    this._bypassTranscoders !== e && (this._bypassTranscoders = e, this._isDirty = !0);
+  }
+  /** @internal */
+  _getKTX2DecoderOptions() {
+    if (!this._isDirty)
+      return this._ktx2DecoderOptions;
+    this._isDirty = !1;
+    const e = {
+      useRGBAIfASTCBC7NotAvailableWhenUASTC: this._useRGBAIfASTCBC7NotAvailableWhenUASTC,
+      forceRGBA: this._forceRGBA,
+      forceR8: this._forceR8,
+      forceRG8: this._forceRG8,
+      bypassTranscoders: this._bypassTranscoders
+    };
+    return this.useRGBAIfOnlyBC1BC3AvailableWhenUASTC && (e.transcodeFormatDecisionTree = {
+      UASTC: {
+        transcodeFormat: [D.BC1_RGB, D.BC3_RGBA],
+        yes: {
+          transcodeFormat: D.RGBA32,
+          engineFormat: p.RGBA8Format,
+          roundToMultiple4: !1
+        }
+      }
+    }), this._ktx2DecoderOptions = e, e;
+  }
+}
+class o {
+  static GetDefaultNumWorkers() {
+    return typeof navigator != "object" || !navigator.hardwareConcurrency ? 1 : Math.min(Math.floor(navigator.hardwareConcurrency * 0.5), 4);
+  }
+  static _Initialize(e) {
+    if (o._WorkerPoolPromise || o._DecoderModulePromise)
+      return;
+    const s = {
+      jsDecoderModule: u.GetAbsoluteUrl(this.URLConfig.jsDecoderModule),
+      wasmUASTCToASTC: m(this.URLConfig.wasmUASTCToASTC),
+      wasmUASTCToBC7: m(this.URLConfig.wasmUASTCToBC7),
+      wasmUASTCToRGBA_UNORM: m(this.URLConfig.wasmUASTCToRGBA_UNORM),
+      wasmUASTCToRGBA_SRGB: m(this.URLConfig.wasmUASTCToRGBA_SRGB),
+      wasmUASTCToR8_UNORM: m(this.URLConfig.wasmUASTCToR8_UNORM),
+      wasmUASTCToRG8_UNORM: m(this.URLConfig.wasmUASTCToRG8_UNORM),
+      jsMSCTranscoder: m(this.URLConfig.jsMSCTranscoder),
+      wasmMSCTranscoder: m(this.URLConfig.wasmMSCTranscoder),
+      wasmZSTDDecoder: m(this.URLConfig.wasmZSTDDecoder)
+    };
+    e && typeof Worker == "function" && typeof URL < "u" ? o._WorkerPoolPromise = new Promise((c) => {
+      const a = `${h}(${B})()`, T = URL.createObjectURL(new Blob([a], { type: "application/javascript" }));
+      c(new S(e, () => new Promise((d, i) => {
+        const n = new Worker(T), r = (f) => {
+          n.removeEventListener("error", r), n.removeEventListener("message", l), i(f);
+        }, l = (f) => {
+          f.data.action === "init" && (n.removeEventListener("error", r), n.removeEventListener("message", l), d(n));
+        };
+        n.addEventListener("error", r), n.addEventListener("message", l), n.postMessage({
+          action: "init",
+          urls: s
+        });
+      })));
+    }) : typeof KTX2DECODER > "u" ? o._DecoderModulePromise = u.LoadScriptAsync(s.jsDecoderModule).then(() => (KTX2DECODER.MSCTranscoder.UseFromWorkerThread = !1, KTX2DECODER.WASMMemoryManager.LoadBinariesFromCurrentThread = !0, h(s), new KTX2DECODER.KTX2Decoder())) : (KTX2DECODER.MSCTranscoder.UseFromWorkerThread = !1, KTX2DECODER.WASMMemoryManager.LoadBinariesFromCurrentThread = !0, o._DecoderModulePromise = Promise.resolve(new KTX2DECODER.KTX2Decoder()));
+  }
+  /**
+   * Constructor
+   * @param engine The engine to use
+   * @param numWorkers The number of workers for async operations. Specify `0` to disable web workers and run synchronously in the current context.
+   */
+  constructor(e, s = o.DefaultNumWorkers) {
+    this._engine = e, o._Initialize(s);
+  }
+  /**
+   * @internal
+   */
+  uploadAsync(e, s, c) {
+    const a = this._engine.getCaps(), T = {
+      astc: !!a.astc,
+      bptc: !!a.bptc,
+      s3tc: !!a.s3tc,
+      pvrtc: !!a.pvrtc,
+      etc2: !!a.etc2,
+      etc1: !!a.etc1
+    };
+    if (o._WorkerPoolPromise)
+      return o._WorkerPoolPromise.then((d) => new Promise((i, n) => {
+        d.push((r, l) => {
+          const f = (C) => {
+            r.removeEventListener("error", f), r.removeEventListener("message", R), n(C), l();
+          }, R = (C) => {
+            if (C.data.action === "decoded") {
+              if (r.removeEventListener("error", f), r.removeEventListener("message", R), !C.data.success)
+                n({ message: C.data.msg });
+              else
+                try {
+                  this._createTexture(C.data.decodedData, s, c), i();
+                } catch (U) {
+                  n({ message: U });
+                }
+              l();
+            }
+          };
+          r.addEventListener("error", f), r.addEventListener("message", R), r.postMessage({ action: "setDefaultDecoderOptions", options: o.DefaultDecoderOptions._getKTX2DecoderOptions() });
+          const A = new Uint8Array(e.byteLength);
+          A.set(new Uint8Array(e.buffer, e.byteOffset, e.byteLength)), r.postMessage({ action: "decode", data: A, caps: T, options: c }, [A.buffer]);
+        });
+      }));
+    if (o._DecoderModulePromise)
+      return o._DecoderModulePromise.then((d) => (o.DefaultDecoderOptions.isDirty && (KTX2DECODER.KTX2Decoder.DefaultDecoderOptions = o.DefaultDecoderOptions._getKTX2DecoderOptions()), new Promise((i, n) => {
+        d.decode(e, a).then((r) => {
+          this._createTexture(r, s), i();
+        }).catch((r) => {
+          n({ message: r });
+        });
+      })));
+    throw new Error("KTX2 decoder module is not available");
+  }
+  _createTexture(e, s, c) {
+    this._engine._bindTextureDirectly(3553, s), c && (c.transcodedFormat = e.transcodedFormat, c.isInGammaSpace = e.isInGammaSpace, c.hasAlpha = e.hasAlpha, c.transcoderName = e.transcoderName);
+    let T = !0;
+    switch (e.transcodedFormat) {
+      case 32856:
+        s.type = 0, s.format = 5;
+        break;
+      case 33321:
+        s.type = 0, s.format = 6;
+        break;
+      case 33323:
+        s.type = 0, s.format = 7;
+        break;
+      default:
+        s.format = e.transcodedFormat, T = !1;
+        break;
+    }
+    if (s._gammaSpace = e.isInGammaSpace, s.generateMipMaps = e.mipmaps.length > 1, e.errors)
+      throw new Error("KTX2 container - could not transcode the data. " + e.errors);
+    for (let d = 0; d < e.mipmaps.length; ++d) {
+      const i = e.mipmaps[d];
+      if (!i || !i.data)
+        throw new Error("KTX2 container - could not transcode one of the image");
+      T ? (s.width = i.width, s.height = i.height, this._engine._uploadDataToTextureDirectly(s, i.data, 0, d, void 0, !0)) : this._engine._uploadCompressedDataToTextureDirectly(s, e.transcodedFormat, i.width, i.height, i.data, 0, d);
+    }
+    s._extension = ".ktx2", s.width = e.mipmaps[0].width, s.height = e.mipmaps[0].height, s.isReady = !0, this._engine._bindTextureDirectly(3553, null);
+  }
+  /**
+   * Checks if the given data starts with a KTX2 file identifier.
+   * @param data the data to check
+   * @returns true if the data is a KTX2 file or false otherwise
+   */
+  static IsValid(e) {
+    if (e.byteLength >= 12) {
+      const s = new Uint8Array(e.buffer, e.byteOffset, 12);
+      if (s[0] === 171 && s[1] === 75 && s[2] === 84 && s[3] === 88 && s[4] === 32 && s[5] === 50 && s[6] === 48 && s[7] === 187 && s[8] === 13 && s[9] === 10 && s[10] === 26 && s[11] === 10)
+        return !0;
+    }
+    return !1;
+  }
+}
+o.URLConfig = {
+  jsDecoderModule: "https://preview.babylonjs.com/babylon.ktx2Decoder.js",
+  wasmUASTCToASTC: null,
+  wasmUASTCToBC7: null,
+  wasmUASTCToRGBA_UNORM: null,
+  wasmUASTCToRGBA_SRGB: null,
+  wasmUASTCToR8_UNORM: null,
+  wasmUASTCToRG8_UNORM: null,
+  jsMSCTranscoder: null,
+  wasmMSCTranscoder: null,
+  wasmZSTDDecoder: null
+};
+o.DefaultNumWorkers = o.GetDefaultNumWorkers();
+o.DefaultDecoderOptions = new _();
+function B() {
+  let t;
+  onmessage = (e) => {
+    if (e.data)
+      switch (e.data.action) {
+        case "init": {
+          const s = e.data.urls;
+          importScripts(s.jsDecoderModule), h(s), t = new KTX2DECODER.KTX2Decoder(), postMessage({ action: "init" });
+          break;
+        }
+        case "setDefaultDecoderOptions": {
+          KTX2DECODER.KTX2Decoder.DefaultDecoderOptions = e.data.options;
+          break;
+        }
+        case "decode":
+          t.decode(e.data.data, e.data.caps, e.data.options).then((s) => {
+            const c = [];
+            for (let a = 0; a < s.mipmaps.length; ++a) {
+              const T = s.mipmaps[a];
+              T && T.data && c.push(T.data.buffer);
+            }
+            postMessage({ action: "decoded", success: !0, decodedData: s }, c);
+          }).catch((s) => {
+            postMessage({ action: "decoded", success: !1, msg: s });
+          });
+          break;
+      }
+  };
+}
+export {
+  _ as DefaultKTX2DecoderOptions,
+  o as KhronosTextureContainer2
+};

package/dist/node_modules/@babylonjs/core/Misc/logger.esm.js

@@ -0,0 +1,77 @@
+class e {
+  static _CheckLimit(a, n) {
+    let t = e._LogLimitOutputs[a];
+    return t ? t.current++ : (t = { limit: n, current: 1 }, e._LogLimitOutputs[a] = t), t.current <= t.limit;
+  }
+  static _GenerateLimitMessage(a, n = 1) {
+    var t;
+    const s = e._LogLimitOutputs[a];
+    if (!s || !e.MessageLimitReached)
+      return;
+    const o = this._Levels[n];
+    s.current === s.limit && e[o.name](e.MessageLimitReached.replace(/%LIMIT%/g, "" + s.limit).replace(/%TYPE%/g, (t = o.name) !== null && t !== void 0 ? t : ""));
+  }
+  static _AddLogEntry(a) {
+    e._LogCache = a + e._LogCache, e.OnNewCacheEntry && e.OnNewCacheEntry(a);
+  }
+  static _FormatMessage(a) {
+    const n = (s) => s < 10 ? "0" + s : "" + s, t = /* @__PURE__ */ new Date();
+    return "[" + n(t.getHours()) + ":" + n(t.getMinutes()) + ":" + n(t.getSeconds()) + "]: " + a;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  static _LogDisabled(a, n) {
+  }
+  static _LogEnabled(a = 1, n, t) {
+    if (t !== void 0 && !e._CheckLimit(n, t))
+      return;
+    const s = e._FormatMessage(n), o = this._Levels[a];
+    o.logFunc && o.logFunc("BJS - " + s);
+    const i = `<div style='color:${o.color}'>${s}</div><br>`;
+    e._AddLogEntry(i), e._GenerateLimitMessage(n, a);
+  }
+  /**
+   * Gets current log cache (list of logs)
+   */
+  static get LogCache() {
+    return e._LogCache;
+  }
+  /**
+   * Clears the log cache
+   */
+  static ClearLogCache() {
+    e._LogCache = "", e._LogLimitOutputs = {}, e.errorsCount = 0;
+  }
+  /**
+   * Sets the current log level (MessageLogLevel / WarningLogLevel / ErrorLogLevel)
+   */
+  static set LogLevels(a) {
+    e.Log = e._LogDisabled, e.Warn = e._LogDisabled, e.Error = e._LogDisabled, [e.MessageLogLevel, e.WarningLogLevel, e.ErrorLogLevel].forEach((n) => {
+      if ((a & n) === n) {
+        const t = this._Levels[n];
+        e[t.name] = e._LogEnabled.bind(e, n);
+      }
+    });
+  }
+}
+e.NoneLogLevel = 0;
+e.MessageLogLevel = 1;
+e.WarningLogLevel = 2;
+e.ErrorLogLevel = 4;
+e.AllLogLevel = 7;
+e.MessageLimitReached = "Too many %TYPE%s (%LIMIT%), no more %TYPE%s will be reported for this message.";
+e._LogCache = "";
+e._LogLimitOutputs = {};
+e._Levels = [
+  {},
+  { color: "white", logFunc: console.log, name: "Log" },
+  { color: "orange", logFunc: console.warn, name: "Warn" },
+  {},
+  { color: "red", logFunc: console.error, name: "Error" }
+];
+e.errorsCount = 0;
+e.Log = e._LogEnabled.bind(e, e.MessageLogLevel);
+e.Warn = e._LogEnabled.bind(e, e.WarningLogLevel);
+e.Error = e._LogEnabled.bind(e, e.ErrorLogLevel);
+export {
+  e as Logger
+};

package/dist/node_modules/@babylonjs/core/Misc/observable.esm.js

@@ -0,0 +1,231 @@
+class o {
+  /**
+   * Create a new EventState
+   * @param mask defines the mask associated with this state
+   * @param skipNextObservers defines a flag which will instruct the observable to skip following observers when set to true
+   * @param target defines the original target of the state
+   * @param currentTarget defines the current target of the state
+   */
+  constructor(e, s = !1, t, r) {
+    this.initialize(e, s, t, r);
+  }
+  /**
+   * Initialize the current event state
+   * @param mask defines the mask associated with this state
+   * @param skipNextObservers defines a flag which will instruct the observable to skip following observers when set to true
+   * @param target defines the original target of the state
+   * @param currentTarget defines the current target of the state
+   * @returns the current event state
+   */
+  initialize(e, s = !1, t, r) {
+    return this.mask = e, this.skipNextObservers = s, this.target = t, this.currentTarget = r, this;
+  }
+}
+class h {
+  /**
+   * Creates a new observer
+   * @param callback defines the callback to call when the observer is notified
+   * @param mask defines the mask of the observer (used to filter notifications)
+   * @param scope defines the current scope used to restore the JS context
+   */
+  constructor(e, s, t = null) {
+    this.callback = e, this.mask = s, this.scope = t, this._willBeUnregistered = !1, this.unregisterOnNextCall = !1, this._remove = null;
+  }
+  /**
+   * Remove the observer from its observable
+   * This can be used instead of using the observable's remove function.
+   */
+  remove() {
+    this._remove && this._remove();
+  }
+}
+class f {
+  /**
+   * Create an observable from a Promise.
+   * @param promise a promise to observe for fulfillment.
+   * @param onErrorObservable an observable to notify if a promise was rejected.
+   * @returns the new Observable
+   */
+  static FromPromise(e, s) {
+    const t = new f();
+    return e.then((r) => {
+      t.notifyObservers(r);
+    }).catch((r) => {
+      if (s)
+        s.notifyObservers(r);
+      else
+        throw r;
+    }), t;
+  }
+  /**
+   * Gets the list of observers
+   * Note that observers that were recently deleted may still be present in the list because they are only really deleted on the next javascript tick!
+   */
+  get observers() {
+    return this._observers;
+  }
+  /**
+   * Creates a new observable
+   * @param onObserverAdded defines a callback to call when a new observer is added
+   * @param notifyIfTriggered If set to true the observable will notify when an observer was added if the observable was already triggered.
+   */
+  constructor(e, s = !1) {
+    this.notifyIfTriggered = s, this._observers = new Array(), this._numObserversMarkedAsDeleted = 0, this._hasNotified = !1, this._eventState = new o(0), e && (this._onObserverAdded = e);
+  }
+  /**
+   * Create a new Observer with the specified callback
+   * @param callback the callback that will be executed for that Observer
+   * @param mask the mask used to filter observers
+   * @param insertFirst if true the callback will be inserted at the first position, hence executed before the others ones. If false (default behavior) the callback will be inserted at the last position, executed after all the others already present.
+   * @param scope optional scope for the callback to be called from
+   * @param unregisterOnFirstCall defines if the observer as to be unregistered after the next notification
+   * @returns the new observer created for the callback
+   */
+  add(e, s = -1, t = !1, r = null, l = !1) {
+    if (!e)
+      return null;
+    const i = new h(e, s, r);
+    return i.unregisterOnNextCall = l, t ? this._observers.unshift(i) : this._observers.push(i), this._onObserverAdded && this._onObserverAdded(i), this._hasNotified && this.notifyIfTriggered && this._lastNotifiedValue !== void 0 && this.notifyObserver(i, this._lastNotifiedValue), i._remove = () => {
+      this.remove(i);
+    }, i;
+  }
+  /**
+   * Create a new Observer with the specified callback and unregisters after the next notification
+   * @param callback the callback that will be executed for that Observer
+   * @returns the new observer created for the callback
+   */
+  addOnce(e) {
+    return this.add(e, void 0, void 0, void 0, !0);
+  }
+  /**
+   * Remove an Observer from the Observable object
+   * @param observer the instance of the Observer to remove
+   * @returns false if it doesn't belong to this Observable
+   */
+  remove(e) {
+    return e ? (e._remove = null, this._observers.indexOf(e) !== -1 ? (this._deferUnregister(e), !0) : !1) : !1;
+  }
+  /**
+   * Remove a callback from the Observable object
+   * @param callback the callback to remove
+   * @param scope optional scope. If used only the callbacks with this scope will be removed
+   * @returns false if it doesn't belong to this Observable
+   */
+  removeCallback(e, s) {
+    for (let t = 0; t < this._observers.length; t++) {
+      const r = this._observers[t];
+      if (!r._willBeUnregistered && r.callback === e && (!s || s === r.scope))
+        return this._deferUnregister(r), !0;
+    }
+    return !1;
+  }
+  /**
+   * @internal
+   */
+  _deferUnregister(e) {
+    e._willBeUnregistered || (this._numObserversMarkedAsDeleted++, e.unregisterOnNextCall = !1, e._willBeUnregistered = !0, setTimeout(() => {
+      this._remove(e);
+    }, 0));
+  }
+  // This should only be called when not iterating over _observers to avoid callback skipping.
+  // Removes an observer from the _observer Array.
+  _remove(e, s = !0) {
+    if (!e)
+      return !1;
+    const t = this._observers.indexOf(e);
+    return t !== -1 ? (s && this._numObserversMarkedAsDeleted--, this._observers.splice(t, 1), !0) : !1;
+  }
+  /**
+   * Moves the observable to the top of the observer list making it get called first when notified
+   * @param observer the observer to move
+   */
+  makeObserverTopPriority(e) {
+    this._remove(e, !1), this._observers.unshift(e);
+  }
+  /**
+   * Moves the observable to the bottom of the observer list making it get called last when notified
+   * @param observer the observer to move
+   */
+  makeObserverBottomPriority(e) {
+    this._remove(e, !1), this._observers.push(e);
+  }
+  /**
+   * Notify all Observers by calling their respective callback with the given data
+   * Will return true if all observers were executed, false if an observer set skipNextObservers to true, then prevent the subsequent ones to execute
+   * @param eventData defines the data to send to all observers
+   * @param mask defines the mask of the current notification (observers with incompatible mask (ie mask & observer.mask === 0) will not be notified)
+   * @param target defines the original target of the state
+   * @param currentTarget defines the current target of the state
+   * @param userInfo defines any user info to send to observers
+   * @returns false if the complete observer chain was not processed (because one observer set the skipNextObservers to true)
+   */
+  notifyObservers(e, s = -1, t, r, l) {
+    if (this.notifyIfTriggered && (this._hasNotified = !0, this._lastNotifiedValue = e), !this._observers.length)
+      return !0;
+    const i = this._eventState;
+    i.mask = s, i.target = t, i.currentTarget = r, i.skipNextObservers = !1, i.lastReturnValue = e, i.userInfo = l;
+    for (const n of this._observers)
+      if (!n._willBeUnregistered && (n.mask & s && (n.unregisterOnNextCall && this._deferUnregister(n), n.scope ? i.lastReturnValue = n.callback.apply(n.scope, [e, i]) : i.lastReturnValue = n.callback(e, i)), i.skipNextObservers))
+        return !1;
+    return !0;
+  }
+  /**
+   * Notify a specific observer
+   * @param observer defines the observer to notify
+   * @param eventData defines the data to be sent to each callback
+   * @param mask is used to filter observers defaults to -1
+   */
+  notifyObserver(e, s, t = -1) {
+    if (this.notifyIfTriggered && (this._hasNotified = !0, this._lastNotifiedValue = s), e._willBeUnregistered)
+      return;
+    const r = this._eventState;
+    r.mask = t, r.skipNextObservers = !1, e.unregisterOnNextCall && this._deferUnregister(e), e.callback(s, r);
+  }
+  /**
+   * Gets a boolean indicating if the observable has at least one observer
+   * @returns true is the Observable has at least one Observer registered
+   */
+  hasObservers() {
+    return this._observers.length - this._numObserversMarkedAsDeleted > 0;
+  }
+  /**
+   * Clear the list of observers
+   */
+  clear() {
+    for (; this._observers.length; ) {
+      const e = this._observers.pop();
+      e && (e._remove = null);
+    }
+    this._onObserverAdded = null, this._numObserversMarkedAsDeleted = 0, this.cleanLastNotifiedState();
+  }
+  /**
+   * Clean the last notified state - both the internal last value and the has-notified flag
+   */
+  cleanLastNotifiedState() {
+    this._hasNotified = !1, this._lastNotifiedValue = void 0;
+  }
+  /**
+   * Clone the current observable
+   * @returns a new observable
+   */
+  clone() {
+    const e = new f();
+    return e._observers = this._observers.slice(0), e;
+  }
+  /**
+   * Does this observable handles observer registered with a given mask
+   * @param mask defines the mask to be tested
+   * @returns whether or not one observer registered with the given mask is handled
+   **/
+  hasSpecificMask(e = -1) {
+    for (const s of this._observers)
+      if (s.mask & e || s.mask === e)
+        return !0;
+    return !1;
+  }
+}
+export {
+  o as EventState,
+  f as Observable,
+  h as Observer
+};

package/dist/node_modules/@babylonjs/core/Misc/perfCounter.esm.js

@@ -0,0 +1,99 @@
+import { PrecisionDate as s } from "./precisionDate.esm.js";
+class e {
+  /**
+   * Returns the smallest value ever
+   */
+  get min() {
+    return this._min;
+  }
+  /**
+   * Returns the biggest value ever
+   */
+  get max() {
+    return this._max;
+  }
+  /**
+   * Returns the average value since the performance counter is running
+   */
+  get average() {
+    return this._average;
+  }
+  /**
+   * Returns the average value of the last second the counter was monitored
+   */
+  get lastSecAverage() {
+    return this._lastSecAverage;
+  }
+  /**
+   * Returns the current value
+   */
+  get current() {
+    return this._current;
+  }
+  /**
+   * Gets the accumulated total
+   */
+  get total() {
+    return this._totalAccumulated;
+  }
+  /**
+   * Gets the total value count
+   */
+  get count() {
+    return this._totalValueCount;
+  }
+  /**
+   * Creates a new counter
+   */
+  constructor() {
+    this._startMonitoringTime = 0, this._min = 0, this._max = 0, this._average = 0, this._lastSecAverage = 0, this._current = 0, this._totalValueCount = 0, this._totalAccumulated = 0, this._lastSecAccumulated = 0, this._lastSecTime = 0, this._lastSecValueCount = 0;
+  }
+  /**
+   * Call this method to start monitoring a new frame.
+   * This scenario is typically used when you accumulate monitoring time many times for a single frame, you call this method at the start of the frame, then beginMonitoring to start recording and endMonitoring(false) to accumulated the recorded time to the PerfCounter or addCount() to accumulate a monitored count.
+   */
+  fetchNewFrame() {
+    this._totalValueCount++, this._current = 0, this._lastSecValueCount++;
+  }
+  /**
+   * Call this method to monitor a count of something (e.g. mesh drawn in viewport count)
+   * @param newCount the count value to add to the monitored count
+   * @param fetchResult true when it's the last time in the frame you add to the counter and you wish to update the statistics properties (min/max/average), false if you only want to update statistics.
+   */
+  addCount(t, i) {
+    e.Enabled && (this._current += t, i && this._fetchResult());
+  }
+  /**
+   * Start monitoring this performance counter
+   */
+  beginMonitoring() {
+    e.Enabled && (this._startMonitoringTime = s.Now);
+  }
+  /**
+   * Compute the time lapsed since the previous beginMonitoring() call.
+   * @param newFrame true by default to fetch the result and monitor a new frame, if false the time monitored will be added to the current frame counter
+   */
+  endMonitoring(t = !0) {
+    if (!e.Enabled)
+      return;
+    t && this.fetchNewFrame();
+    const i = s.Now;
+    this._current = i - this._startMonitoringTime, t && this._fetchResult();
+  }
+  /**
+   * Call this method to end the monitoring of a frame.
+   * This scenario is typically used when you accumulate monitoring time many times for a single frame, you call this method at the end of the frame, after beginMonitoring to start recording and endMonitoring(false) to accumulated the recorded time to the PerfCounter or addCount() to accumulate a monitored count.
+   */
+  endFrame() {
+    this._fetchResult();
+  }
+  _fetchResult() {
+    this._totalAccumulated += this._current, this._lastSecAccumulated += this._current, this._min = Math.min(this._min, this._current), this._max = Math.max(this._max, this._current), this._average = this._totalAccumulated / this._totalValueCount;
+    const t = s.Now;
+    t - this._lastSecTime > 1e3 && (this._lastSecAverage = this._lastSecAccumulated / this._lastSecValueCount, this._lastSecTime = t, this._lastSecAccumulated = 0, this._lastSecValueCount = 0);
+  }
+}
+e.Enabled = !0;
+export {
+  e as PerfCounter
+};