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

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

@@ -1,1562 +0,0 @@
-import { Deferred as U } from "../../../core/Misc/deferred.esm.js";
-import { Vector3 as T, Quaternion as I, Matrix as P, TmpVectors as O } from "../../../core/Maths/math.vector.esm.js";
-import { Color3 as R } from "../../../core/Maths/math.color.esm.js";
-import { Tools as L } from "../../../core/Misc/tools.esm.js";
-import { Camera as W } from "../../../core/Cameras/camera.esm.js";
-import { FreeCamera as K } from "../../../core/Cameras/freeCamera.esm.js";
-import { AnimationKeyInterpolation as z } from "../../../core/Animations/animationKey.esm.js";
-import { AnimationGroup as H } from "../../../core/Animations/animationGroup.esm.js";
-import { Bone as X } from "../../../core/Bones/bone.esm.js";
-import { Skeleton as Z } from "../../../core/Bones/skeleton.esm.js";
-import { Material as C } from "../../../core/Materials/material.esm.js";
-import { PBRMaterial as M } from "../../../core/Materials/PBR/pbrMaterial.esm.js";
-import { Texture as A } from "../../../core/Materials/Textures/texture.esm.js";
-import { TransformNode as k } from "../../../core/Meshes/transformNode.esm.js";
-import { VertexBuffer as p, Buffer as Q } from "../../../core/Buffers/buffer.esm.js";
-import { Geometry as J } from "../../../core/Meshes/geometry.esm.js";
-import { Mesh as V } from "../../../core/Meshes/mesh.esm.js";
-import { MorphTarget as Y } from "../../../core/Morph/morphTarget.esm.js";
-import { MorphTargetManager as j } from "../../../core/Morph/morphTargetManager.esm.js";
-import { GLTFFileLoader as q, GLTFLoaderState as x, GLTFLoaderCoordinateSystemMode as D, GLTFLoaderAnimationStartMode as B } from "../glTFFileLoader.esm.js";
-import { IsBase64DataUrl as ee, DecodeBase64UrlToBinary as te, LoadFileError as ne } from "../../../core/Misc/fileTools.esm.js";
-import { Logger as $ } from "../../../core/Misc/logger.esm.js";
-import { BoundingInfo as se } from "../../../core/Culling/boundingInfo.esm.js";
-import { nodeAnimationData as N } from "./glTFLoaderAnimation.esm.js";
-function F(...v) {
-  const t = (e) => e && typeof e == "object";
-  return v.reduce((e, n) => (Object.keys(n).forEach((s) => {
-    const r = e[s], o = n[s];
-    Array.isArray(r) && Array.isArray(o) ? e[s] = r.concat(...o) : t(r) && t(o) ? e[s] = F(r, o) : e[s] = o;
-  }), e), {});
-}
-class c {
-  /**
-   * Gets an item from the given array.
-   * @param context The context when loading the asset
-   * @param array The array to get the item from
-   * @param index The index to the array
-   * @returns The array item
-   */
-  static Get(t, e, n) {
-    if (!e || n == null || !e[n])
-      throw new Error(`${t}: Failed to find index (${n})`);
-    return e[n];
-  }
-  /**
-   * Assign an `index` field to each item of the given array.
-   * @param array The array of items
-   */
-  static Assign(t) {
-    if (t)
-      for (let e = 0; e < t.length; e++)
-        t[e].index = e;
-  }
-}
-class u {
-  /**
-   * Registers a loader extension.
-   * @param name The name of the loader extension.
-   * @param factory The factory function that creates the loader extension.
-   */
-  static RegisterExtension(t, e) {
-    u.UnregisterExtension(t) && $.Warn(`Extension with the name '${t}' already exists`), u._RegisteredExtensions[t] = {
-      factory: e
-    };
-  }
-  /**
-   * Unregisters a loader extension.
-   * @param name The name of the loader extension.
-   * @returns A boolean indicating whether the extension has been unregistered
-   */
-  static UnregisterExtension(t) {
-    return u._RegisteredExtensions[t] ? (delete u._RegisteredExtensions[t], !0) : !1;
-  }
-  /**
-   * The object that represents the glTF JSON.
-   */
-  get gltf() {
-    if (!this._gltf)
-      throw new Error("glTF JSON is not available");
-    return this._gltf;
-  }
-  /**
-   * The BIN chunk of a binary glTF.
-   */
-  get bin() {
-    return this._bin;
-  }
-  /**
-   * The parent file loader.
-   */
-  get parent() {
-    return this._parent;
-  }
-  /**
-   * The Babylon scene when loading the asset.
-   */
-  get babylonScene() {
-    if (!this._babylonScene)
-      throw new Error("Scene is not available");
-    return this._babylonScene;
-  }
-  /**
-   * The root Babylon mesh when loading the asset.
-   */
-  get rootBabylonMesh() {
-    return this._rootBabylonMesh;
-  }
-  /**
-   * @internal
-   */
-  constructor(t) {
-    this._completePromises = new Array(), this._assetContainer = null, this._babylonLights = [], this._disableInstancedMesh = 0, this._extensions = new Array(), this._disposed = !1, this._rootUrl = null, this._fileName = null, this._uniqueRootUrl = null, this._bin = null, this._rootBabylonMesh = null, this._defaultBabylonMaterialData = {}, this._postSceneLoadActions = new Array(), this._parent = t;
-  }
-  /** @internal */
-  dispose() {
-    this._disposed || (this._disposed = !0, this._completePromises.length = 0, this._extensions.forEach((t) => t.dispose && t.dispose()), this._extensions.length = 0, this._gltf = null, this._bin = null, this._babylonScene = null, this._rootBabylonMesh = null, this._defaultBabylonMaterialData = {}, this._postSceneLoadActions.length = 0, this._parent.dispose());
-  }
-  /**
-   * @internal
-   */
-  importMeshAsync(t, e, n, s, r, o, i = "") {
-    return Promise.resolve().then(() => {
-      this._babylonScene = e, this._assetContainer = n, this._loadData(s);
-      let a = null;
-      if (t) {
-        const l = {};
-        if (this._gltf.nodes)
-          for (const f of this._gltf.nodes)
-            f.name && (l[f.name] = f.index);
-        a = (t instanceof Array ? t : [t]).map((f) => {
-          const d = l[f];
-          if (d === void 0)
-            throw new Error(`Failed to find node '${f}'`);
-          return d;
-        });
-      }
-      return this._loadAsync(r, i, a, () => ({
-        meshes: this._getMeshes(),
-        particleSystems: [],
-        skeletons: this._getSkeletons(),
-        animationGroups: this._getAnimationGroups(),
-        lights: this._babylonLights,
-        transformNodes: this._getTransformNodes(),
-        geometries: this._getGeometries()
-      }));
-    });
-  }
-  /**
-   * @internal
-   */
-  loadAsync(t, e, n, s, r = "") {
-    return Promise.resolve().then(() => (this._babylonScene = t, this._loadData(e), this._loadAsync(n, r, null, () => {
-    })));
-  }
-  _loadAsync(t, e, n, s) {
-    return Promise.resolve().then(() => {
-      this._rootUrl = t, this._uniqueRootUrl = !t.startsWith("file:") && e ? t : `${t}${Date.now()}/`, this._fileName = e, this._loadExtensions(), this._checkExtensions();
-      const r = `${x[x.LOADING]} => ${x[x.READY]}`, o = `${x[x.LOADING]} => ${x[x.COMPLETE]}`;
-      this._parent._startPerformanceCounter(r), this._parent._startPerformanceCounter(o), this._parent._setState(x.LOADING), this._extensionsOnLoading();
-      const i = new Array(), a = this._babylonScene.blockMaterialDirtyMechanism;
-      if (this._babylonScene.blockMaterialDirtyMechanism = !0, !this.parent.loadOnlyMaterials) {
-        if (n)
-          i.push(this.loadSceneAsync("/nodes", { nodes: n, index: -1 }));
-        else if (this._gltf.scene != null || this._gltf.scenes && this._gltf.scenes[0]) {
-          const h = c.Get("/scene", this._gltf.scenes, this._gltf.scene || 0);
-          i.push(this.loadSceneAsync(`/scenes/${h.index}`, h));
-        }
-      }
-      if (!this.parent.skipMaterials && this.parent.loadAllMaterials && this._gltf.materials)
-        for (let h = 0; h < this._gltf.materials.length; ++h) {
-          const f = this._gltf.materials[h], d = "/materials/" + h, m = C.TriangleFillMode;
-          i.push(this._loadMaterialAsync(d, f, null, m, () => {
-          }));
-        }
-      return this._babylonScene.blockMaterialDirtyMechanism = a, this._parent.compileMaterials && i.push(this._compileMaterialsAsync()), this._parent.compileShadowGenerators && i.push(this._compileShadowGeneratorsAsync()), Promise.all(i).then(() => (this._rootBabylonMesh && this._rootBabylonMesh.setEnabled(!0), this._extensionsOnReady(), this._parent._setState(x.READY), this._startAnimations(), s())).then((h) => (this._parent._endPerformanceCounter(r), L.SetImmediate(() => {
-        this._disposed || Promise.all(this._completePromises).then(() => {
-          this._parent._endPerformanceCounter(o), this._parent._setState(x.COMPLETE), this._parent.onCompleteObservable.notifyObservers(void 0), this._parent.onCompleteObservable.clear(), this.dispose();
-        }, (f) => {
-          this._parent.onErrorObservable.notifyObservers(f), this._parent.onErrorObservable.clear(), this.dispose();
-        });
-      }), h));
-    }).catch((r) => {
-      throw this._disposed || (this._parent.onErrorObservable.notifyObservers(r), this._parent.onErrorObservable.clear(), this.dispose()), r;
-    });
-  }
-  _loadData(t) {
-    if (this._gltf = t.json, this._setupData(), t.bin) {
-      const e = this._gltf.buffers;
-      if (e && e[0] && !e[0].uri) {
-        const n = e[0];
-        (n.byteLength < t.bin.byteLength - 3 || n.byteLength > t.bin.byteLength) && $.Warn(`Binary buffer length (${n.byteLength}) from JSON does not match chunk length (${t.bin.byteLength})`), this._bin = t.bin;
-      } else
-        $.Warn("Unexpected BIN chunk");
-    }
-  }
-  _setupData() {
-    if (c.Assign(this._gltf.accessors), c.Assign(this._gltf.animations), c.Assign(this._gltf.buffers), c.Assign(this._gltf.bufferViews), c.Assign(this._gltf.cameras), c.Assign(this._gltf.images), c.Assign(this._gltf.materials), c.Assign(this._gltf.meshes), c.Assign(this._gltf.nodes), c.Assign(this._gltf.samplers), c.Assign(this._gltf.scenes), c.Assign(this._gltf.skins), c.Assign(this._gltf.textures), this._gltf.nodes) {
-      const t = {};
-      for (const n of this._gltf.nodes)
-        if (n.children)
-          for (const s of n.children)
-            t[s] = n.index;
-      const e = this._createRootNode();
-      for (const n of this._gltf.nodes) {
-        const s = t[n.index];
-        n.parent = s === void 0 ? e : this._gltf.nodes[s];
-      }
-    }
-  }
-  _loadExtensions() {
-    for (const t in u._RegisteredExtensions) {
-      const e = u._RegisteredExtensions[t].factory(this);
-      e.name !== t && $.Warn(`The name of the glTF loader extension instance does not match the registered name: ${e.name} !== ${t}`), this._extensions.push(e), this._parent.onExtensionLoadedObservable.notifyObservers(e);
-    }
-    this._extensions.sort((t, e) => (t.order || Number.MAX_VALUE) - (e.order || Number.MAX_VALUE)), this._parent.onExtensionLoadedObservable.clear();
-  }
-  _checkExtensions() {
-    if (this._gltf.extensionsRequired) {
-      for (const t of this._gltf.extensionsRequired)
-        if (!this._extensions.some((n) => n.name === t && n.enabled))
-          throw new Error(`Require extension ${t} is not available`);
-    }
-  }
-  _createRootNode() {
-    this._babylonScene._blockEntityCollection = !!this._assetContainer, this._rootBabylonMesh = new V("__root__", this._babylonScene), this._rootBabylonMesh._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, this._rootBabylonMesh.setEnabled(!1);
-    const t = {
-      _babylonTransformNode: this._rootBabylonMesh,
-      index: -1
-    };
-    switch (this._parent.coordinateSystemMode) {
-      case D.AUTO: {
-        this._babylonScene.useRightHandedSystem || (t.rotation = [0, 1, 0, 0], t.scale = [1, 1, -1], u._LoadTransform(t, this._rootBabylonMesh));
-        break;
-      }
-      case D.FORCE_RIGHT_HANDED: {
-        this._babylonScene.useRightHandedSystem = !0;
-        break;
-      }
-      default:
-        throw new Error(`Invalid coordinate system mode (${this._parent.coordinateSystemMode})`);
-    }
-    return this._parent.onMeshLoadedObservable.notifyObservers(this._rootBabylonMesh), t;
-  }
-  /**
-   * Loads a glTF scene.
-   * @param context The context when loading the asset
-   * @param scene The glTF scene property
-   * @returns A promise that resolves when the load is complete
-   */
-  loadSceneAsync(t, e) {
-    const n = this._extensionsLoadSceneAsync(t, e);
-    if (n)
-      return n;
-    const s = new Array();
-    if (this.logOpen(`${t} ${e.name || ""}`), e.nodes)
-      for (const r of e.nodes) {
-        const o = c.Get(`${t}/nodes/${r}`, this._gltf.nodes, r);
-        s.push(this.loadNodeAsync(`/nodes/${o.index}`, o, (i) => {
-          i.parent = this._rootBabylonMesh;
-        }));
-      }
-    for (const r of this._postSceneLoadActions)
-      r();
-    return s.push(this._loadAnimationsAsync()), this.logClose(), Promise.all(s).then(() => {
-    });
-  }
-  _forEachPrimitive(t, e) {
-    if (t._primitiveBabylonMeshes)
-      for (const n of t._primitiveBabylonMeshes)
-        e(n);
-  }
-  _getGeometries() {
-    const t = new Array(), e = this._gltf.nodes;
-    if (e)
-      for (const n of e)
-        this._forEachPrimitive(n, (s) => {
-          const r = s.geometry;
-          r && t.indexOf(r) === -1 && t.push(r);
-        });
-    return t;
-  }
-  _getMeshes() {
-    const t = new Array();
-    this._rootBabylonMesh && t.push(this._rootBabylonMesh);
-    const e = this._gltf.nodes;
-    if (e)
-      for (const n of e)
-        this._forEachPrimitive(n, (s) => {
-          t.push(s);
-        });
-    return t;
-  }
-  _getTransformNodes() {
-    const t = new Array(), e = this._gltf.nodes;
-    if (e)
-      for (const n of e)
-        n._babylonTransformNode && n._babylonTransformNode.getClassName() === "TransformNode" && t.push(n._babylonTransformNode), n._babylonTransformNodeForSkin && t.push(n._babylonTransformNodeForSkin);
-    return t;
-  }
-  _getSkeletons() {
-    const t = new Array(), e = this._gltf.skins;
-    if (e)
-      for (const n of e)
-        n._data && t.push(n._data.babylonSkeleton);
-    return t;
-  }
-  _getAnimationGroups() {
-    const t = new Array(), e = this._gltf.animations;
-    if (e)
-      for (const n of e)
-        n._babylonAnimationGroup && t.push(n._babylonAnimationGroup);
-    return t;
-  }
-  _startAnimations() {
-    switch (this._parent.animationStartMode) {
-      case B.NONE:
-        break;
-      case B.FIRST: {
-        const t = this._getAnimationGroups();
-        t.length !== 0 && t[0].start(!0);
-        break;
-      }
-      case B.ALL: {
-        const t = this._getAnimationGroups();
-        for (const e of t)
-          e.start(!0);
-        break;
-      }
-      default: {
-        $.Error(`Invalid animation start mode (${this._parent.animationStartMode})`);
-        return;
-      }
-    }
-  }
-  /**
-   * Loads a glTF node.
-   * @param context The context when loading the asset
-   * @param node The glTF node property
-   * @param assign A function called synchronously after parsing the glTF properties
-   * @returns A promise that resolves with the loaded Babylon mesh when the load is complete
-   */
-  loadNodeAsync(t, e, n = () => {
-  }) {
-    const s = this._extensionsLoadNodeAsync(t, e, n);
-    if (s)
-      return s;
-    if (e._babylonTransformNode)
-      throw new Error(`${t}: Invalid recursive node hierarchy`);
-    const r = new Array();
-    this.logOpen(`${t} ${e.name || ""}`);
-    const o = (i) => {
-      if (u.AddPointerMetadata(i, t), u._LoadTransform(e, i), e.camera != null) {
-        const a = c.Get(`${t}/camera`, this._gltf.cameras, e.camera);
-        r.push(this.loadCameraAsync(`/cameras/${a.index}`, a, (l) => {
-          l.parent = i;
-        }));
-      }
-      if (e.children)
-        for (const a of e.children) {
-          const l = c.Get(`${t}/children/${a}`, this._gltf.nodes, a);
-          r.push(this.loadNodeAsync(`/nodes/${l.index}`, l, (h) => {
-            h.parent = i;
-          }));
-        }
-      n(i);
-    };
-    if (e.mesh == null || e.skin != null) {
-      const i = e.name || `node${e.index}`;
-      this._babylonScene._blockEntityCollection = !!this._assetContainer;
-      const a = new k(i, this._babylonScene);
-      a._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, e.mesh == null ? e._babylonTransformNode = a : e._babylonTransformNodeForSkin = a, o(a);
-    }
-    if (e.mesh != null)
-      if (e.skin == null) {
-        const i = c.Get(`${t}/mesh`, this._gltf.meshes, e.mesh);
-        r.push(this._loadMeshAsync(`/meshes/${i.index}`, e, i, o));
-      } else {
-        const i = c.Get(`${t}/mesh`, this._gltf.meshes, e.mesh);
-        r.push(this._loadMeshAsync(`/meshes/${i.index}`, e, i, (a) => {
-          const l = e._babylonTransformNodeForSkin;
-          a.metadata = F(l.metadata, a.metadata || {});
-          const h = c.Get(`${t}/skin`, this._gltf.skins, e.skin);
-          r.push(this._loadSkinAsync(`/skins/${h.index}`, e, h, (f) => {
-            this._forEachPrimitive(e, (d) => {
-              d.skeleton = f;
-            }), this._postSceneLoadActions.push(() => {
-              if (h.skeleton != null) {
-                const d = c.Get(`/skins/${h.index}/skeleton`, this._gltf.nodes, h.skeleton).parent;
-                e.index === d.index ? a.parent = l.parent : a.parent = d._babylonTransformNode;
-              } else
-                a.parent = this._rootBabylonMesh;
-              this._parent.onSkinLoadedObservable.notifyObservers({ node: l, skinnedNode: a });
-            });
-          }));
-        }));
-      }
-    return this.logClose(), Promise.all(r).then(() => (this._forEachPrimitive(e, (i) => {
-      i.geometry && i.geometry.useBoundingInfoFromGeometry ? i._updateBoundingInfo() : i.refreshBoundingInfo(!0);
-    }), e._babylonTransformNode));
-  }
-  _loadMeshAsync(t, e, n, s) {
-    const r = n.primitives;
-    if (!r || !r.length)
-      throw new Error(`${t}: Primitives are missing`);
-    r[0].index == null && c.Assign(r);
-    const o = new Array();
-    this.logOpen(`${t} ${n.name || ""}`);
-    const i = e.name || `node${e.index}`;
-    if (r.length === 1) {
-      const a = n.primitives[0];
-      o.push(this._loadMeshPrimitiveAsync(`${t}/primitives/${a.index}`, i, e, n, a, (l) => {
-        e._babylonTransformNode = l, e._primitiveBabylonMeshes = [l];
-      }));
-    } else {
-      this._babylonScene._blockEntityCollection = !!this._assetContainer, e._babylonTransformNode = new k(i, this._babylonScene), e._babylonTransformNode._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, e._primitiveBabylonMeshes = [];
-      for (const a of r)
-        o.push(this._loadMeshPrimitiveAsync(`${t}/primitives/${a.index}`, `${i}_primitive${a.index}`, e, n, a, (l) => {
-          l.parent = e._babylonTransformNode, e._primitiveBabylonMeshes.push(l);
-        }));
-    }
-    return s(e._babylonTransformNode), this.logClose(), Promise.all(o).then(() => e._babylonTransformNode);
-  }
-  /**
-   * @internal Define this method to modify the default behavior when loading data for mesh primitives.
-   * @param context The context when loading the asset
-   * @param name The mesh name when loading the asset
-   * @param node The glTF node when loading the asset
-   * @param mesh The glTF mesh when loading the asset
-   * @param primitive The glTF mesh primitive property
-   * @param assign A function called synchronously after parsing the glTF properties
-   * @returns A promise that resolves with the loaded mesh when the load is complete or null if not handled
-   */
-  _loadMeshPrimitiveAsync(t, e, n, s, r, o) {
-    const i = this._extensionsLoadMeshPrimitiveAsync(t, e, n, s, r, o);
-    if (i)
-      return i;
-    this.logOpen(`${t}`);
-    const a = this._disableInstancedMesh === 0 && this._parent.createInstances && n.skin == null && !s.primitives[0].targets;
-    let l, h;
-    if (a && r._instanceData)
-      this._babylonScene._blockEntityCollection = !!this._assetContainer, l = r._instanceData.babylonSourceMesh.createInstance(e), l._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, h = r._instanceData.promise;
-    else {
-      const f = new Array();
-      this._babylonScene._blockEntityCollection = !!this._assetContainer;
-      const d = new V(e, this._babylonScene);
-      d._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, d.overrideMaterialSideOrientation = this._babylonScene.useRightHandedSystem ? C.CounterClockWiseSideOrientation : C.ClockWiseSideOrientation, this._createMorphTargets(t, n, s, r, d), f.push(this._loadVertexDataAsync(t, r, d).then((_) => this._loadMorphTargetsAsync(t, r, d, _).then(() => {
-        this._disposed || (this._babylonScene._blockEntityCollection = !!this._assetContainer, _.applyToMesh(d), _._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1);
-      })));
-      const m = u._GetDrawMode(t, r.mode);
-      if (r.material == null) {
-        let _ = this._defaultBabylonMaterialData[m];
-        _ || (_ = this._createDefaultMaterial("__GLTFLoader._default", m), this._parent.onMaterialLoadedObservable.notifyObservers(_), this._defaultBabylonMaterialData[m] = _), d.material = _;
-      } else if (!this.parent.skipMaterials) {
-        const _ = c.Get(`${t}/material`, this._gltf.materials, r.material);
-        f.push(this._loadMaterialAsync(`/materials/${_.index}`, _, d, m, (E) => {
-          d.material = E;
-        }));
-      }
-      h = Promise.all(f), a && (r._instanceData = {
-        babylonSourceMesh: d,
-        promise: h
-      }), l = d;
-    }
-    return u.AddPointerMetadata(l, t), this._parent.onMeshLoadedObservable.notifyObservers(l), o(l), this.logClose(), h.then(() => l);
-  }
-  _loadVertexDataAsync(t, e, n) {
-    const s = this._extensionsLoadVertexDataAsync(t, e, n);
-    if (s)
-      return s;
-    const r = e.attributes;
-    if (!r)
-      throw new Error(`${t}: Attributes are missing`);
-    const o = new Array(), i = new J(n.name, this._babylonScene);
-    if (e.indices == null)
-      n.isUnIndexed = !0;
-    else {
-      const l = c.Get(`${t}/indices`, this._gltf.accessors, e.indices);
-      o.push(this._loadIndicesAccessorAsync(`/accessors/${l.index}`, l).then((h) => {
-        i.setIndices(h);
-      }));
-    }
-    const a = (l, h, f) => {
-      if (r[l] == null)
-        return;
-      n._delayInfo = n._delayInfo || [], n._delayInfo.indexOf(h) === -1 && n._delayInfo.push(h);
-      const d = c.Get(`${t}/attributes/${l}`, this._gltf.accessors, r[l]);
-      o.push(this._loadVertexAccessorAsync(`/accessors/${d.index}`, d, h).then((m) => {
-        if (m.getKind() === p.PositionKind && !this.parent.alwaysComputeBoundingBox && !n.skeleton && d.min && d.max) {
-          const _ = O.Vector3[0].copyFromFloats(...d.min), E = O.Vector3[1].copyFromFloats(...d.max);
-          if (d.normalized && d.componentType !== 5126) {
-            let g = 1;
-            switch (d.componentType) {
-              case 5120:
-                g = 127;
-                break;
-              case 5121:
-                g = 255;
-                break;
-              case 5122:
-                g = 32767;
-                break;
-              case 5123:
-                g = 65535;
-                break;
-            }
-            const b = 1 / g;
-            _.scaleInPlace(b), E.scaleInPlace(b);
-          }
-          i._boundingInfo = new se(_, E), i.useBoundingInfoFromGeometry = !0;
-        }
-        i.setVerticesBuffer(m, d.count);
-      })), h == p.MatricesIndicesExtraKind && (n.numBoneInfluencers = 8), f && f(d);
-    };
-    return a("POSITION", p.PositionKind), a("NORMAL", p.NormalKind), a("TANGENT", p.TangentKind), a("TEXCOORD_0", p.UVKind), a("TEXCOORD_1", p.UV2Kind), a("TEXCOORD_2", p.UV3Kind), a("TEXCOORD_3", p.UV4Kind), a("TEXCOORD_4", p.UV5Kind), a("TEXCOORD_5", p.UV6Kind), a("JOINTS_0", p.MatricesIndicesKind), a("WEIGHTS_0", p.MatricesWeightsKind), a("JOINTS_1", p.MatricesIndicesExtraKind), a("WEIGHTS_1", p.MatricesWeightsExtraKind), a("COLOR_0", p.ColorKind, (l) => {
-      l.type === "VEC4" && (n.hasVertexAlpha = !0);
-    }), Promise.all(o).then(() => i);
-  }
-  _createMorphTargets(t, e, n, s, r) {
-    if (!s.targets)
-      return;
-    if (e._numMorphTargets == null)
-      e._numMorphTargets = s.targets.length;
-    else if (s.targets.length !== e._numMorphTargets)
-      throw new Error(`${t}: Primitives do not have the same number of targets`);
-    const o = n.extras ? n.extras.targetNames : null;
-    this._babylonScene._blockEntityCollection = !!this._assetContainer, r.morphTargetManager = new j(this._babylonScene), r.morphTargetManager._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, r.morphTargetManager.areUpdatesFrozen = !0;
-    for (let i = 0; i < s.targets.length; i++) {
-      const a = e.weights ? e.weights[i] : n.weights ? n.weights[i] : 0, l = o ? o[i] : `morphTarget${i}`;
-      r.morphTargetManager.addTarget(new Y(l, a, r.getScene()));
-    }
-  }
-  _loadMorphTargetsAsync(t, e, n, s) {
-    if (!e.targets)
-      return Promise.resolve();
-    const r = new Array(), o = n.morphTargetManager;
-    for (let i = 0; i < o.numTargets; i++) {
-      const a = o.getTarget(i);
-      r.push(this._loadMorphTargetVertexDataAsync(`${t}/targets/${i}`, s, e.targets[i], a));
-    }
-    return Promise.all(r).then(() => {
-      o.areUpdatesFrozen = !1;
-    });
-  }
-  _loadMorphTargetVertexDataAsync(t, e, n, s) {
-    const r = new Array(), o = (i, a, l) => {
-      if (n[i] == null)
-        return;
-      const h = e.getVertexBuffer(a);
-      if (!h)
-        return;
-      const f = c.Get(`${t}/${i}`, this._gltf.accessors, n[i]);
-      r.push(this._loadFloatAccessorAsync(`/accessors/${f.index}`, f).then((d) => {
-        l(h, d);
-      }));
-    };
-    return o("POSITION", p.PositionKind, (i, a) => {
-      const l = new Float32Array(a.length);
-      i.forEach(a.length, (h, f) => {
-        l[f] = a[f] + h;
-      }), s.setPositions(l);
-    }), o("NORMAL", p.NormalKind, (i, a) => {
-      const l = new Float32Array(a.length);
-      i.forEach(l.length, (h, f) => {
-        l[f] = a[f] + h;
-      }), s.setNormals(l);
-    }), o("TANGENT", p.TangentKind, (i, a) => {
-      const l = new Float32Array(a.length / 3 * 4);
-      let h = 0;
-      i.forEach(a.length / 3 * 4, (f, d) => {
-        (d + 1) % 4 !== 0 && (l[h] = a[h] + f, h++);
-      }), s.setTangents(l);
-    }), Promise.all(r).then(() => {
-    });
-  }
-  static _LoadTransform(t, e) {
-    if (t.skin != null)
-      return;
-    let n = T.Zero(), s = I.Identity(), r = T.One();
-    t.matrix ? P.FromArray(t.matrix).decompose(r, s, n) : (t.translation && (n = T.FromArray(t.translation)), t.rotation && (s = I.FromArray(t.rotation)), t.scale && (r = T.FromArray(t.scale))), e.position = n, e.rotationQuaternion = s, e.scaling = r;
-  }
-  _loadSkinAsync(t, e, n, s) {
-    const r = this._extensionsLoadSkinAsync(t, e, n);
-    if (r)
-      return r;
-    if (n._data)
-      return s(n._data.babylonSkeleton), n._data.promise;
-    const o = `skeleton${n.index}`;
-    this._babylonScene._blockEntityCollection = !!this._assetContainer;
-    const i = new Z(n.name || o, o, this._babylonScene);
-    i._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, this._loadBones(t, n, i);
-    const a = this._loadSkinInverseBindMatricesDataAsync(t, n).then((l) => {
-      this._updateBoneMatrices(i, l);
-    });
-    return n._data = {
-      babylonSkeleton: i,
-      promise: a
-    }, s(i), a;
-  }
-  _loadBones(t, e, n) {
-    if (e.skeleton == null || this._parent.alwaysComputeSkeletonRootNode) {
-      const r = this._findSkeletonRootNode(`${t}/joints`, e.joints);
-      if (r)
-        if (e.skeleton === void 0)
-          e.skeleton = r.index;
-        else {
-          const o = (a, l) => {
-            for (; l.parent; l = l.parent)
-              if (l.parent === a)
-                return !0;
-            return !1;
-          }, i = c.Get(`${t}/skeleton`, this._gltf.nodes, e.skeleton);
-          i !== r && !o(i, r) && ($.Warn(`${t}/skeleton: Overriding with nearest common ancestor as skeleton node is not a common root`), e.skeleton = r.index);
-        }
-      else
-        $.Warn(`${t}: Failed to find common root`);
-    }
-    const s = {};
-    for (const r of e.joints) {
-      const o = c.Get(`${t}/joints/${r}`, this._gltf.nodes, r);
-      this._loadBone(o, e, n, s);
-    }
-  }
-  _findSkeletonRootNode(t, e) {
-    if (e.length === 0)
-      return null;
-    const n = {};
-    for (const r of e) {
-      const o = new Array();
-      let i = c.Get(`${t}/${r}`, this._gltf.nodes, r);
-      for (; i.index !== -1; )
-        o.unshift(i), i = i.parent;
-      n[r] = o;
-    }
-    let s = null;
-    for (let r = 0; ; ++r) {
-      let o = n[e[0]];
-      if (r >= o.length)
-        return s;
-      const i = o[r];
-      for (let a = 1; a < e.length; ++a)
-        if (o = n[e[a]], r >= o.length || i !== o[r])
-          return s;
-      s = i;
-    }
-  }
-  _loadBone(t, e, n, s) {
-    let r = s[t.index];
-    if (r)
-      return r;
-    let o = null;
-    t.index !== e.skeleton && (t.parent && t.parent.index !== -1 ? o = this._loadBone(t.parent, e, n, s) : e.skeleton !== void 0 && $.Warn(`/skins/${e.index}/skeleton: Skeleton node is not a common root`));
-    const i = e.joints.indexOf(t.index);
-    return r = new X(t.name || `joint${t.index}`, n, o, this._getNodeMatrix(t), null, null, i), s[t.index] = r, this._postSceneLoadActions.push(() => {
-      r.linkTransformNode(t._babylonTransformNode);
-    }), r;
-  }
-  _loadSkinInverseBindMatricesDataAsync(t, e) {
-    if (e.inverseBindMatrices == null)
-      return Promise.resolve(null);
-    const n = c.Get(`${t}/inverseBindMatrices`, this._gltf.accessors, e.inverseBindMatrices);
-    return this._loadFloatAccessorAsync(`/accessors/${n.index}`, n);
-  }
-  _updateBoneMatrices(t, e) {
-    for (const n of t.bones) {
-      const s = P.Identity(), r = n._index;
-      e && r !== -1 && (P.FromArrayToRef(e, r * 16, s), s.invertToRef(s));
-      const o = n.getParent();
-      o && s.multiplyToRef(o.getAbsoluteInverseBindMatrix(), s), n.updateMatrix(s, !1, !1), n._updateAbsoluteBindMatrices(void 0, !1);
-    }
-  }
-  _getNodeMatrix(t) {
-    return t.matrix ? P.FromArray(t.matrix) : P.Compose(t.scale ? T.FromArray(t.scale) : T.One(), t.rotation ? I.FromArray(t.rotation) : I.Identity(), t.translation ? T.FromArray(t.translation) : T.Zero());
-  }
-  /**
-   * Loads a glTF camera.
-   * @param context The context when loading the asset
-   * @param camera The glTF camera property
-   * @param assign A function called synchronously after parsing the glTF properties
-   * @returns A promise that resolves with the loaded Babylon camera when the load is complete
-   */
-  loadCameraAsync(t, e, n = () => {
-  }) {
-    const s = this._extensionsLoadCameraAsync(t, e, n);
-    if (s)
-      return s;
-    const r = new Array();
-    this.logOpen(`${t} ${e.name || ""}`), this._babylonScene._blockEntityCollection = !!this._assetContainer;
-    const o = new K(e.name || `camera${e.index}`, T.Zero(), this._babylonScene, !1);
-    switch (o._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, o.ignoreParentScaling = !0, e._babylonCamera = o, o.rotation = new T(0, Math.PI, 0), e.type) {
-      case "perspective": {
-        const i = e.perspective;
-        if (!i)
-          throw new Error(`${t}: Camera perspective properties are missing`);
-        o.fov = i.yfov, o.minZ = i.znear, o.maxZ = i.zfar || 0;
-        break;
-      }
-      case "orthographic": {
-        if (!e.orthographic)
-          throw new Error(`${t}: Camera orthographic properties are missing`);
-        o.mode = W.ORTHOGRAPHIC_CAMERA, o.orthoLeft = -e.orthographic.xmag, o.orthoRight = e.orthographic.xmag, o.orthoBottom = -e.orthographic.ymag, o.orthoTop = e.orthographic.ymag, o.minZ = e.orthographic.znear, o.maxZ = e.orthographic.zfar;
-        break;
-      }
-      default:
-        throw new Error(`${t}: Invalid camera type (${e.type})`);
-    }
-    return u.AddPointerMetadata(o, t), this._parent.onCameraLoadedObservable.notifyObservers(o), n(o), this.logClose(), Promise.all(r).then(() => o);
-  }
-  _loadAnimationsAsync() {
-    const t = this._gltf.animations;
-    if (!t)
-      return Promise.resolve();
-    const e = new Array();
-    for (let n = 0; n < t.length; n++) {
-      const s = t[n];
-      e.push(this.loadAnimationAsync(`/animations/${s.index}`, s).then((r) => {
-        r.targetedAnimations.length === 0 && r.dispose();
-      }));
-    }
-    return Promise.all(e).then(() => {
-    });
-  }
-  /**
-   * Loads a glTF animation.
-   * @param context The context when loading the asset
-   * @param animation The glTF animation property
-   * @returns A promise that resolves with the loaded Babylon animation group when the load is complete
-   */
-  loadAnimationAsync(t, e) {
-    const n = this._extensionsLoadAnimationAsync(t, e);
-    if (n)
-      return n;
-    this._babylonScene._blockEntityCollection = !!this._assetContainer;
-    const s = new H(e.name || `animation${e.index}`, this._babylonScene);
-    s._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, e._babylonAnimationGroup = s;
-    const r = new Array();
-    c.Assign(e.channels), c.Assign(e.samplers);
-    for (const o of e.channels)
-      r.push(this._loadAnimationChannelAsync(`${t}/channels/${o.index}`, t, e, o, (i, a) => {
-        i.animations = i.animations || [], i.animations.push(a), s.addTargetedAnimation(a, i);
-      }));
-    return Promise.all(r).then(() => (s.normalize(0), s));
-  }
-  /**
-   * @hidden
-   * Loads a glTF animation channel.
-   * @param context The context when loading the asset
-   * @param animationContext The context of the animation when loading the asset
-   * @param animation The glTF animation property
-   * @param channel The glTF animation channel property
-   * @param onLoad Called for each animation loaded
-   * @returns A void promise that resolves when the load is complete
-   */
-  _loadAnimationChannelAsync(t, e, n, s, r) {
-    const o = this._extensionsLoadAnimationChannelAsync(t, e, n, s, r);
-    if (o)
-      return o;
-    if (s.target.node == null)
-      return Promise.resolve();
-    const i = c.Get(`${t}/target/node`, this._gltf.nodes, s.target.node);
-    if (s.target.path === "weights" && !i._numMorphTargets || s.target.path !== "weights" && !i._babylonTransformNode)
-      return Promise.resolve();
-    let a;
-    switch (s.target.path) {
-      case "translation": {
-        a = N.translation;
-        break;
-      }
-      case "rotation": {
-        a = N.rotation;
-        break;
-      }
-      case "scale": {
-        a = N.scale;
-        break;
-      }
-      case "weights": {
-        a = N.weights;
-        break;
-      }
-      default:
-        throw new Error(`${t}/target/path: Invalid value (${s.target.path})`);
-    }
-    const l = {
-      target: i,
-      properties: a
-    };
-    return this._loadAnimationChannelFromTargetInfoAsync(t, e, n, s, l, r);
-  }
-  /**
-   * @hidden
-   * Loads a glTF animation channel.
-   * @param context The context when loading the asset
-   * @param animationContext The context of the animation when loading the asset
-   * @param animation The glTF animation property
-   * @param channel The glTF animation channel property
-   * @param targetInfo The glTF target and properties
-   * @param onLoad Called for each animation loaded
-   * @returns A void promise that resolves when the load is complete
-   */
-  _loadAnimationChannelFromTargetInfoAsync(t, e, n, s, r, o) {
-    const i = this.parent.targetFps, a = 1 / i, l = c.Get(`${t}/sampler`, n.samplers, s.sampler);
-    return this._loadAnimationSamplerAsync(`${e}/samplers/${s.sampler}`, l).then((h) => {
-      let f = 0;
-      for (const d of r.properties) {
-        const m = d.getStride(r.target), _ = h.input, E = h.output, g = new Array(_.length);
-        let b = 0;
-        switch (h.interpolation) {
-          case "STEP": {
-            for (let y = 0; y < _.length; y++) {
-              const w = d.getValue(r.target, E, b, 1);
-              b += m, g[y] = {
-                frame: _[y] * i,
-                value: w,
-                interpolation: z.STEP
-              };
-            }
-            break;
-          }
-          case "CUBICSPLINE": {
-            for (let y = 0; y < _.length; y++) {
-              const w = d.getValue(r.target, E, b, a);
-              b += m;
-              const S = d.getValue(r.target, E, b, 1);
-              b += m;
-              const G = d.getValue(r.target, E, b, a);
-              b += m, g[y] = {
-                frame: _[y] * i,
-                inTangent: w,
-                value: S,
-                outTangent: G
-              };
-            }
-            break;
-          }
-          case "LINEAR": {
-            for (let y = 0; y < _.length; y++) {
-              const w = d.getValue(r.target, E, b, 1);
-              b += m, g[y] = {
-                frame: _[y] * i,
-                value: w
-              };
-            }
-            break;
-          }
-        }
-        if (b > 0) {
-          const y = `${n.name || `animation${n.index}`}_channel${s.index}_${f}`;
-          d.buildAnimations(r.target, y, i, g, (w, S) => {
-            ++f, o(w, S);
-          });
-        }
-      }
-    });
-  }
-  _loadAnimationSamplerAsync(t, e) {
-    if (e._data)
-      return e._data;
-    const n = e.interpolation || "LINEAR";
-    switch (n) {
-      case "STEP":
-      case "LINEAR":
-      case "CUBICSPLINE":
-        break;
-      default:
-        throw new Error(`${t}/interpolation: Invalid value (${e.interpolation})`);
-    }
-    const s = c.Get(`${t}/input`, this._gltf.accessors, e.input), r = c.Get(`${t}/output`, this._gltf.accessors, e.output);
-    return e._data = Promise.all([
-      this._loadFloatAccessorAsync(`/accessors/${s.index}`, s),
-      this._loadFloatAccessorAsync(`/accessors/${r.index}`, r)
-    ]).then(([o, i]) => ({
-      input: o,
-      interpolation: n,
-      output: i
-    })), e._data;
-  }
-  /**
-   * Loads a glTF buffer.
-   * @param context The context when loading the asset
-   * @param buffer The glTF buffer property
-   * @param byteOffset The byte offset to use
-   * @param byteLength The byte length to use
-   * @returns A promise that resolves with the loaded data when the load is complete
-   */
-  loadBufferAsync(t, e, n, s) {
-    const r = this._extensionsLoadBufferAsync(t, e, n, s);
-    if (r)
-      return r;
-    if (!e._data)
-      if (e.uri)
-        e._data = this.loadUriAsync(`${t}/uri`, e, e.uri);
-      else {
-        if (!this._bin)
-          throw new Error(`${t}: Uri is missing or the binary glTF is missing its binary chunk`);
-        e._data = this._bin.readAsync(0, e.byteLength);
-      }
-    return e._data.then((o) => {
-      try {
-        return new Uint8Array(o.buffer, o.byteOffset + n, s);
-      } catch (i) {
-        throw new Error(`${t}: ${i.message}`);
-      }
-    });
-  }
-  /**
-   * Loads a glTF buffer view.
-   * @param context The context when loading the asset
-   * @param bufferView The glTF buffer view property
-   * @returns A promise that resolves with the loaded data when the load is complete
-   */
-  loadBufferViewAsync(t, e) {
-    const n = this._extensionsLoadBufferViewAsync(t, e);
-    if (n)
-      return n;
-    if (e._data)
-      return e._data;
-    const s = c.Get(`${t}/buffer`, this._gltf.buffers, e.buffer);
-    return e._data = this.loadBufferAsync(`/buffers/${s.index}`, s, e.byteOffset || 0, e.byteLength), e._data;
-  }
-  _loadAccessorAsync(t, e, n) {
-    if (e._data)
-      return e._data;
-    const s = u._GetNumComponents(t, e.type), r = s * p.GetTypeByteLength(e.componentType), o = s * e.count;
-    if (e.bufferView == null)
-      e._data = Promise.resolve(new n(o));
-    else {
-      const i = c.Get(`${t}/bufferView`, this._gltf.bufferViews, e.bufferView);
-      e._data = this.loadBufferViewAsync(`/bufferViews/${i.index}`, i).then((a) => {
-        if (e.componentType === 5126 && !e.normalized && (!i.byteStride || i.byteStride === r))
-          return u._GetTypedArray(t, e.componentType, a, e.byteOffset, o);
-        {
-          const l = new n(o);
-          return p.ForEach(a, e.byteOffset || 0, i.byteStride || r, s, e.componentType, l.length, e.normalized || !1, (h, f) => {
-            l[f] = h;
-          }), l;
-        }
-      });
-    }
-    if (e.sparse) {
-      const i = e.sparse;
-      e._data = e._data.then((a) => {
-        const l = a, h = c.Get(`${t}/sparse/indices/bufferView`, this._gltf.bufferViews, i.indices.bufferView), f = c.Get(`${t}/sparse/values/bufferView`, this._gltf.bufferViews, i.values.bufferView);
-        return Promise.all([
-          this.loadBufferViewAsync(`/bufferViews/${h.index}`, h),
-          this.loadBufferViewAsync(`/bufferViews/${f.index}`, f)
-        ]).then(([d, m]) => {
-          const _ = u._GetTypedArray(`${t}/sparse/indices`, i.indices.componentType, d, i.indices.byteOffset, i.count), E = s * i.count;
-          let g;
-          if (e.componentType === 5126 && !e.normalized)
-            g = u._GetTypedArray(`${t}/sparse/values`, e.componentType, m, i.values.byteOffset, E);
-          else {
-            const y = u._GetTypedArray(`${t}/sparse/values`, e.componentType, m, i.values.byteOffset, E);
-            g = new n(E), p.ForEach(y, 0, r, s, e.componentType, g.length, e.normalized || !1, (w, S) => {
-              g[S] = w;
-            });
-          }
-          let b = 0;
-          for (let y = 0; y < _.length; y++) {
-            let w = _[y] * s;
-            for (let S = 0; S < s; S++)
-              l[w++] = g[b++];
-          }
-          return l;
-        });
-      });
-    }
-    return e._data;
-  }
-  /**
-   * @internal
-   */
-  _loadFloatAccessorAsync(t, e) {
-    return this._loadAccessorAsync(t, e, Float32Array);
-  }
-  /**
-   * @internal
-   */
-  _loadIndicesAccessorAsync(t, e) {
-    if (e.type !== "SCALAR")
-      throw new Error(`${t}/type: Invalid value ${e.type}`);
-    if (e.componentType !== 5121 && e.componentType !== 5123 && e.componentType !== 5125)
-      throw new Error(`${t}/componentType: Invalid value ${e.componentType}`);
-    if (e._data)
-      return e._data;
-    if (e.sparse) {
-      const n = u._GetTypedArrayConstructor(`${t}/componentType`, e.componentType);
-      e._data = this._loadAccessorAsync(t, e, n);
-    } else {
-      const n = c.Get(`${t}/bufferView`, this._gltf.bufferViews, e.bufferView);
-      e._data = this.loadBufferViewAsync(`/bufferViews/${n.index}`, n).then((s) => u._GetTypedArray(t, e.componentType, s, e.byteOffset, e.count));
-    }
-    return e._data;
-  }
-  /**
-   * @internal
-   */
-  _loadVertexBufferViewAsync(t) {
-    if (t._babylonBuffer)
-      return t._babylonBuffer;
-    const e = this._babylonScene.getEngine();
-    return t._babylonBuffer = this.loadBufferViewAsync(`/bufferViews/${t.index}`, t).then((n) => new Q(e, n, !1)), t._babylonBuffer;
-  }
-  /**
-   * @internal
-   */
-  _loadVertexAccessorAsync(t, e, n) {
-    var s;
-    if (!((s = e._babylonVertexBuffer) === null || s === void 0) && s[n])
-      return e._babylonVertexBuffer[n];
-    e._babylonVertexBuffer || (e._babylonVertexBuffer = {});
-    const r = this._babylonScene.getEngine();
-    if (e.sparse)
-      e._babylonVertexBuffer[n] = this._loadFloatAccessorAsync(t, e).then((o) => new p(r, o, n, !1));
-    else if (n === p.MatricesIndicesKind || n === p.MatricesIndicesExtraKind)
-      e._babylonVertexBuffer[n] = this._loadFloatAccessorAsync(t, e).then((o) => new p(r, o, n, !1));
-    else {
-      const o = c.Get(`${t}/bufferView`, this._gltf.bufferViews, e.bufferView);
-      e._babylonVertexBuffer[n] = this._loadVertexBufferViewAsync(o).then((i) => {
-        const a = u._GetNumComponents(t, e.type);
-        return new p(r, i, n, !1, !1, o.byteStride, !1, e.byteOffset, a, e.componentType, e.normalized, !0, 1, !0);
-      });
-    }
-    return e._babylonVertexBuffer[n];
-  }
-  _loadMaterialMetallicRoughnessPropertiesAsync(t, e, n) {
-    if (!(n instanceof M))
-      throw new Error(`${t}: Material type not supported`);
-    const s = new Array();
-    return e && (e.baseColorFactor ? (n.albedoColor = R.FromArray(e.baseColorFactor), n.alpha = e.baseColorFactor[3]) : n.albedoColor = R.White(), n.metallic = e.metallicFactor == null ? 1 : e.metallicFactor, n.roughness = e.roughnessFactor == null ? 1 : e.roughnessFactor, e.baseColorTexture && s.push(this.loadTextureInfoAsync(`${t}/baseColorTexture`, e.baseColorTexture, (r) => {
-      r.name = `${n.name} (Base Color)`, n.albedoTexture = r;
-    })), e.metallicRoughnessTexture && (e.metallicRoughnessTexture.nonColorData = !0, s.push(this.loadTextureInfoAsync(`${t}/metallicRoughnessTexture`, e.metallicRoughnessTexture, (r) => {
-      r.name = `${n.name} (Metallic Roughness)`, n.metallicTexture = r;
-    })), n.useMetallnessFromMetallicTextureBlue = !0, n.useRoughnessFromMetallicTextureGreen = !0, n.useRoughnessFromMetallicTextureAlpha = !1)), Promise.all(s).then(() => {
-    });
-  }
-  /**
-   * @internal
-   */
-  _loadMaterialAsync(t, e, n, s, r = () => {
-  }) {
-    const o = this._extensionsLoadMaterialAsync(t, e, n, s, r);
-    if (o)
-      return o;
-    e._data = e._data || {};
-    let i = e._data[s];
-    if (!i) {
-      this.logOpen(`${t} ${e.name || ""}`);
-      const a = this.createMaterial(t, e, s);
-      i = {
-        babylonMaterial: a,
-        babylonMeshes: [],
-        promise: this.loadMaterialPropertiesAsync(t, e, a)
-      }, e._data[s] = i, u.AddPointerMetadata(a, t), this._parent.onMaterialLoadedObservable.notifyObservers(a), this.logClose();
-    }
-    return n && (i.babylonMeshes.push(n), n.onDisposeObservable.addOnce(() => {
-      const a = i.babylonMeshes.indexOf(n);
-      a !== -1 && i.babylonMeshes.splice(a, 1);
-    })), r(i.babylonMaterial), i.promise.then(() => i.babylonMaterial);
-  }
-  _createDefaultMaterial(t, e) {
-    this._babylonScene._blockEntityCollection = !!this._assetContainer;
-    const n = new M(t, this._babylonScene);
-    return n._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, n.fillMode = e, n.enableSpecularAntiAliasing = !0, n.useRadianceOverAlpha = !this._parent.transparencyAsCoverage, n.useSpecularOverAlpha = !this._parent.transparencyAsCoverage, n.transparencyMode = M.PBRMATERIAL_OPAQUE, n.metallic = 1, n.roughness = 1, n;
-  }
-  /**
-   * Creates a Babylon material from a glTF material.
-   * @param context The context when loading the asset
-   * @param material The glTF material property
-   * @param babylonDrawMode The draw mode for the Babylon material
-   * @returns The Babylon material
-   */
-  createMaterial(t, e, n) {
-    const s = this._extensionsCreateMaterial(t, e, n);
-    if (s)
-      return s;
-    const r = e.name || `material${e.index}`;
-    return this._createDefaultMaterial(r, n);
-  }
-  /**
-   * Loads properties from a glTF material into a Babylon material.
-   * @param context The context when loading the asset
-   * @param material The glTF material property
-   * @param babylonMaterial The Babylon material
-   * @returns A promise that resolves when the load is complete
-   */
-  loadMaterialPropertiesAsync(t, e, n) {
-    const s = this._extensionsLoadMaterialPropertiesAsync(t, e, n);
-    if (s)
-      return s;
-    const r = new Array();
-    return r.push(this.loadMaterialBasePropertiesAsync(t, e, n)), e.pbrMetallicRoughness && r.push(this._loadMaterialMetallicRoughnessPropertiesAsync(`${t}/pbrMetallicRoughness`, e.pbrMetallicRoughness, n)), this.loadMaterialAlphaProperties(t, e, n), Promise.all(r).then(() => {
-    });
-  }
-  /**
-   * Loads the normal, occlusion, and emissive properties from a glTF material into a Babylon material.
-   * @param context The context when loading the asset
-   * @param material The glTF material property
-   * @param babylonMaterial The Babylon material
-   * @returns A promise that resolves when the load is complete
-   */
-  loadMaterialBasePropertiesAsync(t, e, n) {
-    if (!(n instanceof M))
-      throw new Error(`${t}: Material type not supported`);
-    const s = new Array();
-    return n.emissiveColor = e.emissiveFactor ? R.FromArray(e.emissiveFactor) : new R(0, 0, 0), e.doubleSided && (n.backFaceCulling = !1, n.twoSidedLighting = !0), e.normalTexture && (e.normalTexture.nonColorData = !0, s.push(this.loadTextureInfoAsync(`${t}/normalTexture`, e.normalTexture, (r) => {
-      r.name = `${n.name} (Normal)`, n.bumpTexture = r;
-    })), n.invertNormalMapX = !this._babylonScene.useRightHandedSystem, n.invertNormalMapY = this._babylonScene.useRightHandedSystem, e.normalTexture.scale != null && n.bumpTexture && (n.bumpTexture.level = e.normalTexture.scale), n.forceIrradianceInFragment = !0), e.occlusionTexture && (e.occlusionTexture.nonColorData = !0, s.push(this.loadTextureInfoAsync(`${t}/occlusionTexture`, e.occlusionTexture, (r) => {
-      r.name = `${n.name} (Occlusion)`, n.ambientTexture = r;
-    })), n.useAmbientInGrayScale = !0, e.occlusionTexture.strength != null && (n.ambientTextureStrength = e.occlusionTexture.strength)), e.emissiveTexture && s.push(this.loadTextureInfoAsync(`${t}/emissiveTexture`, e.emissiveTexture, (r) => {
-      r.name = `${n.name} (Emissive)`, n.emissiveTexture = r;
-    })), Promise.all(s).then(() => {
-    });
-  }
-  /**
-   * Loads the alpha properties from a glTF material into a Babylon material.
-   * Must be called after the setting the albedo texture of the Babylon material when the material has an albedo texture.
-   * @param context The context when loading the asset
-   * @param material The glTF material property
-   * @param babylonMaterial The Babylon material
-   */
-  loadMaterialAlphaProperties(t, e, n) {
-    if (!(n instanceof M))
-      throw new Error(`${t}: Material type not supported`);
-    switch (e.alphaMode || "OPAQUE") {
-      case "OPAQUE": {
-        n.transparencyMode = M.PBRMATERIAL_OPAQUE;
-        break;
-      }
-      case "MASK": {
-        n.transparencyMode = M.PBRMATERIAL_ALPHATEST, n.alphaCutOff = e.alphaCutoff == null ? 0.5 : e.alphaCutoff, n.albedoTexture && (n.albedoTexture.hasAlpha = !0);
-        break;
-      }
-      case "BLEND": {
-        n.transparencyMode = M.PBRMATERIAL_ALPHABLEND, n.albedoTexture && (n.albedoTexture.hasAlpha = !0, n.useAlphaFromAlbedoTexture = !0);
-        break;
-      }
-      default:
-        throw new Error(`${t}/alphaMode: Invalid value (${e.alphaMode})`);
-    }
-  }
-  /**
-   * Loads a glTF texture info.
-   * @param context The context when loading the asset
-   * @param textureInfo The glTF texture info property
-   * @param assign A function called synchronously after parsing the glTF properties
-   * @returns A promise that resolves with the loaded Babylon texture when the load is complete
-   */
-  loadTextureInfoAsync(t, e, n = () => {
-  }) {
-    const s = this._extensionsLoadTextureInfoAsync(t, e, n);
-    if (s)
-      return s;
-    if (this.logOpen(`${t}`), e.texCoord >= 6)
-      throw new Error(`${t}/texCoord: Invalid value (${e.texCoord})`);
-    const r = c.Get(`${t}/index`, this._gltf.textures, e.index);
-    r._textureInfo = e;
-    const o = this._loadTextureAsync(`/textures/${e.index}`, r, (i) => {
-      i.coordinatesIndex = e.texCoord || 0, u.AddPointerMetadata(i, t), this._parent.onTextureLoadedObservable.notifyObservers(i), n(i);
-    });
-    return this.logClose(), o;
-  }
-  /**
-   * @internal
-   */
-  _loadTextureAsync(t, e, n = () => {
-  }) {
-    const s = this._extensionsLoadTextureAsync(t, e, n);
-    if (s)
-      return s;
-    this.logOpen(`${t} ${e.name || ""}`);
-    const r = e.sampler == null ? u.DefaultSampler : c.Get(`${t}/sampler`, this._gltf.samplers, e.sampler), o = c.Get(`${t}/source`, this._gltf.images, e.source), i = this._createTextureAsync(t, r, o, n, void 0, !e._textureInfo.nonColorData);
-    return this.logClose(), i;
-  }
-  /**
-   * @internal
-   */
-  _createTextureAsync(t, e, n, s = () => {
-  }, r, o) {
-    const i = this._loadSampler(`/samplers/${e.index}`, e), a = new Array(), l = new U();
-    this._babylonScene._blockEntityCollection = !!this._assetContainer;
-    const h = {
-      noMipmap: i.noMipMaps,
-      invertY: !1,
-      samplingMode: i.samplingMode,
-      onLoad: () => {
-        this._disposed || l.resolve();
-      },
-      onError: (d, m) => {
-        this._disposed || l.reject(new Error(`${t}: ${m && m.message ? m.message : d || "Failed to load texture"}`));
-      },
-      mimeType: n.mimeType,
-      loaderOptions: r,
-      useSRGBBuffer: !!o && this._parent.useSRGBBuffers
-    }, f = new A(null, this._babylonScene, h);
-    return f._parentContainer = this._assetContainer, this._babylonScene._blockEntityCollection = !1, a.push(l.promise), a.push(this.loadImageAsync(`/images/${n.index}`, n).then((d) => {
-      const m = n.uri || `${this._fileName}#image${n.index}`, _ = `data:${this._uniqueRootUrl}${m}`;
-      f.updateURL(_, d);
-    })), f.wrapU = i.wrapU, f.wrapV = i.wrapV, s(f), Promise.all(a).then(() => f);
-  }
-  _loadSampler(t, e) {
-    return e._data || (e._data = {
-      noMipMaps: e.minFilter === 9728 || e.minFilter === 9729,
-      samplingMode: u._GetTextureSamplingMode(t, e),
-      wrapU: u._GetTextureWrapMode(`${t}/wrapS`, e.wrapS),
-      wrapV: u._GetTextureWrapMode(`${t}/wrapT`, e.wrapT)
-    }), e._data;
-  }
-  /**
-   * Loads a glTF image.
-   * @param context The context when loading the asset
-   * @param image The glTF image property
-   * @returns A promise that resolves with the loaded data when the load is complete
-   */
-  loadImageAsync(t, e) {
-    if (!e._data) {
-      if (this.logOpen(`${t} ${e.name || ""}`), e.uri)
-        e._data = this.loadUriAsync(`${t}/uri`, e, e.uri);
-      else {
-        const n = c.Get(`${t}/bufferView`, this._gltf.bufferViews, e.bufferView);
-        e._data = this.loadBufferViewAsync(`/bufferViews/${n.index}`, n);
-      }
-      this.logClose();
-    }
-    return e._data;
-  }
-  /**
-   * Loads a glTF uri.
-   * @param context The context when loading the asset
-   * @param property The glTF property associated with the uri
-   * @param uri The base64 or relative uri
-   * @returns A promise that resolves with the loaded data when the load is complete
-   */
-  loadUriAsync(t, e, n) {
-    const s = this._extensionsLoadUriAsync(t, e, n);
-    if (s)
-      return s;
-    if (!u._ValidateUri(n))
-      throw new Error(`${t}: '${n}' is invalid`);
-    if (ee(n)) {
-      const r = new Uint8Array(te(n));
-      return this.log(`${t}: Decoded ${n.substr(0, 64)}... (${r.length} bytes)`), Promise.resolve(r);
-    }
-    return this.log(`${t}: Loading ${n}`), this._parent.preprocessUrlAsync(this._rootUrl + n).then((r) => new Promise((o, i) => {
-      this._parent._loadFile(this._babylonScene, r, (a) => {
-        this._disposed || (this.log(`${t}: Loaded ${n} (${a.byteLength} bytes)`), o(new Uint8Array(a)));
-      }, !0, (a) => {
-        i(new ne(`${t}: Failed to load '${n}'${a ? ": " + a.status + " " + a.statusText : ""}`, a));
-      });
-    }));
-  }
-  /**
-   * Adds a JSON pointer to the _internalMetadata of the Babylon object at `<object>._internalMetadata.gltf.pointers`.
-   * @param babylonObject the Babylon object with _internalMetadata
-   * @param pointer the JSON pointer
-   */
-  static AddPointerMetadata(t, e) {
-    t.metadata = t.metadata || {};
-    const n = t._internalMetadata = t._internalMetadata || {}, s = n.gltf = n.gltf || {};
-    (s.pointers = s.pointers || []).push(e);
-  }
-  static _GetTextureWrapMode(t, e) {
-    switch (e = e ?? 10497, e) {
-      case 33071:
-        return A.CLAMP_ADDRESSMODE;
-      case 33648:
-        return A.MIRROR_ADDRESSMODE;
-      case 10497:
-        return A.WRAP_ADDRESSMODE;
-      default:
-        return $.Warn(`${t}: Invalid value (${e})`), A.WRAP_ADDRESSMODE;
-    }
-  }
-  static _GetTextureSamplingMode(t, e) {
-    const n = e.magFilter == null ? 9729 : e.magFilter, s = e.minFilter == null ? 9987 : e.minFilter;
-    if (n === 9729)
-      switch (s) {
-        case 9728:
-          return A.LINEAR_NEAREST;
-        case 9729:
-          return A.LINEAR_LINEAR;
-        case 9984:
-          return A.LINEAR_NEAREST_MIPNEAREST;
-        case 9985:
-          return A.LINEAR_LINEAR_MIPNEAREST;
-        case 9986:
-          return A.LINEAR_NEAREST_MIPLINEAR;
-        case 9987:
-          return A.LINEAR_LINEAR_MIPLINEAR;
-        default:
-          return $.Warn(`${t}/minFilter: Invalid value (${s})`), A.LINEAR_LINEAR_MIPLINEAR;
-      }
-    else
-      switch (n !== 9728 && $.Warn(`${t}/magFilter: Invalid value (${n})`), s) {
-        case 9728:
-          return A.NEAREST_NEAREST;
-        case 9729:
-          return A.NEAREST_LINEAR;
-        case 9984:
-          return A.NEAREST_NEAREST_MIPNEAREST;
-        case 9985:
-          return A.NEAREST_LINEAR_MIPNEAREST;
-        case 9986:
-          return A.NEAREST_NEAREST_MIPLINEAR;
-        case 9987:
-          return A.NEAREST_LINEAR_MIPLINEAR;
-        default:
-          return $.Warn(`${t}/minFilter: Invalid value (${s})`), A.NEAREST_NEAREST_MIPNEAREST;
-      }
-  }
-  static _GetTypedArrayConstructor(t, e) {
-    switch (e) {
-      case 5120:
-        return Int8Array;
-      case 5121:
-        return Uint8Array;
-      case 5122:
-        return Int16Array;
-      case 5123:
-        return Uint16Array;
-      case 5125:
-        return Uint32Array;
-      case 5126:
-        return Float32Array;
-      default:
-        throw new Error(`${t}: Invalid component type ${e}`);
-    }
-  }
-  static _GetTypedArray(t, e, n, s, r) {
-    const o = n.buffer;
-    s = n.byteOffset + (s || 0);
-    const i = u._GetTypedArrayConstructor(`${t}/componentType`, e), a = p.GetTypeByteLength(e);
-    return s % a !== 0 ? ($.Warn(`${t}: Copying buffer as byte offset (${s}) is not a multiple of component type byte length (${a})`), new i(o.slice(s, s + r * a), 0)) : new i(o, s, r);
-  }
-  static _GetNumComponents(t, e) {
-    switch (e) {
-      case "SCALAR":
-        return 1;
-      case "VEC2":
-        return 2;
-      case "VEC3":
-        return 3;
-      case "VEC4":
-        return 4;
-      case "MAT2":
-        return 4;
-      case "MAT3":
-        return 9;
-      case "MAT4":
-        return 16;
-    }
-    throw new Error(`${t}: Invalid type (${e})`);
-  }
-  static _ValidateUri(t) {
-    return L.IsBase64(t) || t.indexOf("..") === -1;
-  }
-  /**
-   * @internal
-   */
-  static _GetDrawMode(t, e) {
-    switch (e == null && (e = 4), e) {
-      case 0:
-        return C.PointListDrawMode;
-      case 1:
-        return C.LineListDrawMode;
-      case 2:
-        return C.LineLoopDrawMode;
-      case 3:
-        return C.LineStripDrawMode;
-      case 4:
-        return C.TriangleFillMode;
-      case 5:
-        return C.TriangleStripDrawMode;
-      case 6:
-        return C.TriangleFanDrawMode;
-    }
-    throw new Error(`${t}: Invalid mesh primitive mode (${e})`);
-  }
-  _compileMaterialsAsync() {
-    this._parent._startPerformanceCounter("Compile materials");
-    const t = new Array();
-    if (this._gltf.materials) {
-      for (const e of this._gltf.materials)
-        if (e._data)
-          for (const n in e._data) {
-            const s = e._data[n];
-            for (const r of s.babylonMeshes) {
-              r.computeWorldMatrix(!0);
-              const o = s.babylonMaterial;
-              t.push(o.forceCompilationAsync(r)), t.push(o.forceCompilationAsync(r, { useInstances: !0 })), this._parent.useClipPlane && (t.push(o.forceCompilationAsync(r, { clipPlane: !0 })), t.push(o.forceCompilationAsync(r, { clipPlane: !0, useInstances: !0 })));
-            }
-          }
-    }
-    return Promise.all(t).then(() => {
-      this._parent._endPerformanceCounter("Compile materials");
-    });
-  }
-  _compileShadowGeneratorsAsync() {
-    this._parent._startPerformanceCounter("Compile shadow generators");
-    const t = new Array(), e = this._babylonScene.lights;
-    for (const n of e) {
-      const s = n.getShadowGenerator();
-      s && t.push(s.forceCompilationAsync());
-    }
-    return Promise.all(t).then(() => {
-      this._parent._endPerformanceCounter("Compile shadow generators");
-    });
-  }
-  _forEachExtensions(t) {
-    for (const e of this._extensions)
-      e.enabled && t(e);
-  }
-  _applyExtensions(t, e, n) {
-    for (const s of this._extensions)
-      if (s.enabled) {
-        const r = `${s.name}.${e}`, o = t;
-        o._activeLoaderExtensionFunctions = o._activeLoaderExtensionFunctions || {};
-        const i = o._activeLoaderExtensionFunctions;
-        if (!i[r]) {
-          i[r] = !0;
-          try {
-            const a = n(s);
-            if (a)
-              return a;
-          } finally {
-            delete i[r];
-          }
-        }
-      }
-    return null;
-  }
-  _extensionsOnLoading() {
-    this._forEachExtensions((t) => t.onLoading && t.onLoading());
-  }
-  _extensionsOnReady() {
-    this._forEachExtensions((t) => t.onReady && t.onReady());
-  }
-  _extensionsLoadSceneAsync(t, e) {
-    return this._applyExtensions(e, "loadScene", (n) => n.loadSceneAsync && n.loadSceneAsync(t, e));
-  }
-  _extensionsLoadNodeAsync(t, e, n) {
-    return this._applyExtensions(e, "loadNode", (s) => s.loadNodeAsync && s.loadNodeAsync(t, e, n));
-  }
-  _extensionsLoadCameraAsync(t, e, n) {
-    return this._applyExtensions(e, "loadCamera", (s) => s.loadCameraAsync && s.loadCameraAsync(t, e, n));
-  }
-  _extensionsLoadVertexDataAsync(t, e, n) {
-    return this._applyExtensions(e, "loadVertexData", (s) => s._loadVertexDataAsync && s._loadVertexDataAsync(t, e, n));
-  }
-  _extensionsLoadMeshPrimitiveAsync(t, e, n, s, r, o) {
-    return this._applyExtensions(r, "loadMeshPrimitive", (i) => i._loadMeshPrimitiveAsync && i._loadMeshPrimitiveAsync(t, e, n, s, r, o));
-  }
-  _extensionsLoadMaterialAsync(t, e, n, s, r) {
-    return this._applyExtensions(e, "loadMaterial", (o) => o._loadMaterialAsync && o._loadMaterialAsync(t, e, n, s, r));
-  }
-  _extensionsCreateMaterial(t, e, n) {
-    return this._applyExtensions(e, "createMaterial", (s) => s.createMaterial && s.createMaterial(t, e, n));
-  }
-  _extensionsLoadMaterialPropertiesAsync(t, e, n) {
-    return this._applyExtensions(e, "loadMaterialProperties", (s) => s.loadMaterialPropertiesAsync && s.loadMaterialPropertiesAsync(t, e, n));
-  }
-  _extensionsLoadTextureInfoAsync(t, e, n) {
-    return this._applyExtensions(e, "loadTextureInfo", (s) => s.loadTextureInfoAsync && s.loadTextureInfoAsync(t, e, n));
-  }
-  _extensionsLoadTextureAsync(t, e, n) {
-    return this._applyExtensions(e, "loadTexture", (s) => s._loadTextureAsync && s._loadTextureAsync(t, e, n));
-  }
-  _extensionsLoadAnimationAsync(t, e) {
-    return this._applyExtensions(e, "loadAnimation", (n) => n.loadAnimationAsync && n.loadAnimationAsync(t, e));
-  }
-  _extensionsLoadAnimationChannelAsync(t, e, n, s, r) {
-    return this._applyExtensions(n, "loadAnimationChannel", (o) => o._loadAnimationChannelAsync && o._loadAnimationChannelAsync(t, e, n, s, r));
-  }
-  _extensionsLoadSkinAsync(t, e, n) {
-    return this._applyExtensions(n, "loadSkin", (s) => s._loadSkinAsync && s._loadSkinAsync(t, e, n));
-  }
-  _extensionsLoadUriAsync(t, e, n) {
-    return this._applyExtensions(e, "loadUri", (s) => s._loadUriAsync && s._loadUriAsync(t, e, n));
-  }
-  _extensionsLoadBufferViewAsync(t, e) {
-    return this._applyExtensions(e, "loadBufferView", (n) => n.loadBufferViewAsync && n.loadBufferViewAsync(t, e));
-  }
-  _extensionsLoadBufferAsync(t, e, n, s) {
-    return this._applyExtensions(e, "loadBuffer", (r) => r.loadBufferAsync && r.loadBufferAsync(t, e, n, s));
-  }
-  /**
-   * Helper method called by a loader extension to load an glTF extension.
-   * @param context The context when loading the asset
-   * @param property The glTF property to load the extension from
-   * @param extensionName The name of the extension to load
-   * @param actionAsync The action to run
-   * @returns The promise returned by actionAsync or null if the extension does not exist
-   */
-  static LoadExtensionAsync(t, e, n, s) {
-    if (!e.extensions)
-      return null;
-    const o = e.extensions[n];
-    return o ? s(`${t}/extensions/${n}`, o) : null;
-  }
-  /**
-   * Helper method called by a loader extension to load a glTF extra.
-   * @param context The context when loading the asset
-   * @param property The glTF property to load the extra from
-   * @param extensionName The name of the extension to load
-   * @param actionAsync The action to run
-   * @returns The promise returned by actionAsync or null if the extra does not exist
-   */
-  static LoadExtraAsync(t, e, n, s) {
-    if (!e.extras)
-      return null;
-    const o = e.extras[n];
-    return o ? s(`${t}/extras/${n}`, o) : null;
-  }
-  /**
-   * Checks for presence of an extension.
-   * @param name The name of the extension to check
-   * @returns A boolean indicating the presence of the given extension name in `extensionsUsed`
-   */
-  isExtensionUsed(t) {
-    return !!this._gltf.extensionsUsed && this._gltf.extensionsUsed.indexOf(t) !== -1;
-  }
-  /**
-   * Increments the indentation level and logs a message.
-   * @param message The message to log
-   */
-  logOpen(t) {
-    this._parent._logOpen(t);
-  }
-  /**
-   * Decrements the indentation level.
-   */
-  logClose() {
-    this._parent._logClose();
-  }
-  /**
-   * Logs a message
-   * @param message The message to log
-   */
-  log(t) {
-    this._parent._log(t);
-  }
-  /**
-   * Starts a performance counter.
-   * @param counterName The name of the performance counter
-   */
-  startPerformanceCounter(t) {
-    this._parent._startPerformanceCounter(t);
-  }
-  /**
-   * Ends a performance counter.
-   * @param counterName The name of the performance counter
-   */
-  endPerformanceCounter(t) {
-    this._parent._endPerformanceCounter(t);
-  }
-}
-u._RegisteredExtensions = {};
-u.DefaultSampler = { index: -1 };
-q._CreateGLTF2Loader = (v) => new u(v);
-export {
-  c as ArrayItem,
-  u as GLTFLoader
-};