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

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

@@ -0,0 +1,187 @@
+import { Tools as D } from "./tools.esm.js";
+import { Vector3 as f } from "../Maths/math.vector.esm.js";
+import { Scalar as S } from "../Maths/math.scalar.esm.js";
+import { SphericalPolynomial as O } from "../Maths/sphericalPolynomial.esm.js";
+import { InternalTexture as U, InternalTextureSource as B } from "../Materials/Textures/internalTexture.esm.js";
+import { BaseTexture as E } from "../Materials/Textures/baseTexture.esm.js";
+import "../scene.esm.js";
+import { PostProcess as z } from "../PostProcesses/postProcess.esm.js";
+import { Logger as G } from "./logger.esm.js";
+import "../Shaders/rgbdDecode.fragment.esm.js";
+import "../Engines/Extensions/engine.renderTarget.esm.js";
+import "../Materials/Textures/texture.esm.js";
+import "../Materials/Textures/renderTargetTexture.esm.js";
+import "../PostProcesses/passPostProcess.esm.js";
+import "../Engines/Extensions/engine.renderTargetCube.esm.js";
+import "../Engines/Extensions/engine.readTexture.esm.js";
+import "../Materials/Textures/baseTexture.polynomial.esm.js";
+import "../Shaders/rgbdEncode.fragment.esm.js";
+import "./dumpTools.esm.js";
+const C = "image/png", M = 2, v = [134, 22, 135, 150, 246, 214, 150, 54];
+function ae(e) {
+  const o = new DataView(e.buffer, e.byteOffset, e.byteLength);
+  let t = 0;
+  for (let s = 0; s < v.length; s++)
+    if (o.getUint8(t++) !== v[s])
+      return G.Error("Not a babylon environment map"), null;
+  let r = "", a = 0;
+  for (; a = o.getUint8(t++); )
+    r += String.fromCharCode(a);
+  let n = JSON.parse(r);
+  return n = L(n), n.specular && (n.specular.specularDataPosition = t, n.specular.lodGenerationScale = n.specular.lodGenerationScale || 0.8), n;
+}
+function L(e) {
+  if (e.version > M)
+    throw new Error(`Unsupported babylon environment map version "${e.version}". Latest supported version is "${M}".`);
+  return e.version === 2 || (e = Object.assign(Object.assign({}, e), { version: 2, imageType: C })), e;
+}
+function P(e, o) {
+  o = L(o);
+  const t = o.specular;
+  let r = S.Log2(o.width);
+  if (r = Math.round(r) + 1, t.mipmaps.length !== 6 * r)
+    throw new Error(`Unsupported specular mipmaps number "${t.mipmaps.length}"`);
+  const a = new Array(r);
+  for (let n = 0; n < r; n++) {
+    a[n] = new Array(6);
+    for (let s = 0; s < 6; s++) {
+      const c = t.mipmaps[n * 6 + s];
+      a[n][s] = new Uint8Array(e.buffer, e.byteOffset + t.specularDataPosition + c.position, c.length);
+    }
+  }
+  return a;
+}
+function se(e, o, t) {
+  t = L(t);
+  const r = t.specular;
+  if (!r)
+    return Promise.resolve();
+  e._lodGenerationScale = r.lodGenerationScale;
+  const a = P(o, t);
+  return I(e, a, t.imageType);
+}
+function F(e, o, t, r, a, n, s, c, y, h, g) {
+  return new Promise((w, i) => {
+    if (t) {
+      const l = o.createTexture(null, !0, !0, null, 1, null, (p) => {
+        i(p);
+      }, e);
+      r.getEffect().executeWhenCompiled(() => {
+        r.externalTextureSamplerBinding = !0, r.onApply = (p) => {
+          p._bindTexture("textureSampler", l), p.setFloat2("scale", 1, o._features.needsInvertingBitmap && e instanceof ImageBitmap ? -1 : 1);
+        }, o.scenes.length && (o.scenes[0].postProcessManager.directRender([r], h, !0, n, s), o.restoreDefaultFramebuffer(), l.dispose(), URL.revokeObjectURL(a), w());
+      });
+    } else {
+      if (o._uploadImageToTexture(g, e, n, s), c) {
+        const l = y[s];
+        l && o._uploadImageToTexture(l._texture, e, n, 0);
+      }
+      w();
+    }
+  });
+}
+function I(e, o, t = C) {
+  if (!D.IsExponentOfTwo(e.width))
+    throw new Error("Texture size must be a power of two");
+  const r = S.ILog2(e.width) + 1, a = e.getEngine();
+  let n = !1, s = !1, c = null, y = null, h = null;
+  const g = a.getCaps();
+  if (e.format = 5, e.type = 0, e.generateMipMaps = !0, e._cachedAnisotropicFilteringLevel = null, a.updateTextureSamplingMode(3, e), g.textureLOD ? a._features.supportRenderAndCopyToLodForFloatTextures ? g.textureHalfFloatRender && g.textureHalfFloatLinearFiltering ? (n = !0, e.type = 2) : g.textureFloatRender && g.textureFloatLinearFiltering && (n = !0, e.type = 1) : n = !1 : (n = !1, s = !0, h = {}), n)
+    c = new z("rgbdDecode", "rgbdDecode", null, null, 1, null, 3, a, !1, void 0, e.type, void 0, null, !1), e._isRGBD = !1, e.invertY = !1, y = a.createRenderTargetCubeTexture(e.width, {
+      generateDepthBuffer: !1,
+      generateMipMaps: !0,
+      generateStencilBuffer: !1,
+      samplingMode: 3,
+      type: e.type,
+      format: 5
+    });
+  else if (e._isRGBD = !0, e.invertY = !0, s) {
+    const l = e._lodGenerationScale, p = e._lodGenerationOffset;
+    for (let m = 0; m < 3; m++) {
+      const T = 1 - m / 2, u = p, x = (r - 1) * l + p, A = u + (x - u) * T, b = Math.round(Math.min(Math.max(A, 0), x)), R = new U(a, B.Temp);
+      R.isCube = !0, R.invertY = !0, R.generateMipMaps = !1, a.updateTextureSamplingMode(2, R);
+      const _ = new E(null);
+      switch (_._isCube = !0, _._texture = R, h[b] = _, m) {
+        case 0:
+          e._lodTextureLow = _;
+          break;
+        case 1:
+          e._lodTextureMid = _;
+          break;
+        case 2:
+          e._lodTextureHigh = _;
+          break;
+      }
+    }
+  }
+  const w = [];
+  for (let i = 0; i < o.length; i++)
+    for (let l = 0; l < 6; l++) {
+      const p = o[i][l], m = new Blob([p], { type: t }), d = URL.createObjectURL(m);
+      let T;
+      if (typeof Image > "u" || a._features.forceBitmapOverHTMLImageElement)
+        T = a.createImageBitmap(m, { premultiplyAlpha: "none" }).then((u) => F(u, a, n, c, d, l, i, s, h, y, e));
+      else {
+        const u = new Image();
+        u.src = d, T = new Promise((x, A) => {
+          u.onload = () => {
+            F(u, a, n, c, d, l, i, s, h, y, e).then(() => x()).catch((b) => {
+              A(b);
+            });
+          }, u.onerror = (b) => {
+            A(b);
+          };
+        });
+      }
+      w.push(T);
+    }
+  if (o.length < r) {
+    let i;
+    const l = Math.pow(2, r - 1 - o.length), p = l * l * 4;
+    switch (e.type) {
+      case 0: {
+        i = new Uint8Array(p);
+        break;
+      }
+      case 2: {
+        i = new Uint16Array(p);
+        break;
+      }
+      case 1: {
+        i = new Float32Array(p);
+        break;
+      }
+    }
+    for (let m = o.length; m < r; m++)
+      for (let d = 0; d < 6; d++)
+        a._uploadArrayBufferViewToTexture(e, i, d, m);
+  }
+  return Promise.all(w).then(() => {
+    y && (a._releaseTexture(e), y._swapAndDie(e)), c && c.dispose(), s && (e._lodTextureHigh && e._lodTextureHigh._texture && (e._lodTextureHigh._texture.isReady = !0), e._lodTextureMid && e._lodTextureMid._texture && (e._lodTextureMid._texture.isReady = !0), e._lodTextureLow && e._lodTextureLow._texture && (e._lodTextureLow._texture.isReady = !0));
+  });
+}
+function le(e, o) {
+  o = L(o);
+  const t = o.irradiance;
+  if (!t)
+    return;
+  const r = new O();
+  f.FromArrayToRef(t.x, 0, r.x), f.FromArrayToRef(t.y, 0, r.y), f.FromArrayToRef(t.z, 0, r.z), f.FromArrayToRef(t.xx, 0, r.xx), f.FromArrayToRef(t.yy, 0, r.yy), f.FromArrayToRef(t.zz, 0, r.zz), f.FromArrayToRef(t.yz, 0, r.yz), f.FromArrayToRef(t.zx, 0, r.zx), f.FromArrayToRef(t.xy, 0, r.xy), e._sphericalPolynomial = r;
+}
+function ie(e, o, t, r, a) {
+  const n = e.getEngine().createRawCubeTexture(null, e.width, e.format, e.type, e.generateMipMaps, e.invertY, e.samplingMode, e._compression), s = I(n, o).then(() => e);
+  return e.onRebuildCallback = (c) => ({
+    proxy: s,
+    isReady: !0,
+    isAsync: !0
+  }), e._source = B.CubeRawRGBD, e._bufferViewArrayArray = o, e._lodGenerationScale = r, e._lodGenerationOffset = a, e._sphericalPolynomial = t, I(e, o).then(() => (e.isReady = !0, e));
+}
+export {
+  P as CreateImageDataArrayBufferViews,
+  ae as GetEnvInfo,
+  se as UploadEnvLevelsAsync,
+  le as UploadEnvSpherical,
+  I as UploadLevelsAsync,
+  ie as _UpdateRGBDAsync,
+  L as normalizeEnvInfo
+};

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

@@ -0,0 +1,40 @@
+class o extends Error {
+}
+o._setPrototypeOf = Object.setPrototypeOf || ((r, e) => (r.__proto__ = e, r));
+const i = {
+  // Mesh errors 0-999
+  /** Invalid or empty mesh vertex positions. */
+  MeshInvalidPositionsError: 0,
+  // Texture errors 1000-1999
+  /** Unsupported texture found. */
+  UnsupportedTextureError: 1e3,
+  // GLTFLoader errors 2000-2999
+  /** Unexpected magic number found in GLTF file header. */
+  GLTFLoaderUnexpectedMagicError: 2e3,
+  // SceneLoader errors 3000-3999
+  /** SceneLoader generic error code. Ideally wraps the inner exception. */
+  SceneLoaderError: 3e3,
+  // File related errors 4000-4999
+  /** Load file error */
+  LoadFileError: 4e3,
+  /** Request file error */
+  RequestFileError: 4001,
+  /** Read file error */
+  ReadFileError: 4002
+};
+class t extends o {
+  /**
+   * Creates a new RuntimeError
+   * @param message defines the message of the error
+   * @param errorCode the error code
+   * @param innerError the error that caused the outer error
+   */
+  constructor(e, s, n) {
+    super(e), this.errorCode = s, this.innerError = n, this.name = "RuntimeError", o._setPrototypeOf(this, t.prototype);
+  }
+}
+export {
+  o as BaseError,
+  i as ErrorCodes,
+  t as RuntimeError
+};

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

@@ -0,0 +1,339 @@
+import { WebRequest as F } from "./webRequest.esm.js";
+import { IsWindowObjectExist as Z } from "./domManagement.esm.js";
+import { Observable as j } from "./observable.esm.js";
+import { FilesInputStore as w } from "./filesInputStore.esm.js";
+import { RetryStrategy as P } from "./retryStrategy.esm.js";
+import { RuntimeError as I, ErrorCodes as H, BaseError as q } from "./error.esm.js";
+import { EncodeArrayBufferToBase64 as ee, DecodeBase64ToBinary as te, DecodeBase64ToString as re } from "./stringTools.esm.js";
+import { ShaderProcessor as ne } from "../Engines/Processors/shaderProcessor.esm.js";
+import { ThinEngine as _ } from "../Engines/thinEngine.esm.js";
+import { EngineStore as $ } from "../Engines/engineStore.esm.js";
+import { Logger as N } from "./logger.esm.js";
+import { TimingTools as se } from "./timingTools.esm.js";
+const M = new RegExp(/^data:([^,]+\/[^,]+)?;base64,/i);
+class x extends I {
+  /**
+   * Creates a new LoadFileError
+   * @param message defines the message of the error
+   * @param object defines the optional web request
+   */
+  constructor(a, r) {
+    super(a, H.LoadFileError), this.name = "LoadFileError", q._setPrototypeOf(this, x.prototype), r instanceof F ? this.request = r : this.file = r;
+  }
+}
+class S extends I {
+  /**
+   * Creates a new LoadFileError
+   * @param message defines the message of the error
+   * @param request defines the optional web request
+   */
+  constructor(a, r) {
+    super(a, H.RequestFileError), this.request = r, this.name = "RequestFileError", q._setPrototypeOf(this, S.prototype);
+  }
+}
+class k extends I {
+  /**
+   * Creates a new ReadFileError
+   * @param message defines the message of the error
+   * @param file defines the optional file
+   */
+  constructor(a, r) {
+    super(a, H.ReadFileError), this.file = r, this.name = "ReadFileError", q._setPrototypeOf(this, k.prototype);
+  }
+}
+const y = {
+  /**
+   * Gets or sets the retry strategy to apply when an error happens while loading an asset.
+   * When defining this function, return the wait time before trying again or return -1 to
+   * stop retrying and error out.
+   */
+  DefaultRetryStrategy: P.ExponentialBackoff(),
+  /**
+   * Gets or sets the base URL to use to load assets
+   */
+  BaseUrl: "",
+  /**
+   * 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)
+   */
+  CorsBehavior: "anonymous",
+  /**
+   * Gets or sets a function used to pre-process url before using them to load assets
+   * @param url
+   */
+  PreprocessUrl: (t) => t
+}, A = (t) => (t = t.replace(/#/gm, "%23"), t), W = (t, a) => {
+  if (!(t && t.indexOf("data:") === 0) && y.CorsBehavior)
+    if (typeof y.CorsBehavior == "string" || y.CorsBehavior instanceof String)
+      a.crossOrigin = y.CorsBehavior;
+    else {
+      const r = y.CorsBehavior(t);
+      r && (a.crossOrigin = r);
+    }
+}, X = (t, a, r, c, f = "", o) => {
+  var b;
+  let s, d = !1;
+  t instanceof ArrayBuffer || ArrayBuffer.isView(t) ? typeof Blob < "u" && typeof URL < "u" ? (s = URL.createObjectURL(new Blob([t], { type: f })), d = !0) : s = `data:${f};base64,` + ee(t) : t instanceof Blob ? (s = URL.createObjectURL(t), d = !0) : (s = A(t), s = y.PreprocessUrl(t));
+  const p = $.LastCreatedEngine, n = (i) => {
+    if (r) {
+      const l = s || t.toString();
+      r(`Error while trying to load image: ${l.indexOf("http") === 0 || l.length <= 128 ? l : l.slice(0, 128) + "..."}`, i);
+    }
+  };
+  if (typeof Image > "u" || (b = p == null ? void 0 : p._features.forceBitmapOverHTMLImageElement) !== null && b !== void 0 && b)
+    return B(s, (i) => {
+      p.createImageBitmap(new Blob([i], { type: f }), Object.assign({ premultiplyAlpha: "none" }, o)).then((l) => {
+        a(l), d && URL.revokeObjectURL(s);
+      }).catch((l) => {
+        r && r("Error while trying to load image: " + t, l);
+      });
+    }, void 0, c || void 0, !0, (i, l) => {
+      n(l);
+    }), null;
+  const e = new Image();
+  W(s, e);
+  const m = [], u = () => {
+    m.forEach((i) => {
+      i.target.addEventListener(i.name, i.handler);
+    });
+  }, h = () => {
+    m.forEach((i) => {
+      i.target.removeEventListener(i.name, i.handler);
+    }), m.length = 0;
+  }, L = () => {
+    h(), a(e), d && e.src && URL.revokeObjectURL(e.src);
+  }, O = (i) => {
+    h(), n(i), d && e.src && URL.revokeObjectURL(e.src);
+  }, C = (i) => {
+    if (i.blockedURI !== e.src)
+      return;
+    h();
+    const l = new Error(`CSP violation of policy ${i.effectiveDirective} ${i.blockedURI}. Current policy is ${i.originalPolicy}`);
+    $.UseFallbackTexture = !1, n(l), d && e.src && URL.revokeObjectURL(e.src), e.src = "";
+  };
+  m.push({ target: e, name: "load", handler: L }), m.push({ target: e, name: "error", handler: O }), m.push({ target: document, name: "securitypolicyviolation", handler: C }), u();
+  const R = s.substring(0, 5) === "blob:", g = s.substring(0, 5) === "data:", E = () => {
+    R || g ? e.src = s : B(s, (i, l, D) => {
+      const K = !f && D ? D : f, Q = new Blob([i], { type: K }), Y = URL.createObjectURL(Q);
+      d = !0, e.src = Y;
+    }, void 0, c || void 0, !0, (i, l) => {
+      n(l);
+    });
+  }, U = () => {
+    c && c.loadImage(s, e);
+  };
+  if (!R && !g && c && c.enableTexturesOffline)
+    c.open(U, E);
+  else {
+    if (s.indexOf("file:") !== -1) {
+      const i = decodeURIComponent(s.substring(5).toLowerCase());
+      if (w.FilesToLoad[i] && typeof URL < "u") {
+        try {
+          let l;
+          try {
+            l = URL.createObjectURL(w.FilesToLoad[i]);
+          } catch {
+            l = URL.createObjectURL(w.FilesToLoad[i]);
+          }
+          e.src = l, d = !0;
+        } catch {
+          e.src = "";
+        }
+        return e;
+      }
+    }
+    E();
+  }
+  return e;
+}, T = (t, a, r, c, f) => {
+  const o = new FileReader(), b = {
+    onCompleteObservable: new j(),
+    abort: () => o.abort()
+  };
+  return o.onloadend = () => b.onCompleteObservable.notifyObservers(b), f && (o.onerror = () => {
+    f(new k(`Unable to read ${t.name}`, t));
+  }), o.onload = (s) => {
+    a(s.target.result);
+  }, r && (o.onprogress = r), c ? o.readAsArrayBuffer(t) : o.readAsText(t), b;
+}, B = (t, a, r, c, f, o, b) => {
+  if (t.name)
+    return T(t, a, r, f, o ? (n) => {
+      o(void 0, n);
+    } : void 0);
+  const s = t;
+  if (s.indexOf("file:") !== -1) {
+    let n = decodeURIComponent(s.substring(5).toLowerCase());
+    n.indexOf("./") === 0 && (n = n.substring(2));
+    const e = w.FilesToLoad[n];
+    if (e)
+      return T(e, a, r, f, o ? (m) => o(void 0, new x(m.message, m.file)) : void 0);
+  }
+  const { match: d, type: p } = oe(s);
+  if (d) {
+    const n = {
+      onCompleteObservable: new j(),
+      abort: () => () => {
+      }
+    };
+    try {
+      const e = f ? z(s) : J(s);
+      a(e, void 0, p);
+    } catch (e) {
+      o ? o(void 0, e) : N.Error(e.message || "Failed to parse the Data URL");
+    }
+    return se.SetImmediate(() => {
+      n.onCompleteObservable.notifyObservers(n);
+    }), n;
+  }
+  return G(s, (n, e) => {
+    a(n, e == null ? void 0 : e.responseURL, e == null ? void 0 : e.getResponseHeader("content-type"));
+  }, r, c, f, o ? (n) => {
+    o(n.request, new x(n.message, n.request));
+  } : void 0, b);
+}, G = (t, a, r, c, f, o, b) => {
+  t = A(t), t = y.PreprocessUrl(t);
+  const s = y.BaseUrl + t;
+  let d = !1;
+  const p = {
+    onCompleteObservable: new j(),
+    abort: () => d = !0
+  }, n = () => {
+    let e = new F(), m = null, u;
+    const h = () => {
+      e && (r && e.removeEventListener("progress", r), u && e.removeEventListener("readystatechange", u), e.removeEventListener("loadend", L));
+    };
+    let L = () => {
+      h(), p.onCompleteObservable.notifyObservers(p), p.onCompleteObservable.clear(), r = void 0, u = null, L = null, o = void 0, b = void 0, a = void 0;
+    };
+    p.abort = () => {
+      d = !0, L && L(), e && e.readyState !== (XMLHttpRequest.DONE || 4) && e.abort(), m !== null && (clearTimeout(m), m = null), e = null;
+    };
+    const O = (R) => {
+      const g = R.message || "Unknown error";
+      o && e ? o(new S(g, e)) : N.Error(g);
+    }, C = (R) => {
+      if (e) {
+        if (e.open("GET", s), b)
+          try {
+            b(e);
+          } catch (g) {
+            O(g);
+            return;
+          }
+        f && (e.responseType = "arraybuffer"), r && e.addEventListener("progress", r), L && e.addEventListener("loadend", L), u = () => {
+          if (!(d || !e) && e.readyState === (XMLHttpRequest.DONE || 4)) {
+            if (u && e.removeEventListener("readystatechange", u), e.status >= 200 && e.status < 300 || e.status === 0 && (!Z() || V())) {
+              try {
+                a && a(f ? e.response : e.responseText, e);
+              } catch (U) {
+                O(U);
+              }
+              return;
+            }
+            const g = y.DefaultRetryStrategy;
+            if (g) {
+              const U = g(s, e, R);
+              if (U !== -1) {
+                h(), e = new F(), m = setTimeout(() => C(R + 1), U);
+                return;
+              }
+            }
+            const E = new S("Error status: " + e.status + " " + e.statusText + " - Unable to load " + s, e);
+            o && o(E);
+          }
+        }, e.addEventListener("readystatechange", u), e.send();
+      }
+    };
+    C(0);
+  };
+  if (c && c.enableSceneOffline) {
+    const e = (u) => {
+      u && u.status > 400 ? o && o(u) : n();
+    }, m = () => {
+      c && c.loadFile(y.BaseUrl + t, (u) => {
+        !d && a && a(u), p.onCompleteObservable.notifyObservers(p);
+      }, r ? (u) => {
+        !d && r && r(u);
+      } : void 0, e, f);
+    };
+    c.open(m, e);
+  } else
+    n();
+  return p;
+}, V = () => typeof location < "u" && location.protocol === "file:", ae = (t) => M.test(t), oe = (t) => {
+  const a = M.exec(t);
+  return a === null || a.length === 0 ? { match: !1, type: "" } : { match: !0, type: a[0].replace("data:", "").replace("base64,", "") };
+};
+function z(t) {
+  return te(t.split(",")[1]);
+}
+const J = (t) => re(t.split(",")[1]), ie = () => {
+  _._FileToolsLoadImage = X, _._FileToolsLoadFile = B, ne._FileToolsLoadFile = B;
+};
+ie();
+let v;
+const le = (t, a, r, c, f, o, b, s, d, p) => {
+  v = {
+    DecodeBase64UrlToBinary: t,
+    DecodeBase64UrlToString: a,
+    DefaultRetryStrategy: r.DefaultRetryStrategy,
+    BaseUrl: r.BaseUrl,
+    CorsBehavior: r.CorsBehavior,
+    PreprocessUrl: r.PreprocessUrl,
+    IsBase64DataUrl: c,
+    IsFileURL: f,
+    LoadFile: o,
+    LoadImage: b,
+    ReadFile: s,
+    RequestFile: d,
+    SetCorsBehavior: p
+  }, Object.defineProperty(v, "DefaultRetryStrategy", {
+    get: function() {
+      return r.DefaultRetryStrategy;
+    },
+    set: function(n) {
+      r.DefaultRetryStrategy = n;
+    }
+  }), Object.defineProperty(v, "BaseUrl", {
+    get: function() {
+      return r.BaseUrl;
+    },
+    set: function(n) {
+      r.BaseUrl = n;
+    }
+  }), Object.defineProperty(v, "PreprocessUrl", {
+    get: function() {
+      return r.PreprocessUrl;
+    },
+    set: function(n) {
+      r.PreprocessUrl = n;
+    }
+  }), Object.defineProperty(v, "CorsBehavior", {
+    get: function() {
+      return r.CorsBehavior;
+    },
+    set: function(n) {
+      r.CorsBehavior = n;
+    }
+  });
+};
+le(z, J, y, ae, V, B, X, T, G, W);
+export {
+  z as DecodeBase64UrlToBinary,
+  J as DecodeBase64UrlToString,
+  v as FileTools,
+  y as FileToolsOptions,
+  ae as IsBase64DataUrl,
+  V as IsFileURL,
+  B as LoadFile,
+  x as LoadFileError,
+  X as LoadImage,
+  T as ReadFile,
+  k as ReadFileError,
+  G as RequestFile,
+  S as RequestFileError,
+  W as SetCorsBehavior,
+  oe as TestBase64DataUrl,
+  le as _injectLTSFileTools
+};

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

@@ -0,0 +1,6 @@
+class e {
+}
+e.FilesToLoad = {};
+export {
+  e as FilesInputStore
+};

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

@@ -0,0 +1,9 @@
+function t() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (r) => {
+    const x = Math.random() * 16 | 0;
+    return (r === "x" ? x : x & 3 | 8).toString(16);
+  });
+}
+export {
+  t as RandomGUID
+};

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

@@ -0,0 +1,26 @@
+import { Logger as o } from "./logger.esm.js";
+import { GetClass as l } from "./typeStore.esm.js";
+class a {
+  /**
+   * 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(t) {
+    if (this.RegisteredExternalClasses && this.RegisteredExternalClasses[t])
+      return this.RegisteredExternalClasses[t];
+    const r = l(t);
+    if (r)
+      return r;
+    o.Warn(t + " not found, you may have missed an import.");
+    const s = t.split(".");
+    let e = window || this;
+    for (let n = 0, i = s.length; n < i; n++)
+      e = e[s[n]];
+    return typeof e != "function" ? null : e;
+  }
+}
+a.RegisteredExternalClasses = {};
+export {
+  a as InstantiationTools
+};

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

@@ -0,0 +1,79 @@
+import { Logger as n } from "./logger.esm.js";
+class a {
+  /**
+   * Creates a new KhronosTextureContainer
+   * @param data contents of the KTX container file
+   * @param facesExpected should be either 1 or 6, based whether a cube texture or or
+   */
+  constructor(r, t) {
+    if (this.data = r, this.isInvalid = !1, !a.IsValid(r)) {
+      this.isInvalid = !0, n.Error("texture missing KTX identifier");
+      return;
+    }
+    const e = Uint32Array.BYTES_PER_ELEMENT, i = new DataView(this.data.buffer, this.data.byteOffset + 12, 13 * e), s = i.getUint32(0, !0) === 67305985;
+    if (this.glType = i.getUint32(1 * e, s), this.glTypeSize = i.getUint32(2 * e, s), this.glFormat = i.getUint32(3 * e, s), this.glInternalFormat = i.getUint32(4 * e, s), this.glBaseInternalFormat = i.getUint32(5 * e, s), this.pixelWidth = i.getUint32(6 * e, s), this.pixelHeight = i.getUint32(7 * e, s), this.pixelDepth = i.getUint32(8 * e, s), this.numberOfArrayElements = i.getUint32(9 * e, s), this.numberOfFaces = i.getUint32(10 * e, s), this.numberOfMipmapLevels = i.getUint32(11 * e, s), this.bytesOfKeyValueData = i.getUint32(12 * e, s), this.glType !== 0) {
+      n.Error("only compressed formats currently supported"), this.isInvalid = !0;
+      return;
+    } else
+      this.numberOfMipmapLevels = Math.max(1, this.numberOfMipmapLevels);
+    if (this.pixelHeight === 0 || this.pixelDepth !== 0) {
+      n.Error("only 2D textures currently supported"), this.isInvalid = !0;
+      return;
+    }
+    if (this.numberOfArrayElements !== 0) {
+      n.Error("texture arrays not currently supported"), this.isInvalid = !0;
+      return;
+    }
+    if (this.numberOfFaces !== t) {
+      n.Error("number of faces expected" + t + ", but found " + this.numberOfFaces), this.isInvalid = !0;
+      return;
+    }
+    this.loadType = a.COMPRESSED_2D;
+  }
+  /**
+   * Uploads KTX content to a Babylon Texture.
+   * It is assumed that the texture has already been created & is currently bound
+   * @internal
+   */
+  uploadLevels(r, t) {
+    switch (this.loadType) {
+      case a.COMPRESSED_2D:
+        this._upload2DCompressedLevels(r, t);
+        break;
+    }
+  }
+  _upload2DCompressedLevels(r, t) {
+    let e = a.HEADER_LEN + this.bytesOfKeyValueData, i = this.pixelWidth, l = this.pixelHeight;
+    const s = t ? this.numberOfMipmapLevels : 1;
+    for (let h = 0; h < s; h++) {
+      const f = new Int32Array(this.data.buffer, this.data.byteOffset + e, 1)[0];
+      e += 4;
+      for (let u = 0; u < this.numberOfFaces; u++) {
+        const p = new Uint8Array(this.data.buffer, this.data.byteOffset + e, f);
+        r.getEngine()._uploadCompressedDataToTextureDirectly(r, r.format, i, l, p, u, h), e += f, e += 3 - (f + 3) % 4;
+      }
+      i = Math.max(1, i * 0.5), l = Math.max(1, l * 0.5);
+    }
+  }
+  /**
+   * Checks if the given data starts with a KTX file identifier.
+   * @param data the data to check
+   * @returns true if the data is a KTX file or false otherwise
+   */
+  static IsValid(r) {
+    if (r.byteLength >= 12) {
+      const t = new Uint8Array(r.buffer, r.byteOffset, 12);
+      if (t[0] === 171 && t[1] === 75 && t[2] === 84 && t[3] === 88 && t[4] === 32 && t[5] === 49 && t[6] === 49 && t[7] === 187 && t[8] === 13 && t[9] === 10 && t[10] === 26 && t[11] === 10)
+        return !0;
+    }
+    return !1;
+  }
+}
+a.HEADER_LEN = 12 + 13 * 4;
+a.COMPRESSED_2D = 0;
+a.COMPRESSED_3D = 1;
+a.TEX_2D = 2;
+a.TEX_3D = 3;
+export {
+  a as KhronosTextureContainer
+};