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

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

@@ -1,41 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,178 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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
-};