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

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

@@ -0,0 +1,929 @@
+import { Observable as F } from "./observable.esm.js";
+import { IsWindowObjectExist as m, IsNavigatorAvailable as C, GetDOMTextContent as B } from "./domManagement.esm.js";
+import { Logger as c } from "./logger.esm.js";
+import { DeepCopier as p } from "./deepCopier.esm.js";
+import { PrecisionDate as T } from "./precisionDate.esm.js";
+import { _WarnImport as g } from "./devTools.esm.js";
+import { WebRequest as L } from "./webRequest.esm.js";
+import { EngineStore as P } from "../Engines/engineStore.esm.js";
+import { FileToolsOptions as f, SetCorsBehavior as j, LoadImage as E, LoadFile as U, ReadFile as b, IsBase64DataUrl as y, DecodeBase64UrlToBinary as D } from "./fileTools.esm.js";
+import { TimingTools as w } from "./timingTools.esm.js";
+import { InstantiationTools as v } from "./instantiationTools.esm.js";
+import { RandomGUID as R } from "./guid.esm.js";
+class a {
+  /**
+   * Gets or sets the base URL to use to load assets
+   */
+  static get BaseUrl() {
+    return f.BaseUrl;
+  }
+  static set BaseUrl(e) {
+    f.BaseUrl = e;
+  }
+  /**
+   * Gets or sets the retry strategy to apply when an error happens while loading an asset
+   */
+  static get DefaultRetryStrategy() {
+    return f.DefaultRetryStrategy;
+  }
+  static set DefaultRetryStrategy(e) {
+    f.DefaultRetryStrategy = e;
+  }
+  /**
+   * Default behaviour for cors in the application.
+   * It can be a string if the expected behavior is identical in the entire app.
+   * Or a callback to be able to set it per url or on a group of them (in case of Video source for instance)
+   */
+  static get CorsBehavior() {
+    return f.CorsBehavior;
+  }
+  static set CorsBehavior(e) {
+    f.CorsBehavior = e;
+  }
+  /**
+   * Gets or sets a global variable indicating if fallback texture must be used when a texture cannot be loaded
+   * @ignorenaming
+   */
+  static get UseFallbackTexture() {
+    return P.UseFallbackTexture;
+  }
+  static set UseFallbackTexture(e) {
+    P.UseFallbackTexture = e;
+  }
+  /**
+   * Use this object to register external classes like custom textures or material
+   * to allow the loaders to instantiate them
+   */
+  static get RegisteredExternalClasses() {
+    return v.RegisteredExternalClasses;
+  }
+  static set RegisteredExternalClasses(e) {
+    v.RegisteredExternalClasses = e;
+  }
+  /**
+   * Texture content used if a texture cannot loaded
+   * @ignorenaming
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static get fallbackTexture() {
+    return P.FallbackTexture;
+  }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static set fallbackTexture(e) {
+    P.FallbackTexture = e;
+  }
+  /**
+   * Read the content of a byte array at a specified coordinates (taking in account wrapping)
+   * @param u defines the coordinate on X axis
+   * @param v defines the coordinate on Y axis
+   * @param width defines the width of the source data
+   * @param height defines the height of the source data
+   * @param pixels defines the source byte array
+   * @param color defines the output color
+   */
+  static FetchToRef(e, o, t, r, i, n) {
+    const s = Math.abs(e) * t % t | 0, K = Math.abs(o) * r % r | 0, l = (s + K * t) * 4;
+    n.r = i[l] / 255, n.g = i[l + 1] / 255, n.b = i[l + 2] / 255, n.a = i[l + 3] / 255;
+  }
+  /**
+   * Interpolates between a and b via alpha
+   * @param a The lower value (returned when alpha = 0)
+   * @param b The upper value (returned when alpha = 1)
+   * @param alpha The interpolation-factor
+   * @returns The mixed value
+   */
+  static Mix(e, o, t) {
+    return e * (1 - t) + o * t;
+  }
+  /**
+   * Tries to instantiate a new object from a given class name
+   * @param className defines the class name to instantiate
+   * @returns the new object or null if the system was not able to do the instantiation
+   */
+  static Instantiate(e) {
+    return v.Instantiate(e);
+  }
+  /**
+   * Polyfill for setImmediate
+   * @param action defines the action to execute after the current execution block
+   */
+  static SetImmediate(e) {
+    w.SetImmediate(e);
+  }
+  /**
+   * Function indicating if a number is an exponent of 2
+   * @param value defines the value to test
+   * @returns true if the value is an exponent of 2
+   */
+  static IsExponentOfTwo(e) {
+    let o = 1;
+    do
+      o *= 2;
+    while (o < e);
+    return o === e;
+  }
+  /**
+   * Returns the nearest 32-bit single precision float representation of a Number
+   * @param value A Number.  If the parameter is of a different type, it will get converted
+   * to a number or to NaN if it cannot be converted
+   * @returns number
+   */
+  static FloatRound(e) {
+    return Math.fround ? Math.fround(e) : (a._TmpFloatArray[0] = e, a._TmpFloatArray[0]);
+  }
+  /**
+   * Extracts the filename from a path
+   * @param path defines the path to use
+   * @returns the filename
+   */
+  static GetFilename(e) {
+    const o = e.lastIndexOf("/");
+    return o < 0 ? e : e.substring(o + 1);
+  }
+  /**
+   * Extracts the "folder" part of a path (everything before the filename).
+   * @param uri The URI to extract the info from
+   * @param returnUnchangedIfNoSlash Do not touch the URI if no slashes are present
+   * @returns The "folder" part of the path
+   */
+  static GetFolderPath(e, o = !1) {
+    const t = e.lastIndexOf("/");
+    return t < 0 ? o ? e : "" : e.substring(0, t + 1);
+  }
+  /**
+   * Convert an angle in radians to degrees
+   * @param angle defines the angle to convert
+   * @returns the angle in degrees
+   */
+  static ToDegrees(e) {
+    return e * 180 / Math.PI;
+  }
+  /**
+   * Convert an angle in degrees to radians
+   * @param angle defines the angle to convert
+   * @returns the angle in radians
+   */
+  static ToRadians(e) {
+    return e * Math.PI / 180;
+  }
+  /**
+   * Smooth angle changes (kind of low-pass filter), in particular for device orientation "shaking"
+   * Use trigonometric functions to avoid discontinuity (0/360, -180/180)
+   * @param previousAngle defines last angle value, in degrees
+   * @param newAngle defines new angle value, in degrees
+   * @param smoothFactor defines smoothing sensitivity; min 0: no smoothing, max 1: new data ignored
+   * @returns the angle in degrees
+   */
+  static SmoothAngleChange(e, o, t = 0.9) {
+    const r = this.ToRadians(e), i = this.ToRadians(o);
+    return this.ToDegrees(Math.atan2((1 - t) * Math.sin(i) + t * Math.sin(r), (1 - t) * Math.cos(i) + t * Math.cos(r)));
+  }
+  /**
+   * Returns an array if obj is not an array
+   * @param obj defines the object to evaluate as an array
+   * @param allowsNullUndefined defines a boolean indicating if obj is allowed to be null or undefined
+   * @returns either obj directly if obj is an array or a new array containing obj
+   */
+  static MakeArray(e, o) {
+    return o !== !0 && (e === void 0 || e == null) ? null : Array.isArray(e) ? e : [e];
+  }
+  /**
+   * Gets the pointer prefix to use
+   * @param engine defines the engine we are finding the prefix for
+   * @returns "pointer" if touch is enabled. Else returns "mouse"
+   */
+  static GetPointerPrefix(e) {
+    let o = "pointer";
+    return m() && !window.PointerEvent && (o = "mouse"), e._badDesktopOS && !e._badOS && // And not ipad pros who claim to be macs...
+    !(document && "ontouchend" in document) && (o = "mouse"), o;
+  }
+  /**
+   * Sets the cors behavior on a dom element. This will add the required Tools.CorsBehavior to the element.
+   * @param url define the url we are trying
+   * @param element define the dom element where to configure the cors policy
+   * @param element.crossOrigin
+   */
+  static SetCorsBehavior(e, o) {
+    j(e, o);
+  }
+  /**
+   * Sets the referrerPolicy behavior on a dom element.
+   * @param referrerPolicy define the referrer policy to use
+   * @param element define the dom element where to configure the referrer policy
+   * @param element.referrerPolicy
+   */
+  static SetReferrerPolicyBehavior(e, o) {
+    o.referrerPolicy = e;
+  }
+  // External files
+  /**
+   * Removes unwanted characters from an url
+   * @param url defines the url to clean
+   * @returns the cleaned url
+   */
+  static CleanUrl(e) {
+    return e = e.replace(/#/gm, "%23"), e;
+  }
+  /**
+   * Gets or sets a function used to pre-process url before using them to load assets
+   */
+  static get PreprocessUrl() {
+    return f.PreprocessUrl;
+  }
+  static set PreprocessUrl(e) {
+    f.PreprocessUrl = e;
+  }
+  /**
+   * Loads an image as an HTMLImageElement.
+   * @param input url string, ArrayBuffer, or Blob to load
+   * @param onLoad callback called when the image successfully loads
+   * @param onError callback called when the image fails to load
+   * @param offlineProvider offline provider for caching
+   * @param mimeType optional mime type
+   * @param imageBitmapOptions optional the options to use when creating an ImageBitmap
+   * @returns the HTMLImageElement of the loaded image
+   */
+  static LoadImage(e, o, t, r, i, n) {
+    return E(e, o, t, r, i, n);
+  }
+  /**
+   * Loads a file from a url
+   * @param url url string, ArrayBuffer, or Blob to load
+   * @param onSuccess callback called when the file successfully loads
+   * @param onProgress callback called while file is loading (if the server supports this mode)
+   * @param offlineProvider defines the offline provider for caching
+   * @param useArrayBuffer defines a boolean indicating that date must be returned as ArrayBuffer
+   * @param onError callback called when the file fails to load
+   * @returns a file request object
+   */
+  static LoadFile(e, o, t, r, i, n) {
+    return U(e, o, t, r, i, n);
+  }
+  /**
+   * Loads a file from a url
+   * @param url the file url to load
+   * @param useArrayBuffer defines a boolean indicating that date must be returned as ArrayBuffer
+   * @returns a promise containing an ArrayBuffer corresponding to the loaded file
+   */
+  static LoadFileAsync(e, o = !0) {
+    return new Promise((t, r) => {
+      U(e, (i) => {
+        t(i);
+      }, void 0, void 0, o, (i, n) => {
+        r(n);
+      });
+    });
+  }
+  /**
+   * Load a script (identified by an url). When the url returns, the
+   * content of this file is added into a new script element, attached to the DOM (body element)
+   * @param scriptUrl defines the url of the script to laod
+   * @param onSuccess defines the callback called when the script is loaded
+   * @param onError defines the callback to call if an error occurs
+   * @param scriptId defines the id of the script element
+   */
+  static LoadScript(e, o, t, r) {
+    if (typeof importScripts == "function") {
+      try {
+        importScripts(e), o();
+      } catch (s) {
+        t == null || t(`Unable to load script '${e}' in worker`, s);
+      }
+      return;
+    } else if (!m()) {
+      t == null || t(`Cannot load script '${e}' outside of a window or a worker`);
+      return;
+    }
+    const i = document.getElementsByTagName("head")[0], n = document.createElement("script");
+    n.setAttribute("type", "text/javascript"), n.setAttribute("src", e), r && (n.id = r), n.onload = () => {
+      o && o();
+    }, n.onerror = (s) => {
+      t && t(`Unable to load script '${e}'`, s);
+    }, i.appendChild(n);
+  }
+  /**
+   * Load an asynchronous script (identified by an url). When the url returns, the
+   * content of this file is added into a new script element, attached to the DOM (body element)
+   * @param scriptUrl defines the url of the script to laod
+   * @returns a promise request object
+   */
+  static LoadScriptAsync(e) {
+    return new Promise((o, t) => {
+      this.LoadScript(e, () => {
+        o();
+      }, (r, i) => {
+        t(i || new Error(r));
+      });
+    });
+  }
+  /**
+   * Loads a file from a blob
+   * @param fileToLoad defines the blob to use
+   * @param callback defines the callback to call when data is loaded
+   * @param progressCallback defines the callback to call during loading process
+   * @returns a file request object
+   */
+  static ReadFileAsDataURL(e, o, t) {
+    const r = new FileReader(), i = {
+      onCompleteObservable: new F(),
+      abort: () => r.abort()
+    };
+    return r.onloadend = () => {
+      i.onCompleteObservable.notifyObservers(i);
+    }, r.onload = (n) => {
+      o(n.target.result);
+    }, r.onprogress = t, r.readAsDataURL(e), i;
+  }
+  /**
+   * Reads a file from a File object
+   * @param file defines the file to load
+   * @param onSuccess defines the callback to call when data is loaded
+   * @param onProgress defines the callback to call during loading process
+   * @param useArrayBuffer defines a boolean indicating that data must be returned as an ArrayBuffer
+   * @param onError defines the callback to call when an error occurs
+   * @returns a file request object
+   */
+  static ReadFile(e, o, t, r, i) {
+    return b(e, o, t, r, i);
+  }
+  /**
+   * Creates a data url from a given string content
+   * @param content defines the content to convert
+   * @returns the new data url link
+   */
+  static FileAsURL(e) {
+    const o = new Blob([e]);
+    return window.URL.createObjectURL(o);
+  }
+  /**
+   * Format the given number to a specific decimal format
+   * @param value defines the number to format
+   * @param decimals defines the number of decimals to use
+   * @returns the formatted string
+   */
+  static Format(e, o = 2) {
+    return e.toFixed(o);
+  }
+  /**
+   * Tries to copy an object by duplicating every property
+   * @param source defines the source object
+   * @param destination defines the target object
+   * @param doNotCopyList defines a list of properties to avoid
+   * @param mustCopyList defines a list of properties to copy (even if they start with _)
+   */
+  static DeepCopy(e, o, t, r) {
+    p.DeepCopy(e, o, t, r);
+  }
+  /**
+   * Gets a boolean indicating if the given object has no own property
+   * @param obj defines the object to test
+   * @returns true if object has no own property
+   */
+  static IsEmpty(e) {
+    for (const o in e)
+      if (Object.prototype.hasOwnProperty.call(e, o))
+        return !1;
+    return !0;
+  }
+  /**
+   * Function used to register events at window level
+   * @param windowElement defines the Window object to use
+   * @param events defines the events to register
+   */
+  static RegisterTopRootEvents(e, o) {
+    for (let t = 0; t < o.length; t++) {
+      const r = o[t];
+      e.addEventListener(r.name, r.handler, !1);
+      try {
+        window.parent && window.parent.addEventListener(r.name, r.handler, !1);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Function used to unregister events from window level
+   * @param windowElement defines the Window object to use
+   * @param events defines the events to unregister
+   */
+  static UnregisterTopRootEvents(e, o) {
+    for (let t = 0; t < o.length; t++) {
+      const r = o[t];
+      e.removeEventListener(r.name, r.handler);
+      try {
+        e.parent && e.parent.removeEventListener(r.name, r.handler);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Dumps the current bound framebuffer
+   * @param width defines the rendering width
+   * @param height defines the rendering height
+   * @param engine defines the hosting engine
+   * @param successCallback defines the callback triggered once the data are available
+   * @param mimeType defines the mime type of the result
+   * @param fileName defines the filename to download. If present, the result will automatically be downloaded
+   * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.
+   * @returns a void promise
+   */
+  static async DumpFramebuffer(e, o, t, r, i = "image/png", n, s) {
+    throw g("DumpTools");
+  }
+  /**
+   * Dumps an array buffer
+   * @param width defines the rendering width
+   * @param height defines the rendering height
+   * @param data the data array
+   * @param successCallback defines the callback triggered once the data are available
+   * @param mimeType defines the mime type of the result
+   * @param fileName defines the filename to download. If present, the result will automatically be downloaded
+   * @param invertY true to invert the picture in the Y dimension
+   * @param toArrayBuffer true to convert the data to an ArrayBuffer (encoded as `mimeType`) instead of a base64 string
+   * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.
+   */
+  static DumpData(e, o, t, r, i = "image/png", n, s = !1, K = !1, l) {
+    throw g("DumpTools");
+  }
+  /**
+   * Dumps an array buffer
+   * @param width defines the rendering width
+   * @param height defines the rendering height
+   * @param data the data array
+   * @param mimeType defines the mime type of the result
+   * @param fileName defines the filename to download. If present, the result will automatically be downloaded
+   * @param invertY true to invert the picture in the Y dimension
+   * @param toArrayBuffer true to convert the data to an ArrayBuffer (encoded as `mimeType`) instead of a base64 string
+   * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.
+   * @returns a promise that resolve to the final data
+   */
+  static DumpDataAsync(e, o, t, r = "image/png", i, n = !1, s = !1, K) {
+    throw g("DumpTools");
+  }
+  static _IsOffScreenCanvas(e) {
+    return e.convertToBlob !== void 0;
+  }
+  /**
+   * Converts the canvas data to blob.
+   * This acts as a polyfill for browsers not supporting the to blob function.
+   * @param canvas Defines the canvas to extract the data from (can be an offscreen canvas)
+   * @param successCallback Defines the callback triggered once the data are available
+   * @param mimeType Defines the mime type of the result
+   * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.
+   */
+  static ToBlob(e, o, t = "image/png", r) {
+    !a._IsOffScreenCanvas(e) && !e.toBlob && (e.toBlob = function(i, n, s) {
+      setTimeout(() => {
+        const K = atob(this.toDataURL(n, s).split(",")[1]), l = K.length, A = new Uint8Array(l);
+        for (let u = 0; u < l; u++)
+          A[u] = K.charCodeAt(u);
+        i(new Blob([A]));
+      });
+    }), a._IsOffScreenCanvas(e) ? e.convertToBlob({
+      type: t,
+      quality: r
+    }).then((i) => o(i)) : e.toBlob(function(i) {
+      o(i);
+    }, t, r);
+  }
+  /**
+   * Download a Blob object
+   * @param blob the Blob object
+   * @param fileName the file name to download
+   * @returns
+   */
+  static DownloadBlob(e, o) {
+    if ("download" in document.createElement("a")) {
+      if (!o) {
+        const t = /* @__PURE__ */ new Date();
+        o = "screenshot_" + ((t.getFullYear() + "-" + (t.getMonth() + 1)).slice(2) + "-" + t.getDate() + "_" + t.getHours() + "-" + ("0" + t.getMinutes()).slice(-2)) + ".png";
+      }
+      a.Download(e, o);
+    } else if (e && typeof URL < "u") {
+      const t = URL.createObjectURL(e), r = window.open("");
+      if (!r)
+        return;
+      const i = r.document.createElement("img");
+      i.onload = function() {
+        URL.revokeObjectURL(t);
+      }, i.src = t, r.document.body.appendChild(i);
+    }
+  }
+  /**
+   * Encodes the canvas data to base 64, or automatically downloads the result if `fileName` is defined.
+   * @param canvas The canvas to get the data from, which can be an offscreen canvas.
+   * @param successCallback The callback which is triggered once the data is available. If `fileName` is defined, the callback will be invoked after the download occurs, and the `data` argument will be an empty string.
+   * @param mimeType The mime type of the result.
+   * @param fileName The name of the file to download. If defined, the result will automatically be downloaded. If not defined, and `successCallback` is also not defined, the result will automatically be downloaded with an auto-generated file name.
+   * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.
+   */
+  static EncodeScreenshotCanvasData(e, o, t = "image/png", r, i) {
+    if (typeof r == "string" || !o)
+      this.ToBlob(e, function(n) {
+        n && a.DownloadBlob(n, r), o && o("");
+      }, t, i);
+    else if (o) {
+      if (a._IsOffScreenCanvas(e)) {
+        e.convertToBlob({
+          type: t,
+          quality: i
+        }).then((s) => {
+          const K = new FileReader();
+          K.readAsDataURL(s), K.onloadend = () => {
+            const l = K.result;
+            o(l);
+          };
+        });
+        return;
+      }
+      const n = e.toDataURL(t, i);
+      o(n);
+    }
+  }
+  /**
+   * Downloads a blob in the browser
+   * @param blob defines the blob to download
+   * @param fileName defines the name of the downloaded file
+   */
+  static Download(e, o) {
+    if (typeof URL > "u")
+      return;
+    const t = window.URL.createObjectURL(e), r = document.createElement("a");
+    document.body.appendChild(r), r.style.display = "none", r.href = t, r.download = o, r.addEventListener("click", () => {
+      r.parentElement && r.parentElement.removeChild(r);
+    }), r.click(), window.URL.revokeObjectURL(t);
+  }
+  /**
+   * Will return the right value of the noPreventDefault variable
+   * Needed to keep backwards compatibility to the old API.
+   *
+   * @param args arguments passed to the attachControl function
+   * @returns the correct value for noPreventDefault
+   */
+  static BackCompatCameraNoPreventDefault(e) {
+    return typeof e[0] == "boolean" ? e[0] : typeof e[1] == "boolean" ? e[1] : !1;
+  }
+  /**
+   * Captures a screenshot of the current rendering
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/renderToPNG
+   * @param engine defines the rendering engine
+   * @param camera defines the source camera
+   * @param size This parameter can be set to a single number or to an object with the
+   * following (optional) properties: precision, width, height. If a single number is passed,
+   * it will be used for both width and height. If an object is passed, the screenshot size
+   * will be derived from the parameters. The precision property is a multiplier allowing
+   * rendering at a higher or lower resolution
+   * @param successCallback defines the callback receives a single parameter which contains the
+   * screenshot as a string of base64-encoded characters. This string can be assigned to the
+   * src parameter of an <img> to display it
+   * @param mimeType defines the MIME type of the screenshot image (default: image/png).
+   * Check your browser for supported MIME types
+   * @param forceDownload force the system to download the image even if a successCallback is provided
+   * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  static CreateScreenshot(e, o, t, r, i = "image/png", n = !1, s) {
+    throw g("ScreenshotTools");
+  }
+  /**
+   * Captures a screenshot of the current rendering
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/renderToPNG
+   * @param engine defines the rendering engine
+   * @param camera defines the source camera
+   * @param size This parameter can be set to a single number or to an object with the
+   * following (optional) properties: precision, width, height. If a single number is passed,
+   * it will be used for both width and height. If an object is passed, the screenshot size
+   * will be derived from the parameters. The precision property is a multiplier allowing
+   * rendering at a higher or lower resolution
+   * @param mimeType defines the MIME type of the screenshot image (default: image/png).
+   * Check your browser for supported MIME types
+   * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.
+   * @returns screenshot as a string of base64-encoded characters. This string can be assigned
+   * to the src parameter of an <img> to display it
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  static CreateScreenshotAsync(e, o, t, r = "image/png", i) {
+    throw g("ScreenshotTools");
+  }
+  /**
+   * Generates an image screenshot from the specified camera.
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/renderToPNG
+   * @param engine The engine to use for rendering
+   * @param camera The camera to use for rendering
+   * @param size This parameter can be set to a single number or to an object with the
+   * following (optional) properties: precision, width, height. If a single number is passed,
+   * it will be used for both width and height. If an object is passed, the screenshot size
+   * will be derived from the parameters. The precision property is a multiplier allowing
+   * rendering at a higher or lower resolution
+   * @param successCallback The callback receives a single parameter which contains the
+   * screenshot as a string of base64-encoded characters. This string can be assigned to the
+   * src parameter of an <img> to display it
+   * @param mimeType The MIME type of the screenshot image (default: image/png).
+   * Check your browser for supported MIME types
+   * @param samples Texture samples (default: 1)
+   * @param antialiasing Whether antialiasing should be turned on or not (default: false)
+   * @param fileName A name for for the downloaded file.
+   * @param renderSprites Whether the sprites should be rendered or not (default: false)
+   * @param enableStencilBuffer Whether the stencil buffer should be enabled or not (default: false)
+   * @param useLayerMask if the camera's layer mask should be used to filter what should be rendered (default: true)
+   * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  static CreateScreenshotUsingRenderTarget(e, o, t, r, i = "image/png", n = 1, s = !1, K, l = !1, A = !1, u = !0, q) {
+    throw g("ScreenshotTools");
+  }
+  /**
+   * Generates an image screenshot from the specified camera.
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/renderToPNG
+   * @param engine The engine to use for rendering
+   * @param camera The camera to use for rendering
+   * @param size This parameter can be set to a single number or to an object with the
+   * following (optional) properties: precision, width, height. If a single number is passed,
+   * it will be used for both width and height. If an object is passed, the screenshot size
+   * will be derived from the parameters. The precision property is a multiplier allowing
+   * rendering at a higher or lower resolution
+   * @param mimeType The MIME type of the screenshot image (default: image/png).
+   * Check your browser for supported MIME types
+   * @param samples Texture samples (default: 1)
+   * @param antialiasing Whether antialiasing should be turned on or not (default: false)
+   * @param fileName A name for for the downloaded file.
+   * @returns screenshot as a string of base64-encoded characters. This string can be assigned
+   * @param renderSprites Whether the sprites should be rendered or not (default: false)
+   * @param enableStencilBuffer Whether the stencil buffer should be enabled or not (default: false)
+   * @param useLayerMask if the camera's layer mask should be used to filter what should be rendered (default: true)
+   * @param quality The quality of the image if lossy mimeType is used (e.g. image/jpeg, image/webp). See {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement/toBlob | HTMLCanvasElement.toBlob()}'s `quality` parameter.
+   * to the src parameter of an <img> to display it
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  static CreateScreenshotUsingRenderTargetAsync(e, o, t, r = "image/png", i = 1, n = !1, s, K = !1, l = !1, A = !0, u) {
+    throw g("ScreenshotTools");
+  }
+  /**
+   * Implementation from http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#answer-2117523
+   * Be aware Math.random() could cause collisions, but:
+   * "All but 6 of the 128 bits of the ID are randomly generated, which means that for any two ids, there's a 1 in 2^^122 (or 5.3x10^^36) chance they'll collide"
+   * @returns a pseudo random id
+   */
+  static RandomId() {
+    return R();
+  }
+  /**
+   * Test if the given uri is a base64 string
+   * @deprecated Please use FileTools.IsBase64DataUrl instead.
+   * @param uri The uri to test
+   * @returns True if the uri is a base64 string or false otherwise
+   */
+  static IsBase64(e) {
+    return y(e);
+  }
+  /**
+   * Decode the given base64 uri.
+   * @deprecated Please use FileTools.DecodeBase64UrlToBinary instead.
+   * @param uri The uri to decode
+   * @returns The decoded base64 data.
+   */
+  static DecodeBase64(e) {
+    return D(e);
+  }
+  /**
+   * Gets a value indicating the number of loading errors
+   * @ignorenaming
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static get errorsCount() {
+    return c.errorsCount;
+  }
+  /**
+   * Log a message to the console
+   * @param message defines the message to log
+   */
+  static Log(e) {
+    c.Log(e);
+  }
+  /**
+   * Write a warning message to the console
+   * @param message defines the message to log
+   */
+  static Warn(e) {
+    c.Warn(e);
+  }
+  /**
+   * Write an error message to the console
+   * @param message defines the message to log
+   */
+  static Error(e) {
+    c.Error(e);
+  }
+  /**
+   * Gets current log cache (list of logs)
+   */
+  static get LogCache() {
+    return c.LogCache;
+  }
+  /**
+   * Clears the log cache
+   */
+  static ClearLogCache() {
+    c.ClearLogCache();
+  }
+  /**
+   * Sets the current log level (MessageLogLevel / WarningLogLevel / ErrorLogLevel)
+   */
+  static set LogLevels(e) {
+    c.LogLevels = e;
+  }
+  /**
+   * Sets the current performance log level
+   */
+  static set PerformanceLogLevel(e) {
+    if ((e & a.PerformanceUserMarkLogLevel) === a.PerformanceUserMarkLogLevel) {
+      a.StartPerformanceCounter = a._StartUserMark, a.EndPerformanceCounter = a._EndUserMark;
+      return;
+    }
+    if ((e & a.PerformanceConsoleLogLevel) === a.PerformanceConsoleLogLevel) {
+      a.StartPerformanceCounter = a._StartPerformanceConsole, a.EndPerformanceCounter = a._EndPerformanceConsole;
+      return;
+    }
+    a.StartPerformanceCounter = a._StartPerformanceCounterDisabled, a.EndPerformanceCounter = a._EndPerformanceCounterDisabled;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  static _StartPerformanceCounterDisabled(e, o) {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  static _EndPerformanceCounterDisabled(e, o) {
+  }
+  static _StartUserMark(e, o = !0) {
+    if (!a._Performance) {
+      if (!m())
+        return;
+      a._Performance = window.performance;
+    }
+    !o || !a._Performance.mark || a._Performance.mark(e + "-Begin");
+  }
+  static _EndUserMark(e, o = !0) {
+    !o || !a._Performance.mark || (a._Performance.mark(e + "-End"), a._Performance.measure(e, e + "-Begin", e + "-End"));
+  }
+  static _StartPerformanceConsole(e, o = !0) {
+    o && (a._StartUserMark(e, o), console.time && console.time(e));
+  }
+  static _EndPerformanceConsole(e, o = !0) {
+    o && (a._EndUserMark(e, o), console.timeEnd(e));
+  }
+  /**
+   * Gets either window.performance.now() if supported or Date.now() else
+   */
+  static get Now() {
+    return T.Now;
+  }
+  /**
+   * This method will return the name of the class used to create the instance of the given object.
+   * It will works only on Javascript basic data types (number, string, ...) and instance of class declared with the @className decorator.
+   * @param object the object to get the class name from
+   * @param isType defines if the object is actually a type
+   * @returns the name of the class, will be "object" for a custom data type not using the @className decorator
+   */
+  static GetClassName(e, o = !1) {
+    let t = null;
+    return !o && e.getClassName ? t = e.getClassName() : (e instanceof Object && (t = (o ? e : Object.getPrototypeOf(e)).constructor.__bjsclassName__), t || (t = typeof e)), t;
+  }
+  /**
+   * Gets the first element of an array satisfying a given predicate
+   * @param array defines the array to browse
+   * @param predicate defines the predicate to use
+   * @returns null if not found or the element
+   */
+  static First(e, o) {
+    for (const t of e)
+      if (o(t))
+        return t;
+    return null;
+  }
+  /**
+   * This method will return the name of the full name of the class, including its owning module (if any).
+   * It will works only on Javascript basic data types (number, string, ...) and instance of class declared with the @className decorator or implementing a method getClassName():string (in which case the module won't be specified).
+   * @param object the object to get the class name from
+   * @param isType defines if the object is actually a type
+   * @returns a string that can have two forms: "moduleName.className" if module was specified when the class' Name was registered or "className" if there was not module specified.
+   * @ignorenaming
+   */
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  static getFullClassName(e, o = !1) {
+    let t = null, r = null;
+    if (!o && e.getClassName)
+      t = e.getClassName();
+    else {
+      if (e instanceof Object) {
+        const i = o ? e : Object.getPrototypeOf(e);
+        t = i.constructor.__bjsclassName__, r = i.constructor.__bjsmoduleName__;
+      }
+      t || (t = typeof e);
+    }
+    return t ? (r != null ? r + "." : "") + t : null;
+  }
+  /**
+   * Returns a promise that resolves after the given amount of time.
+   * @param delay Number of milliseconds to delay
+   * @returns Promise that resolves after the given amount of time
+   */
+  static DelayAsync(e) {
+    return new Promise((o) => {
+      setTimeout(() => {
+        o();
+      }, e);
+    });
+  }
+  /**
+   * Utility function to detect if the current user agent is Safari
+   * @returns whether or not the current user agent is safari
+   */
+  static IsSafari() {
+    return C() ? /^((?!chrome|android).)*safari/i.test(navigator.userAgent) : !1;
+  }
+}
+a.UseCustomRequestHeaders = !1;
+a.CustomRequestHeaders = L.CustomRequestHeaders;
+a._TmpFloatArray = new Float32Array(1);
+a.GetDOMTextContent = B;
+a.GetAbsoluteUrl = typeof document == "object" ? (d) => {
+  const e = document.createElement("a");
+  return e.href = d, e.href;
+} : typeof URL == "function" && typeof location == "object" ? (d) => new URL(d, location.origin).href : () => {
+  throw new Error("Unable to get absolute URL. Override BABYLON.Tools.GetAbsoluteUrl to a custom implementation for the current context.");
+};
+a.NoneLogLevel = c.NoneLogLevel;
+a.MessageLogLevel = c.MessageLogLevel;
+a.WarningLogLevel = c.WarningLogLevel;
+a.ErrorLogLevel = c.ErrorLogLevel;
+a.AllLogLevel = c.AllLogLevel;
+a.IsWindowObjectExist = m;
+a.PerformanceNoneLogLevel = 0;
+a.PerformanceUserMarkLogLevel = 1;
+a.PerformanceConsoleLogLevel = 2;
+a.StartPerformanceCounter = a._StartPerformanceCounterDisabled;
+a.EndPerformanceCounter = a._EndPerformanceCounterDisabled;
+class h {
+  /**
+   * Constructor.
+   * @param iterations the number of iterations.
+   * @param func the function to run each iteration
+   * @param successCallback the callback that will be called upon successful execution
+   * @param offset starting offset.
+   */
+  constructor(e, o, t, r = 0) {
+    this.iterations = e, this.index = r - 1, this._done = !1, this._fn = o, this._successCallback = t;
+  }
+  /**
+   * Execute the next iteration. Must be called after the last iteration was finished.
+   */
+  executeNext() {
+    this._done || (this.index + 1 < this.iterations ? (++this.index, this._fn(this)) : this.breakLoop());
+  }
+  /**
+   * Break the loop and run the success callback.
+   */
+  breakLoop() {
+    this._done = !0, this._successCallback();
+  }
+  /**
+   * Create and run an async loop.
+   * @param iterations the number of iterations.
+   * @param fn the function to run each iteration
+   * @param successCallback the callback that will be called upon successful execution
+   * @param offset starting offset.
+   * @returns the created async loop object
+   */
+  static Run(e, o, t, r = 0) {
+    const i = new h(e, o, t, r);
+    return i.executeNext(), i;
+  }
+  /**
+   * A for-loop that will run a given number of iterations synchronous and the rest async.
+   * @param iterations total number of iterations
+   * @param syncedIterations number of synchronous iterations in each async iteration.
+   * @param fn the function to call each iteration.
+   * @param callback a success call back that will be called when iterating stops.
+   * @param breakFunction a break condition (optional)
+   * @param timeout timeout settings for the setTimeout function. default - 0.
+   * @returns the created async loop object
+   */
+  static SyncAsyncForLoop(e, o, t, r, i, n = 0) {
+    return h.Run(Math.ceil(e / o), (s) => {
+      i && i() ? s.breakLoop() : setTimeout(() => {
+        for (let K = 0; K < o; ++K) {
+          const l = s.index * o + K;
+          if (l >= e)
+            break;
+          if (t(l), i && i()) {
+            s.breakLoop();
+            break;
+          }
+        }
+        s.executeNext();
+      }, n);
+    }, r);
+  }
+}
+P.FallbackTexture = "data:image/jpg;base64,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";
+export {
+  h as AsyncLoop,
+  a as Tools
+};