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

package/dist/node_modules/@babylonjs/loaders/glTF/1.0/glTFLoaderInterfaces.esm.js

@@ -0,0 +1,42 @@
+var _;
+(function(A) {
+  A[A.BYTE = 5120] = "BYTE", A[A.UNSIGNED_BYTE = 5121] = "UNSIGNED_BYTE", A[A.SHORT = 5122] = "SHORT", A[A.UNSIGNED_SHORT = 5123] = "UNSIGNED_SHORT", A[A.FLOAT = 5126] = "FLOAT";
+})(_ || (_ = {}));
+var N;
+(function(A) {
+  A[A.FRAGMENT = 35632] = "FRAGMENT", A[A.VERTEX = 35633] = "VERTEX";
+})(N || (N = {}));
+var O;
+(function(A) {
+  A[A.BYTE = 5120] = "BYTE", A[A.UNSIGNED_BYTE = 5121] = "UNSIGNED_BYTE", A[A.SHORT = 5122] = "SHORT", A[A.UNSIGNED_SHORT = 5123] = "UNSIGNED_SHORT", A[A.INT = 5124] = "INT", A[A.UNSIGNED_INT = 5125] = "UNSIGNED_INT", A[A.FLOAT = 5126] = "FLOAT", A[A.FLOAT_VEC2 = 35664] = "FLOAT_VEC2", A[A.FLOAT_VEC3 = 35665] = "FLOAT_VEC3", A[A.FLOAT_VEC4 = 35666] = "FLOAT_VEC4", A[A.INT_VEC2 = 35667] = "INT_VEC2", A[A.INT_VEC3 = 35668] = "INT_VEC3", A[A.INT_VEC4 = 35669] = "INT_VEC4", A[A.BOOL = 35670] = "BOOL", A[A.BOOL_VEC2 = 35671] = "BOOL_VEC2", A[A.BOOL_VEC3 = 35672] = "BOOL_VEC3", A[A.BOOL_VEC4 = 35673] = "BOOL_VEC4", A[A.FLOAT_MAT2 = 35674] = "FLOAT_MAT2", A[A.FLOAT_MAT3 = 35675] = "FLOAT_MAT3", A[A.FLOAT_MAT4 = 35676] = "FLOAT_MAT4", A[A.SAMPLER_2D = 35678] = "SAMPLER_2D";
+})(O || (O = {}));
+var R;
+(function(A) {
+  A[A.CLAMP_TO_EDGE = 33071] = "CLAMP_TO_EDGE", A[A.MIRRORED_REPEAT = 33648] = "MIRRORED_REPEAT", A[A.REPEAT = 10497] = "REPEAT";
+})(R || (R = {}));
+var L;
+(function(A) {
+  A[A.NEAREST = 9728] = "NEAREST", A[A.LINEAR = 9728] = "LINEAR", A[A.NEAREST_MIPMAP_NEAREST = 9984] = "NEAREST_MIPMAP_NEAREST", A[A.LINEAR_MIPMAP_NEAREST = 9985] = "LINEAR_MIPMAP_NEAREST", A[A.NEAREST_MIPMAP_LINEAR = 9986] = "NEAREST_MIPMAP_LINEAR", A[A.LINEAR_MIPMAP_LINEAR = 9987] = "LINEAR_MIPMAP_LINEAR";
+})(L || (L = {}));
+var S;
+(function(A) {
+  A[A.ALPHA = 6406] = "ALPHA", A[A.RGB = 6407] = "RGB", A[A.RGBA = 6408] = "RGBA", A[A.LUMINANCE = 6409] = "LUMINANCE", A[A.LUMINANCE_ALPHA = 6410] = "LUMINANCE_ALPHA";
+})(S || (S = {}));
+var I;
+(function(A) {
+  A[A.FRONT = 1028] = "FRONT", A[A.BACK = 1029] = "BACK", A[A.FRONT_AND_BACK = 1032] = "FRONT_AND_BACK";
+})(I || (I = {}));
+var C;
+(function(A) {
+  A[A.ZERO = 0] = "ZERO", A[A.ONE = 1] = "ONE", A[A.SRC_COLOR = 768] = "SRC_COLOR", A[A.ONE_MINUS_SRC_COLOR = 769] = "ONE_MINUS_SRC_COLOR", A[A.DST_COLOR = 774] = "DST_COLOR", A[A.ONE_MINUS_DST_COLOR = 775] = "ONE_MINUS_DST_COLOR", A[A.SRC_ALPHA = 770] = "SRC_ALPHA", A[A.ONE_MINUS_SRC_ALPHA = 771] = "ONE_MINUS_SRC_ALPHA", A[A.DST_ALPHA = 772] = "DST_ALPHA", A[A.ONE_MINUS_DST_ALPHA = 773] = "ONE_MINUS_DST_ALPHA", A[A.CONSTANT_COLOR = 32769] = "CONSTANT_COLOR", A[A.ONE_MINUS_CONSTANT_COLOR = 32770] = "ONE_MINUS_CONSTANT_COLOR", A[A.CONSTANT_ALPHA = 32771] = "CONSTANT_ALPHA", A[A.ONE_MINUS_CONSTANT_ALPHA = 32772] = "ONE_MINUS_CONSTANT_ALPHA", A[A.SRC_ALPHA_SATURATE = 776] = "SRC_ALPHA_SATURATE";
+})(C || (C = {}));
+export {
+  C as EBlendingFunction,
+  _ as EComponentType,
+  I as ECullingType,
+  O as EParameterType,
+  N as EShaderType,
+  L as ETextureFilterType,
+  S as ETextureFormat,
+  R as ETextureWrapMode
+};

package/dist/node_modules/@babylonjs/loaders/glTF/1.0/glTFLoaderUtils.esm.js

@@ -0,0 +1,195 @@
+import { EParameterType as n, ETextureWrapMode as c, ETextureFilterType as u, EComponentType as M } from "./glTFLoaderInterfaces.esm.js";
+import { Matrix as f, Vector4 as T, Vector3 as S, Vector2 as V } from "../../../core/Maths/math.vector.esm.js";
+import { Color4 as R } from "../../../core/Maths/math.color.esm.js";
+import { Effect as A } from "../../../core/Materials/effect.esm.js";
+import { ShaderMaterial as m } from "../../../core/Materials/shaderMaterial.esm.js";
+import { Texture as E } from "../../../core/Materials/Textures/texture.esm.js";
+class o {
+  /**
+   * Sets the given "parameter" matrix
+   * @param scene the Scene object
+   * @param source the source node where to pick the matrix
+   * @param parameter the GLTF technique parameter
+   * @param uniformName the name of the shader's uniform
+   * @param shaderMaterial the shader material
+   */
+  static SetMatrix(e, r, t, a, s) {
+    let i = null;
+    if (t.semantic === "MODEL" ? i = r.getWorldMatrix() : t.semantic === "PROJECTION" ? i = e.getProjectionMatrix() : t.semantic === "VIEW" ? i = e.getViewMatrix() : t.semantic === "MODELVIEWINVERSETRANSPOSE" ? i = f.Transpose(r.getWorldMatrix().multiply(e.getViewMatrix()).invert()) : t.semantic === "MODELVIEW" ? i = r.getWorldMatrix().multiply(e.getViewMatrix()) : t.semantic === "MODELVIEWPROJECTION" ? i = r.getWorldMatrix().multiply(e.getTransformMatrix()) : t.semantic === "MODELINVERSE" ? i = r.getWorldMatrix().invert() : t.semantic === "VIEWINVERSE" ? i = e.getViewMatrix().invert() : t.semantic === "PROJECTIONINVERSE" ? i = e.getProjectionMatrix().invert() : t.semantic === "MODELVIEWINVERSE" ? i = r.getWorldMatrix().multiply(e.getViewMatrix()).invert() : t.semantic === "MODELVIEWPROJECTIONINVERSE" ? i = r.getWorldMatrix().multiply(e.getTransformMatrix()).invert() : t.semantic === "MODELINVERSETRANSPOSE" && (i = f.Transpose(r.getWorldMatrix().invert())), i)
+      switch (t.type) {
+        case n.FLOAT_MAT2:
+          s.setMatrix2x2(a, f.GetAsMatrix2x2(i));
+          break;
+        case n.FLOAT_MAT3:
+          s.setMatrix3x3(a, f.GetAsMatrix3x3(i));
+          break;
+        case n.FLOAT_MAT4:
+          s.setMatrix(a, i);
+          break;
+      }
+  }
+  /**
+   * Sets the given "parameter" matrix
+   * @param shaderMaterial the shader material
+   * @param uniform the name of the shader's uniform
+   * @param value the value of the uniform
+   * @param type the uniform's type (EParameterType FLOAT, VEC2, VEC3 or VEC4)
+   */
+  static SetUniform(e, r, t, a) {
+    switch (a) {
+      case n.FLOAT:
+        return e.setFloat(r, t), !0;
+      case n.FLOAT_VEC2:
+        return e.setVector2(r, V.FromArray(t)), !0;
+      case n.FLOAT_VEC3:
+        return e.setVector3(r, S.FromArray(t)), !0;
+      case n.FLOAT_VEC4:
+        return e.setVector4(r, T.FromArray(t)), !0;
+      default:
+        return !1;
+    }
+  }
+  /**
+   * Returns the wrap mode of the texture
+   * @param mode the mode value
+   */
+  static GetWrapMode(e) {
+    switch (e) {
+      case c.CLAMP_TO_EDGE:
+        return E.CLAMP_ADDRESSMODE;
+      case c.MIRRORED_REPEAT:
+        return E.MIRROR_ADDRESSMODE;
+      case c.REPEAT:
+        return E.WRAP_ADDRESSMODE;
+      default:
+        return E.WRAP_ADDRESSMODE;
+    }
+  }
+  /**
+   * Returns the byte stride giving an accessor
+   * @param accessor the GLTF accessor objet
+   */
+  static GetByteStrideFromType(e) {
+    switch (e.type) {
+      case "VEC2":
+        return 2;
+      case "VEC3":
+        return 3;
+      case "VEC4":
+        return 4;
+      case "MAT2":
+        return 4;
+      case "MAT3":
+        return 9;
+      case "MAT4":
+        return 16;
+      default:
+        return 1;
+    }
+  }
+  /**
+   * Returns the texture filter mode giving a mode value
+   * @param mode the filter mode value
+   * @returns the filter mode (TODO - needs to be a type?)
+   */
+  static GetTextureFilterMode(e) {
+    switch (e) {
+      case u.LINEAR:
+      case u.LINEAR_MIPMAP_NEAREST:
+      case u.LINEAR_MIPMAP_LINEAR:
+        return E.TRILINEAR_SAMPLINGMODE;
+      case u.NEAREST:
+      case u.NEAREST_MIPMAP_NEAREST:
+        return E.NEAREST_SAMPLINGMODE;
+      default:
+        return E.BILINEAR_SAMPLINGMODE;
+    }
+  }
+  static GetBufferFromBufferView(e, r, t, a, s) {
+    t = r.byteOffset + t;
+    const i = e.loadedBufferViews[r.buffer];
+    if (t + a > i.byteLength)
+      throw new Error("Buffer access is out of range");
+    const l = i.buffer;
+    switch (t += i.byteOffset, s) {
+      case M.BYTE:
+        return new Int8Array(l, t, a);
+      case M.UNSIGNED_BYTE:
+        return new Uint8Array(l, t, a);
+      case M.SHORT:
+        return new Int16Array(l, t, a);
+      case M.UNSIGNED_SHORT:
+        return new Uint16Array(l, t, a);
+      default:
+        return new Float32Array(l, t, a);
+    }
+  }
+  /**
+   * Returns a buffer from its accessor
+   * @param gltfRuntime the GLTF runtime
+   * @param accessor the GLTF accessor
+   */
+  static GetBufferFromAccessor(e, r) {
+    const t = e.bufferViews[r.bufferView], a = r.count * o.GetByteStrideFromType(r);
+    return o.GetBufferFromBufferView(e, t, r.byteOffset, a, r.componentType);
+  }
+  /**
+   * Decodes a buffer view into a string
+   * @param view the buffer view
+   */
+  static DecodeBufferToText(e) {
+    let r = "";
+    const t = e.byteLength;
+    for (let a = 0; a < t; ++a)
+      r += String.fromCharCode(e[a]);
+    return r;
+  }
+  /**
+   * Returns the default material of gltf. Related to
+   * https://github.com/KhronosGroup/glTF/tree/master/specification/1.0#appendix-a-default-material
+   * @param scene the Babylon.js scene
+   */
+  static GetDefaultMaterial(e) {
+    if (!o._DefaultMaterial) {
+      A.ShadersStore.GLTFDefaultMaterialVertexShader = [
+        "precision highp float;",
+        "",
+        "uniform mat4 worldView;",
+        "uniform mat4 projection;",
+        "",
+        "attribute vec3 position;",
+        "",
+        "void main(void)",
+        "{",
+        "    gl_Position = projection * worldView * vec4(position, 1.0);",
+        "}"
+      ].join(`
+`), A.ShadersStore.GLTFDefaultMaterialPixelShader = [
+        "precision highp float;",
+        "",
+        "uniform vec4 u_emission;",
+        "",
+        "void main(void)",
+        "{",
+        "    gl_FragColor = u_emission;",
+        "}"
+      ].join(`
+`);
+      const r = {
+        vertex: "GLTFDefaultMaterial",
+        fragment: "GLTFDefaultMaterial"
+      }, t = {
+        attributes: ["position"],
+        uniforms: ["worldView", "projection", "u_emission"],
+        samplers: new Array(),
+        needAlphaBlending: !1
+      };
+      o._DefaultMaterial = new m("GLTFDefaultMaterial", e, r, t), o._DefaultMaterial.setColor4("u_emission", new R(0.5, 0.5, 0.5, 1));
+    }
+    return o._DefaultMaterial;
+  }
+}
+o._DefaultMaterial = null;
+export {
+  o as GLTFUtils
+};

package/dist/node_modules/@babylonjs/loaders/glTF/1.0/glTFMaterialsCommonExtension.esm.js

@@ -0,0 +1,75 @@
+import { GLTFLoader as f, GLTFLoaderExtension as u, GLTFLoaderBase as c } from "./glTFLoader.esm.js";
+import { Vector3 as l } from "../../../core/Maths/math.vector.esm.js";
+import { Color3 as n } from "../../../core/Maths/math.color.esm.js";
+import { Tools as m } from "../../../core/Misc/tools.esm.js";
+import { Material as d } from "../../../core/Materials/material.esm.js";
+import { StandardMaterial as p } from "../../../core/Materials/standardMaterial.esm.js";
+import { HemisphericLight as h } from "../../../core/Lights/hemisphericLight.esm.js";
+import { DirectionalLight as x } from "../../../core/Lights/directionalLight.esm.js";
+import { PointLight as y } from "../../../core/Lights/pointLight.esm.js";
+import { SpotLight as T } from "../../../core/Lights/spotLight.esm.js";
+class b extends u {
+  constructor() {
+    super("KHR_materials_common");
+  }
+  loadRuntimeExtensionsAsync(i) {
+    if (!i.extensions)
+      return !1;
+    const o = i.extensions[this.name];
+    if (!o)
+      return !1;
+    const a = o.lights;
+    if (a)
+      for (const t in a) {
+        const r = a[t];
+        switch (r.type) {
+          case "ambient": {
+            const e = new h(r.name, new l(0, 1, 0), i.scene), s = r.ambient;
+            s && (e.diffuse = n.FromArray(s.color || [1, 1, 1]));
+            break;
+          }
+          case "point": {
+            const e = new y(r.name, new l(10, 10, 10), i.scene), s = r.point;
+            s && (e.diffuse = n.FromArray(s.color || [1, 1, 1]));
+            break;
+          }
+          case "directional": {
+            const e = new x(r.name, new l(0, -1, 0), i.scene), s = r.directional;
+            s && (e.diffuse = n.FromArray(s.color || [1, 1, 1]));
+            break;
+          }
+          case "spot": {
+            const e = r.spot;
+            if (e) {
+              const s = new T(r.name, new l(0, 10, 0), new l(0, -1, 0), e.fallOffAngle || Math.PI, e.fallOffExponent || 0, i.scene);
+              s.diffuse = n.FromArray(e.color || [1, 1, 1]);
+            }
+            break;
+          }
+          default:
+            m.Warn('GLTF Material Common extension: light type "' + r.type + "” not supported");
+            break;
+        }
+      }
+    return !1;
+  }
+  loadMaterialAsync(i, o, a, t) {
+    const r = i.materials[o];
+    if (!r || !r.extensions)
+      return !1;
+    const e = r.extensions[this.name];
+    if (!e)
+      return !1;
+    const s = new p(o, i.scene);
+    return s.sideOrientation = d.CounterClockWiseSideOrientation, e.technique === "CONSTANT" && (s.disableLighting = !0), s.backFaceCulling = e.doubleSided === void 0 ? !1 : !e.doubleSided, s.alpha = e.values.transparency === void 0 ? 1 : e.values.transparency, s.specularPower = e.values.shininess === void 0 ? 0 : e.values.shininess, typeof e.values.ambient == "string" ? this._loadTexture(i, e.values.ambient, s, "ambientTexture", t) : s.ambientColor = n.FromArray(e.values.ambient || [0, 0, 0]), typeof e.values.diffuse == "string" ? this._loadTexture(i, e.values.diffuse, s, "diffuseTexture", t) : s.diffuseColor = n.FromArray(e.values.diffuse || [0, 0, 0]), typeof e.values.emission == "string" ? this._loadTexture(i, e.values.emission, s, "emissiveTexture", t) : s.emissiveColor = n.FromArray(e.values.emission || [0, 0, 0]), typeof e.values.specular == "string" ? this._loadTexture(i, e.values.specular, s, "specularTexture", t) : s.specularColor = n.FromArray(e.values.specular || [0, 0, 0]), !0;
+  }
+  _loadTexture(i, o, a, t, r) {
+    c.LoadTextureBufferAsync(i, o, (e) => {
+      c.CreateTextureAsync(i, o, e, (s) => a[t] = s);
+    }, r);
+  }
+}
+f.RegisterExtension(new b());
+export {
+  b as GLTFMaterialsCommonExtension
+};

package/dist/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_lights_image_based.esm.js

@@ -0,0 +1,77 @@
+import { Scalar as p } from "../../../../core/Maths/math.scalar.esm.js";
+import { SphericalHarmonics as f, SphericalPolynomial as y } from "../../../../core/Maths/sphericalPolynomial.esm.js";
+import { Quaternion as d, Matrix as b } from "../../../../core/Maths/math.vector.esm.js";
+import { RawCubeTexture as A } from "../../../../core/Materials/Textures/rawCubeTexture.esm.js";
+import { GLTFLoader as _, ArrayItem as h } from "../glTFLoader.esm.js";
+const c = "EXT_lights_image_based";
+class I {
+  /**
+   * @internal
+   */
+  constructor(a) {
+    this.name = c, this._loader = a, this.enabled = this._loader.isExtensionUsed(c);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null, delete this._lights;
+  }
+  /** @internal */
+  onLoading() {
+    const a = this._loader.gltf.extensions;
+    if (a && a[this.name]) {
+      const e = a[this.name];
+      this._lights = e.lights;
+    }
+  }
+  /**
+   * @internal
+   */
+  loadSceneAsync(a, e) {
+    return _.LoadExtensionAsync(a, e, this.name, (i, r) => {
+      const n = new Array();
+      n.push(this._loader.loadSceneAsync(a, e)), this._loader.logOpen(`${i}`);
+      const s = h.Get(`${i}/light`, this._lights, r.light);
+      return n.push(this._loadLightAsync(`/extensions/${this.name}/lights/${r.light}`, s).then((o) => {
+        this._loader.babylonScene.environmentTexture = o;
+      })), this._loader.logClose(), Promise.all(n).then(() => {
+      });
+    });
+  }
+  _loadLightAsync(a, e) {
+    if (!e._loaded) {
+      const i = new Array();
+      this._loader.logOpen(`${a}`);
+      const r = new Array(e.specularImages.length);
+      for (let n = 0; n < e.specularImages.length; n++) {
+        const s = e.specularImages[n];
+        r[n] = new Array(s.length);
+        for (let o = 0; o < s.length; o++) {
+          const l = `${a}/specularImages/${n}/${o}`;
+          this._loader.logOpen(`${l}`);
+          const t = s[o], u = h.Get(l, this._loader.gltf.images, t);
+          i.push(this._loader.loadImageAsync(`/images/${t}`, u).then((g) => {
+            r[n][o] = g;
+          })), this._loader.logClose();
+        }
+      }
+      this._loader.logClose(), e._loaded = Promise.all(i).then(() => {
+        const n = new A(this._loader.babylonScene, null, e.specularImageSize);
+        if (n.name = e.name || "environment", e._babylonTexture = n, e.intensity != null && (n.level = e.intensity), e.rotation) {
+          let t = d.FromArray(e.rotation);
+          this._loader.babylonScene.useRightHandedSystem || (t = d.Inverse(t)), b.FromQuaternionToRef(t, n.getReflectionTextureMatrix());
+        }
+        if (!e.irradianceCoefficients)
+          throw new Error(`${a}: Irradiance coefficients are missing`);
+        const s = f.FromArray(e.irradianceCoefficients);
+        s.scaleInPlace(e.intensity), s.convertIrradianceToLambertianRadiance();
+        const o = y.FromHarmonics(s), l = (r.length - 1) / p.Log2(e.specularImageSize);
+        return n.updateRGBDAsync(r, o, l);
+      });
+    }
+    return e._loaded.then(() => e._babylonTexture);
+  }
+}
+_.RegisterExtension(c, (m) => new I(m));
+export {
+  I as EXT_lights_image_based
+};

package/dist/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_mesh_gpu_instancing.esm.js

@@ -0,0 +1,53 @@
+import { TmpVectors as e, Vector3 as A, Quaternion as b, Matrix as F } from "../../../../core/Maths/math.vector.esm.js";
+import { GLTFLoader as f, ArrayItem as M } from "../glTFLoader.esm.js";
+import "../../../../core/Meshes/thinInstanceMesh.esm.js";
+const l = "EXT_mesh_gpu_instancing";
+class V {
+  /**
+   * @internal
+   */
+  constructor(a) {
+    this.name = l, this._loader = a, this.enabled = this._loader.isExtensionUsed(l);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadNodeAsync(a, t, T) {
+    return f.LoadExtensionAsync(a, t, this.name, (h, u) => {
+      this._loader._disableInstancedMesh++;
+      const d = this._loader.loadNodeAsync(`/nodes/${t.index}`, t, T);
+      if (this._loader._disableInstancedMesh--, !t._primitiveBabylonMeshes)
+        return d;
+      const i = new Array();
+      let s = 0;
+      const c = (n) => {
+        if (u.attributes[n] == null) {
+          i.push(Promise.resolve(null));
+          return;
+        }
+        const o = M.Get(`${h}/attributes/${n}`, this._loader.gltf.accessors, u.attributes[n]);
+        if (i.push(this._loader._loadFloatAccessorAsync(`/accessors/${o.bufferView}`, o)), s === 0)
+          s = o.count;
+        else if (s !== o.count)
+          throw new Error(`${h}/attributes: Instance buffer accessors do not have the same count.`);
+      };
+      return c("TRANSLATION"), c("ROTATION"), c("SCALE"), d.then((n) => Promise.all(i).then(([o, p, _]) => {
+        const y = new Float32Array(s * 16);
+        e.Vector3[0].copyFromFloats(0, 0, 0), e.Quaternion[0].copyFromFloats(0, 0, 0, 1), e.Vector3[1].copyFromFloats(1, 1, 1);
+        for (let r = 0; r < s; ++r)
+          o && A.FromArrayToRef(o, r * 3, e.Vector3[0]), p && b.FromArrayToRef(p, r * 4, e.Quaternion[0]), _ && A.FromArrayToRef(_, r * 3, e.Vector3[1]), F.ComposeToRef(e.Vector3[1], e.Quaternion[0], e.Vector3[0], e.Matrix[0]), e.Matrix[0].copyToArray(y, r * 16);
+        for (const r of t._primitiveBabylonMeshes)
+          r.thinInstanceSetBuffer("matrix", y, 16, !0);
+        return n;
+      }));
+    });
+  }
+}
+f.RegisterExtension(l, (m) => new V(m));
+export {
+  V as EXT_mesh_gpu_instancing
+};

package/dist/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_meshopt_compression.esm.js

@@ -0,0 +1,31 @@
+import { GLTFLoader as n, ArrayItem as h } from "../glTFLoader.esm.js";
+import { MeshoptCompression as m } from "../../../../core/Meshes/Compression/meshoptCompression.esm.js";
+const r = "EXT_meshopt_compression";
+class u {
+  /**
+   * @internal
+   */
+  constructor(t) {
+    this.name = r, this.enabled = t.isExtensionUsed(r), this._loader = t;
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadBufferViewAsync(t, f) {
+    return n.LoadExtensionAsync(t, f, this.name, (d, e) => {
+      const s = f;
+      if (s._meshOptData)
+        return s._meshOptData;
+      const a = h.Get(`${t}/buffer`, this._loader.gltf.buffers, e.buffer);
+      return s._meshOptData = this._loader.loadBufferAsync(`/buffers/${a.index}`, a, e.byteOffset || 0, e.byteLength).then((i) => m.Default.decodeGltfBufferAsync(i, e.count, e.byteStride, e.mode, e.filter)), s._meshOptData;
+    });
+  }
+}
+n.RegisterExtension(r, (o) => new u(o));
+export {
+  u as EXT_meshopt_compression
+};

package/dist/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/EXT_texture_webp.esm.js

@@ -0,0 +1,29 @@
+import { GLTFLoader as r, ArrayItem as a } from "../glTFLoader.esm.js";
+const t = "EXT_texture_webp";
+class p {
+  /**
+   * @internal
+   */
+  constructor(e) {
+    this.name = t, this._loader = e, this.enabled = e.isExtensionUsed(t);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  _loadTextureAsync(e, s, o) {
+    return r.LoadExtensionAsync(e, s, this.name, (i, l) => {
+      const d = s.sampler == null ? r.DefaultSampler : a.Get(`${e}/sampler`, this._loader.gltf.samplers, s.sampler), m = a.Get(`${i}/source`, this._loader.gltf.images, l.source);
+      return this._loader._createTextureAsync(e, d, m, (_) => {
+        o(_);
+      }, void 0, !s._textureInfo.nonColorData);
+    });
+  }
+}
+r.RegisterExtension(t, (n) => new p(n));
+export {
+  p as EXT_texture_webp
+};

package/dist/node_modules/@babylonjs/loaders/glTF/2.0/Extensions/ExtrasAsMetadata.esm.js

@@ -0,0 +1,47 @@
+import { GLTFLoader as n } from "../glTFLoader.esm.js";
+const i = "ExtrasAsMetadata";
+class d {
+  _assignExtras(a, t) {
+    if (t.extras && Object.keys(t.extras).length > 0) {
+      const e = a.metadata = a.metadata || {}, s = e.gltf = e.gltf || {};
+      s.extras = t.extras;
+    }
+  }
+  /**
+   * @internal
+   */
+  constructor(a) {
+    this.name = i, this.enabled = !0, this._loader = a;
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadNodeAsync(a, t, e) {
+    return this._loader.loadNodeAsync(a, t, (s) => {
+      this._assignExtras(s, t), e(s);
+    });
+  }
+  /**
+   * @internal
+   */
+  loadCameraAsync(a, t, e) {
+    return this._loader.loadCameraAsync(a, t, (s) => {
+      this._assignExtras(s, t), e(s);
+    });
+  }
+  /**
+   * @internal
+   */
+  createMaterial(a, t, e) {
+    const s = this._loader.createMaterial(a, t, e);
+    return this._assignExtras(s, t), s;
+  }
+}
+n.RegisterExtension(i, (r) => new d(r));
+export {
+  d as ExtrasAsMetadata
+};