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

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

@@ -0,0 +1,41 @@
+import { PBRMaterial as n } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
+import { GLTFLoader as u } from "../glTFLoader.esm.js";
+import { Color3 as i } from "../../../../core/Maths/math.color.esm.js";
+const a = "KHR_materials_specular";
+class d {
+  /**
+   * @internal
+   */
+  constructor(s) {
+    this.name = a, this.order = 190, this._loader = s, this.enabled = this._loader.isExtensionUsed(a);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadMaterialPropertiesAsync(s, e, r) {
+    return u.LoadExtensionAsync(s, e, this.name, (l, o) => {
+      const t = new Array();
+      return t.push(this._loader.loadMaterialPropertiesAsync(s, e, r)), t.push(this._loadSpecularPropertiesAsync(l, o, r)), Promise.all(t).then(() => {
+      });
+    });
+  }
+  _loadSpecularPropertiesAsync(s, e, r) {
+    if (!(r instanceof n))
+      throw new Error(`${s}: Material type not supported`);
+    const l = new Array();
+    return e.specularFactor !== void 0 && (r.metallicF0Factor = e.specularFactor), e.specularColorFactor !== void 0 && (r.metallicReflectanceColor = i.FromArray(e.specularColorFactor)), e.specularTexture && (e.specularTexture.nonColorData = !0, l.push(this._loader.loadTextureInfoAsync(`${s}/specularTexture`, e.specularTexture, (o) => {
+      o.name = `${r.name} (Specular F0 Strength)`, r.metallicReflectanceTexture = o, r.useOnlyMetallicFromMetallicReflectanceTexture = !0;
+    }))), e.specularColorTexture && l.push(this._loader.loadTextureInfoAsync(`${s}/specularColorTexture`, e.specularColorTexture, (o) => {
+      o.name = `${r.name} (Specular F0 Color)`, r.reflectanceTexture = o;
+    })), Promise.all(l).then(() => {
+    });
+  }
+}
+u.RegisterExtension(a, (c) => new d(c));
+export {
+  d as KHR_materials_specular
+};

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

@@ -0,0 +1,41 @@
+import { PBRMaterial as o } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
+import { GLTFLoader as i } from "../glTFLoader.esm.js";
+const u = "KHR_materials_translucency";
+class l {
+  /**
+   * @internal
+   */
+  constructor(r) {
+    this.name = u, this.order = 174, this._loader = r, this.enabled = this._loader.isExtensionUsed(u), this.enabled && (r.parent.transparencyAsCoverage = !0);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadMaterialPropertiesAsync(r, a, n) {
+    return i.LoadExtensionAsync(r, a, this.name, (s, e) => {
+      const t = new Array();
+      return t.push(this._loader.loadMaterialBasePropertiesAsync(r, a, n)), t.push(this._loader.loadMaterialPropertiesAsync(r, a, n)), t.push(this._loadTranslucentPropertiesAsync(s, a, n, e)), Promise.all(t).then(() => {
+      });
+    });
+  }
+  _loadTranslucentPropertiesAsync(r, a, n, s) {
+    if (!(n instanceof o))
+      throw new Error(`${r}: Material type not supported`);
+    const e = n;
+    if (e.subSurface.isTranslucencyEnabled = !0, e.subSurface.volumeIndexOfRefraction = 1, e.subSurface.minimumThickness = 0, e.subSurface.maximumThickness = 0, e.subSurface.useAlbedoToTintTranslucency = !0, s.translucencyFactor !== void 0)
+      e.subSurface.translucencyIntensity = s.translucencyFactor;
+    else
+      return e.subSurface.translucencyIntensity = 0, e.subSurface.isTranslucencyEnabled = !1, Promise.resolve();
+    return s.translucencyTexture ? (s.translucencyTexture.nonColorData = !0, this._loader.loadTextureInfoAsync(`${r}/translucencyTexture`, s.translucencyTexture).then((t) => {
+      e.subSurface.translucencyIntensityTexture = t;
+    })) : Promise.resolve();
+  }
+}
+i.RegisterExtension(u, (c) => new l(c));
+export {
+  l as KHR_materials_translucency
+};

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

@@ -0,0 +1,136 @@
+import { PBRMaterial as a } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
+import { GLTFLoader as p } from "../glTFLoader.esm.js";
+import { RenderTargetTexture as d } from "../../../../core/Materials/Textures/renderTargetTexture.esm.js";
+import { Observable as c } from "../../../../core/Misc/observable.esm.js";
+import { Constants as l } from "../../../../core/Engines/constants.esm.js";
+import { Tools as _ } from "../../../../core/Misc/tools.esm.js";
+class h {
+  /**
+   * Creates the default options for the helper.
+   */
+  static _GetDefaultOptions() {
+    return {
+      renderSize: 1024,
+      samples: 4,
+      lodGenerationScale: 1,
+      lodGenerationOffset: -4,
+      renderTargetTextureType: l.TEXTURETYPE_HALF_FLOAT,
+      generateMipmaps: !0
+    };
+  }
+  /**
+   * constructor
+   * @param options Defines the options we want to customize the helper
+   * @param scene The scene to add the material to
+   */
+  constructor(e, t) {
+    this._opaqueRenderTarget = null, this._opaqueMeshesCache = [], this._transparentMeshesCache = [], this._materialObservers = {}, this._options = {
+      ...h._GetDefaultOptions(),
+      ...e
+    }, this._scene = t, this._scene._transmissionHelper = this, this.onErrorObservable = new c(), this._scene.onDisposeObservable.addOnce(() => {
+      this.dispose();
+    }), this._parseScene(), this._setupRenderTargets();
+  }
+  /**
+   * Updates the background according to the new options
+   * @param options
+   */
+  updateOptions(e) {
+    if (!Object.keys(e).filter((s) => this._options[s] !== e[s]).length)
+      return;
+    const r = {
+      ...this._options,
+      ...e
+    }, n = this._options;
+    this._options = r, r.renderSize !== n.renderSize || r.renderTargetTextureType !== n.renderTargetTextureType || r.generateMipmaps !== n.generateMipmaps || !this._opaqueRenderTarget ? this._setupRenderTargets() : (this._opaqueRenderTarget.samples = r.samples, this._opaqueRenderTarget.lodGenerationScale = r.lodGenerationScale, this._opaqueRenderTarget.lodGenerationOffset = r.lodGenerationOffset);
+  }
+  /**
+   * Gets the opaque render target texture or null if not available.
+   */
+  getOpaqueTarget() {
+    return this._opaqueRenderTarget;
+  }
+  _shouldRenderAsTransmission(e) {
+    return e ? !!(e instanceof a && e.subSurface.isRefractionEnabled) : !1;
+  }
+  _addMesh(e) {
+    this._materialObservers[e.uniqueId] = e.onMaterialChangedObservable.add(this._onMeshMaterialChanged.bind(this)), _.SetImmediate(() => {
+      this._shouldRenderAsTransmission(e.material) ? (e.material.refractionTexture = this._opaqueRenderTarget, this._transparentMeshesCache.indexOf(e) === -1 && this._transparentMeshesCache.push(e)) : this._opaqueMeshesCache.indexOf(e) === -1 && this._opaqueMeshesCache.push(e);
+    });
+  }
+  _removeMesh(e) {
+    e.onMaterialChangedObservable.remove(this._materialObservers[e.uniqueId]), delete this._materialObservers[e.uniqueId];
+    let t = this._transparentMeshesCache.indexOf(e);
+    t !== -1 && this._transparentMeshesCache.splice(t, 1), t = this._opaqueMeshesCache.indexOf(e), t !== -1 && this._opaqueMeshesCache.splice(t, 1);
+  }
+  _parseScene() {
+    this._scene.meshes.forEach(this._addMesh.bind(this)), this._scene.onNewMeshAddedObservable.add(this._addMesh.bind(this)), this._scene.onMeshRemovedObservable.add(this._removeMesh.bind(this));
+  }
+  // When one of the meshes in the scene has its material changed, make sure that it's in the correct cache list.
+  _onMeshMaterialChanged(e) {
+    const t = this._transparentMeshesCache.indexOf(e), r = this._opaqueMeshesCache.indexOf(e);
+    this._shouldRenderAsTransmission(e.material) ? (e.material instanceof a && (e.material.subSurface.refractionTexture = this._opaqueRenderTarget), r !== -1 ? (this._opaqueMeshesCache.splice(r, 1), this._transparentMeshesCache.push(e)) : t === -1 && this._transparentMeshesCache.push(e)) : t !== -1 ? (this._transparentMeshesCache.splice(t, 1), this._opaqueMeshesCache.push(e)) : r === -1 && this._opaqueMeshesCache.push(e);
+  }
+  /**
+   * Setup the render targets according to the specified options.
+   */
+  _setupRenderTargets() {
+    var e, t;
+    this._opaqueRenderTarget && this._opaqueRenderTarget.dispose(), this._opaqueRenderTarget = new d("opaqueSceneTexture", this._options.renderSize, this._scene, this._options.generateMipmaps, void 0, this._options.renderTargetTextureType), this._opaqueRenderTarget.ignoreCameraViewport = !0, this._opaqueRenderTarget.renderList = this._opaqueMeshesCache, this._opaqueRenderTarget.clearColor = (t = (e = this._options.clearColor) === null || e === void 0 ? void 0 : e.clone()) !== null && t !== void 0 ? t : this._scene.clearColor.clone(), this._opaqueRenderTarget.gammaSpace = !1, this._opaqueRenderTarget.lodGenerationScale = this._options.lodGenerationScale, this._opaqueRenderTarget.lodGenerationOffset = this._options.lodGenerationOffset, this._opaqueRenderTarget.samples = this._options.samples;
+    let r, n;
+    this._opaqueRenderTarget.onBeforeBindObservable.add((s) => {
+      n = this._scene.environmentIntensity, this._scene.environmentIntensity = 1, r = this._scene.imageProcessingConfiguration.applyByPostProcess, this._options.clearColor ? s.clearColor.copyFrom(this._options.clearColor) : this._scene.clearColor.toLinearSpaceToRef(s.clearColor, this._scene.getEngine().useExactSrgbConversions), this._scene.imageProcessingConfiguration._applyByPostProcess = !0;
+    }), this._opaqueRenderTarget.onAfterUnbindObservable.add(() => {
+      this._scene.environmentIntensity = n, this._scene.imageProcessingConfiguration._applyByPostProcess = r;
+    }), this._transparentMeshesCache.forEach((s) => {
+      this._shouldRenderAsTransmission(s.material) && (s.material.refractionTexture = this._opaqueRenderTarget);
+    });
+  }
+  /**
+   * Dispose all the elements created by the Helper.
+   */
+  dispose() {
+    this._scene._transmissionHelper = void 0, this._opaqueRenderTarget && (this._opaqueRenderTarget.dispose(), this._opaqueRenderTarget = null), this._transparentMeshesCache = [], this._opaqueMeshesCache = [];
+  }
+}
+const o = "KHR_materials_transmission";
+class f {
+  /**
+   * @internal
+   */
+  constructor(e) {
+    this.name = o, this.order = 175, this._loader = e, this.enabled = this._loader.isExtensionUsed(o), this.enabled && (e.parent.transparencyAsCoverage = !0);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadMaterialPropertiesAsync(e, t, r) {
+    return p.LoadExtensionAsync(e, t, this.name, (n, s) => {
+      const i = new Array();
+      return i.push(this._loader.loadMaterialBasePropertiesAsync(e, t, r)), i.push(this._loader.loadMaterialPropertiesAsync(e, t, r)), i.push(this._loadTransparentPropertiesAsync(n, t, r, s)), Promise.all(i).then(() => {
+      });
+    });
+  }
+  _loadTransparentPropertiesAsync(e, t, r, n) {
+    if (!(r instanceof a))
+      throw new Error(`${e}: Material type not supported`);
+    const s = r;
+    if (s.subSurface.isRefractionEnabled = !0, s.subSurface.volumeIndexOfRefraction = 1, s.subSurface.useAlbedoToTintRefraction = !0, n.transmissionFactor !== void 0) {
+      s.subSurface.refractionIntensity = n.transmissionFactor;
+      const i = s.getScene();
+      s.subSurface.refractionIntensity && !i._transmissionHelper && new h({}, s.getScene());
+    } else
+      return s.subSurface.refractionIntensity = 0, s.subSurface.isRefractionEnabled = !1, Promise.resolve();
+    return s.subSurface.minimumThickness = 0, s.subSurface.maximumThickness = 0, n.transmissionTexture ? (n.transmissionTexture.nonColorData = !0, this._loader.loadTextureInfoAsync(`${e}/transmissionTexture`, n.transmissionTexture, void 0).then((i) => {
+      s.subSurface.refractionIntensityTexture = i, s.subSurface.useGltfStyleTextures = !0;
+    })) : Promise.resolve();
+  }
+}
+p.RegisterExtension(o, (u) => new f(u));
+export {
+  f as KHR_materials_transmission
+};

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

@@ -0,0 +1,37 @@
+import { Color3 as d } from "../../../../core/Maths/math.color.esm.js";
+import { PBRMaterial as p } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
+import { GLTFLoader as a } from "../glTFLoader.esm.js";
+const t = "KHR_materials_unlit";
+class u {
+  /**
+   * @internal
+   */
+  constructor(o) {
+    this.name = t, this.order = 210, this._loader = o, this.enabled = this._loader.isExtensionUsed(t);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadMaterialPropertiesAsync(o, r, e) {
+    return a.LoadExtensionAsync(o, r, this.name, () => this._loadUnlitPropertiesAsync(o, r, e));
+  }
+  _loadUnlitPropertiesAsync(o, r, e) {
+    if (!(e instanceof p))
+      throw new Error(`${o}: Material type not supported`);
+    const l = new Array();
+    e.unlit = !0;
+    const s = r.pbrMetallicRoughness;
+    return s && (s.baseColorFactor ? (e.albedoColor = d.FromArray(s.baseColorFactor), e.alpha = s.baseColorFactor[3]) : e.albedoColor = d.White(), s.baseColorTexture && l.push(this._loader.loadTextureInfoAsync(`${o}/baseColorTexture`, s.baseColorTexture, (n) => {
+      n.name = `${e.name} (Base Color)`, e.albedoTexture = n;
+    }))), r.doubleSided && (e.backFaceCulling = !1, e.twoSidedLighting = !0), this._loader.loadMaterialAlphaProperties(o, r, e), Promise.all(l).then(() => {
+    });
+  }
+}
+a.RegisterExtension(t, (i) => new u(i));
+export {
+  u as KHR_materials_unlit
+};

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

@@ -0,0 +1,178 @@
+import { GLTFLoader as E, ArrayItem as V } from "../glTFLoader.esm.js";
+import { Mesh as I } from "../../../../core/Meshes/mesh.esm.js";
+const n = "KHR_materials_variants";
+class d {
+  /**
+   * @internal
+   */
+  constructor(t) {
+    this.name = n, this._loader = t, this.enabled = this._loader.isExtensionUsed(n);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * Gets the list of available variant names for this asset.
+   * @param rootMesh The glTF root mesh
+   * @returns the list of all the variant names for this model
+   */
+  static GetAvailableVariants(t) {
+    const a = this._GetExtensionMetadata(t);
+    return a ? Object.keys(a.variants) : [];
+  }
+  /**
+   * Gets the list of available variant names for this asset.
+   * @param rootMesh The glTF root mesh
+   * @returns the list of all the variant names for this model
+   */
+  getAvailableVariants(t) {
+    return d.GetAvailableVariants(t);
+  }
+  /**
+   * Select a variant given a variant name or a list of variant names.
+   * @param rootMesh The glTF root mesh
+   * @param variantName The variant name(s) to select.
+   */
+  static SelectVariant(t, a) {
+    const s = this._GetExtensionMetadata(t);
+    if (!s)
+      throw new Error(`Cannot select variant on a glTF mesh that does not have the ${n} extension`);
+    const h = (c) => {
+      const f = s.variants[c];
+      if (f)
+        for (const m of f)
+          m.mesh.material = m.material;
+    };
+    if (a instanceof Array)
+      for (const c of a)
+        h(c);
+    else
+      h(a);
+    s.lastSelected = a;
+  }
+  /**
+   * Select a variant given a variant name or a list of variant names.
+   * @param rootMesh The glTF root mesh
+   * @param variantName The variant name(s) to select.
+   */
+  selectVariant(t, a) {
+    return d.SelectVariant(t, a);
+  }
+  /**
+   * Reset back to the original before selecting a variant.
+   * @param rootMesh The glTF root mesh
+   */
+  static Reset(t) {
+    const a = this._GetExtensionMetadata(t);
+    if (!a)
+      throw new Error(`Cannot reset on a glTF mesh that does not have the ${n} extension`);
+    for (const s of a.original)
+      s.mesh.material = s.material;
+    a.lastSelected = null;
+  }
+  /**
+   * Reset back to the original before selecting a variant.
+   * @param rootMesh The glTF root mesh
+   */
+  reset(t) {
+    return d.Reset(t);
+  }
+  /**
+   * Gets the last selected variant name(s) or null if original.
+   * @param rootMesh The glTF root mesh
+   * @returns The selected variant name(s).
+   */
+  static GetLastSelectedVariant(t) {
+    const a = this._GetExtensionMetadata(t);
+    if (!a)
+      throw new Error(`Cannot get the last selected variant on a glTF mesh that does not have the ${n} extension`);
+    return a.lastSelected;
+  }
+  /**
+   * Gets the last selected variant name(s) or null if original.
+   * @param rootMesh The glTF root mesh
+   * @returns The selected variant name(s).
+   */
+  getLastSelectedVariant(t) {
+    return d.GetLastSelectedVariant(t);
+  }
+  static _GetExtensionMetadata(t) {
+    var a, s;
+    return ((s = (a = t == null ? void 0 : t._internalMetadata) === null || a === void 0 ? void 0 : a.gltf) === null || s === void 0 ? void 0 : s[n]) || null;
+  }
+  /** @internal */
+  onLoading() {
+    const t = this._loader.gltf.extensions;
+    if (t && t[this.name]) {
+      const a = t[this.name];
+      this._variants = a.variants;
+    }
+  }
+  /**
+   * @internal
+   */
+  _loadMeshPrimitiveAsync(t, a, s, h, c, f) {
+    return E.LoadExtensionAsync(t, c, this.name, (m, G) => {
+      const p = new Array();
+      return p.push(this._loader._loadMeshPrimitiveAsync(t, a, s, h, c, (r) => {
+        if (f(r), r instanceof I) {
+          const L = E._GetDrawMode(t, c.mode), l = this._loader.rootBabylonMesh, w = l ? l._internalMetadata = l._internalMetadata || {} : {}, A = w.gltf = w.gltf || {}, g = A[n] = A[n] || { lastSelected: null, original: [], variants: {} };
+          g.original.push({ mesh: r, material: r.material });
+          for (let v = 0; v < G.mappings.length; ++v) {
+            const u = G.mappings[v], k = V.Get(`${m}/mappings/${v}/material`, this._loader.gltf.materials, u.material);
+            p.push(this._loader._loadMaterialAsync(`#/materials/${u.material}`, k, r, L, (C) => {
+              for (let _ = 0; _ < u.variants.length; ++_) {
+                const y = u.variants[_], M = V.Get(`/extensions/${n}/variants/${y}`, this._variants, y);
+                g.variants[M.name] = g.variants[M.name] || [], g.variants[M.name].push({
+                  mesh: r,
+                  material: C
+                }), r.onClonedObservable.add((F) => {
+                  const x = F;
+                  let o = null, i = x;
+                  do {
+                    if (i = i.parent, !i)
+                      return;
+                    o = d._GetExtensionMetadata(i);
+                  } while (o === null);
+                  if (l && o === d._GetExtensionMetadata(l)) {
+                    i._internalMetadata = {};
+                    for (const e in l._internalMetadata)
+                      i._internalMetadata[e] = l._internalMetadata[e];
+                    i._internalMetadata.gltf = [];
+                    for (const e in l._internalMetadata.gltf)
+                      i._internalMetadata.gltf[e] = l._internalMetadata.gltf[e];
+                    i._internalMetadata.gltf[n] = { lastSelected: null, original: [], variants: {} };
+                    for (const e of o.original)
+                      i._internalMetadata.gltf[n].original.push({
+                        mesh: e.mesh,
+                        material: e.material
+                      });
+                    for (const e in o.variants)
+                      if (Object.prototype.hasOwnProperty.call(o.variants, e)) {
+                        i._internalMetadata.gltf[n].variants[e] = [];
+                        for (const S of o.variants[e])
+                          i._internalMetadata.gltf[n].variants[e].push({
+                            mesh: S.mesh,
+                            material: S.material
+                          });
+                      }
+                    o = i._internalMetadata.gltf[n];
+                  }
+                  for (const e of o.original)
+                    e.mesh === r && (e.mesh = x);
+                  for (const e of o.variants[M.name])
+                    e.mesh === r && (e.mesh = x);
+                });
+              }
+            }));
+          }
+        }
+      })), Promise.all(p).then(([r]) => r);
+    });
+  }
+}
+E.RegisterExtension(n, ($) => new d($));
+export {
+  d as KHR_materials_variants
+};

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

@@ -0,0 +1,40 @@
+import { PBRMaterial as a } from "../../../../core/Materials/PBR/pbrMaterial.esm.js";
+import { GLTFLoader as c } from "../glTFLoader.esm.js";
+const i = "KHR_materials_volume";
+class d {
+  /**
+   * @internal
+   */
+  constructor(t) {
+    this.name = i, this.order = 173, this._loader = t, this.enabled = this._loader.isExtensionUsed(i), this.enabled && this._loader._disableInstancedMesh++;
+  }
+  /** @internal */
+  dispose() {
+    this.enabled && this._loader._disableInstancedMesh--, this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadMaterialPropertiesAsync(t, u, e) {
+    return c.LoadExtensionAsync(t, u, this.name, (s, o) => {
+      const r = new Array();
+      return r.push(this._loader.loadMaterialBasePropertiesAsync(t, u, e)), r.push(this._loader.loadMaterialPropertiesAsync(t, u, e)), r.push(this._loadVolumePropertiesAsync(s, u, e, o)), Promise.all(r).then(() => {
+      });
+    });
+  }
+  _loadVolumePropertiesAsync(t, u, e, s) {
+    if (!(e instanceof a))
+      throw new Error(`${t}: Material type not supported`);
+    if (!e.subSurface.isRefractionEnabled && !e.subSurface.isTranslucencyEnabled || !s.thicknessFactor)
+      return Promise.resolve();
+    e.subSurface.volumeIndexOfRefraction = e.indexOfRefraction;
+    const o = s.attenuationDistance !== void 0 ? s.attenuationDistance : Number.MAX_VALUE;
+    return e.subSurface.tintColorAtDistance = o, s.attenuationColor !== void 0 && s.attenuationColor.length == 3 && e.subSurface.tintColor.copyFromFloats(s.attenuationColor[0], s.attenuationColor[1], s.attenuationColor[2]), e.subSurface.minimumThickness = 0, e.subSurface.maximumThickness = s.thicknessFactor, e.subSurface.useThicknessAsDepth = !0, s.thicknessTexture ? (s.thicknessTexture.nonColorData = !0, this._loader.loadTextureInfoAsync(`${t}/thicknessTexture`, s.thicknessTexture).then((r) => {
+      e.subSurface.thicknessTexture = r, e.subSurface.useGltfStyleTextures = !0;
+    })) : Promise.resolve();
+  }
+}
+c.RegisterExtension(i, (n) => new d(n));
+export {
+  d as KHR_materials_volume
+};

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

@@ -0,0 +1,17 @@
+import { GLTFLoader as n } from "../glTFLoader.esm.js";
+const s = "KHR_mesh_quantization";
+class i {
+  /**
+   * @internal
+   */
+  constructor(t) {
+    this.name = s, this.enabled = t.isExtensionUsed(s);
+  }
+  /** @internal */
+  dispose() {
+  }
+}
+n.RegisterExtension(s, (e) => new i(e));
+export {
+  i as KHR_mesh_quantization
+};

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

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

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

@@ -0,0 +1,29 @@
+import { Texture as c } from "../../../../core/Materials/Textures/texture.esm.js";
+import { GLTFLoader as i } from "../glTFLoader.esm.js";
+const s = "KHR_texture_transform";
+class h {
+  /**
+   * @internal
+   */
+  constructor(o) {
+    this.name = s, this._loader = o, this.enabled = this._loader.isExtensionUsed(s);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * @internal
+   */
+  loadTextureInfoAsync(o, d, e) {
+    return i.LoadExtensionAsync(o, d, this.name, (a, t) => this._loader.loadTextureInfoAsync(o, d, (r) => {
+      if (!(r instanceof c))
+        throw new Error(`${a}: Texture type not supported`);
+      t.offset && (r.uOffset = t.offset[0], r.vOffset = t.offset[1]), r.uRotationCenter = 0, r.vRotationCenter = 0, t.rotation && (r.wAng = -t.rotation), t.scale && (r.uScale = t.scale[0], r.vScale = t.scale[1]), t.texCoord != null && (r.coordinatesIndex = t.texCoord), e(r);
+    }));
+  }
+}
+i.RegisterExtension(s, (f) => new h(f));
+export {
+  h as KHR_texture_transform
+};

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

@@ -0,0 +1,31 @@
+import { GLTFLoader as d } from "../glTFLoader.esm.js";
+const a = "KHR_xmp_json_ld";
+class _ {
+  /**
+   * @internal
+   */
+  constructor(o) {
+    this.name = a, this.order = 100, this._loader = o, this.enabled = this._loader.isExtensionUsed(a);
+  }
+  /** @internal */
+  dispose() {
+    this._loader = null;
+  }
+  /**
+   * Called after the loader state changes to LOADING.
+   */
+  onLoading() {
+    var o, s, e;
+    if (this._loader.rootBabylonMesh === null)
+      return;
+    const t = (o = this._loader.gltf.extensions) === null || o === void 0 ? void 0 : o.KHR_xmp_json_ld, l = (e = (s = this._loader.gltf.asset) === null || s === void 0 ? void 0 : s.extensions) === null || e === void 0 ? void 0 : e.KHR_xmp_json_ld;
+    if (t && l) {
+      const i = +l.packet;
+      t.packets && i < t.packets.length && (this._loader.rootBabylonMesh.metadata = this._loader.rootBabylonMesh.metadata || {}, this._loader.rootBabylonMesh.metadata.xmp = t.packets[i]);
+    }
+  }
+}
+d.RegisterExtension(a, (n) => new _(n));
+export {
+  _ as KHR_xmp_json_ld
+};