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

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

@@ -0,0 +1,902 @@
+import { ETextureFilterType as Q, EParameterType as j, ECullingType as ue, EBlendingFunction as N, EShaderType as me } from "./glTFLoaderInterfaces.esm.js";
+import { Quaternion as w, Vector3 as C, Matrix as J } from "../../../core/Maths/math.vector.esm.js";
+import { Color3 as H } from "../../../core/Maths/math.color.esm.js";
+import { Tools as T } from "../../../core/Misc/tools.esm.js";
+import { Camera as de } from "../../../core/Cameras/camera.esm.js";
+import { FreeCamera as D } from "../../../core/Cameras/freeCamera.esm.js";
+import { Animation as W } from "../../../core/Animations/animation.esm.js";
+import { Bone as z } from "../../../core/Bones/bone.esm.js";
+import { Skeleton as ae } from "../../../core/Bones/skeleton.esm.js";
+import { Effect as Z } from "../../../core/Materials/effect.esm.js";
+import { Material as R } from "../../../core/Materials/material.esm.js";
+import { MultiMaterial as pe } from "../../../core/Materials/multiMaterial.esm.js";
+import { StandardMaterial as ce } from "../../../core/Materials/standardMaterial.esm.js";
+import { ShaderMaterial as ye } from "../../../core/Materials/shaderMaterial.esm.js";
+import { Texture as ee } from "../../../core/Materials/Textures/texture.esm.js";
+import { VertexData as Ae } from "../../../core/Meshes/mesh.vertexData.esm.js";
+import { VertexBuffer as be } from "../../../core/Buffers/buffer.esm.js";
+import { Geometry as Ne } from "../../../core/Meshes/geometry.esm.js";
+import { SubMesh as Ee } from "../../../core/Meshes/subMesh.esm.js";
+import { AbstractMesh as xe } from "../../../core/Meshes/abstractMesh.esm.js";
+import { Mesh as X } from "../../../core/Meshes/mesh.esm.js";
+import { HemisphericLight as Oe } from "../../../core/Lights/hemisphericLight.esm.js";
+import { DirectionalLight as _e } from "../../../core/Lights/directionalLight.esm.js";
+import { PointLight as Ce } from "../../../core/Lights/pointLight.esm.js";
+import { SpotLight as Te } from "../../../core/Lights/spotLight.esm.js";
+import { GLTFUtils as g } from "./glTFLoaderUtils.esm.js";
+import { GLTFFileLoader as V } from "../glTFFileLoader.esm.js";
+import { Constants as v } from "../../../core/Engines/constants.esm.js";
+var F;
+(function(s) {
+  s[s.IDENTIFIER = 1] = "IDENTIFIER", s[s.UNKNOWN = 2] = "UNKNOWN", s[s.END_OF_INPUT = 3] = "END_OF_INPUT";
+})(F || (F = {}));
+class ne {
+  constructor(e) {
+    this._pos = 0, this.currentToken = F.UNKNOWN, this.currentIdentifier = "", this.currentString = "", this.isLetterOrDigitPattern = /^[a-zA-Z0-9]+$/, this._toParse = e, this._maxPos = e.length;
+  }
+  getNextToken() {
+    if (this.isEnd())
+      return F.END_OF_INPUT;
+    if (this.currentString = this.read(), this.currentToken = F.UNKNOWN, this.currentString === "_" || this.isLetterOrDigitPattern.test(this.currentString))
+      for (this.currentToken = F.IDENTIFIER, this.currentIdentifier = this.currentString; !this.isEnd() && (this.isLetterOrDigitPattern.test(this.currentString = this.peek()) || this.currentString === "_"); )
+        this.currentIdentifier += this.currentString, this.forward();
+    return this.currentToken;
+  }
+  peek() {
+    return this._toParse[this._pos];
+  }
+  read() {
+    return this._toParse[this._pos++];
+  }
+  forward() {
+    this._pos++;
+  }
+  isEnd() {
+    return this._pos >= this._maxPos;
+  }
+}
+const le = ["MODEL", "VIEW", "PROJECTION", "MODELVIEW", "MODELVIEWPROJECTION", "JOINTMATRIX"], fe = ["world", "view", "projection", "worldView", "worldViewProjection", "mBones"], Ie = ["translation", "rotation", "scale"], Se = ["position", "rotationQuaternion", "scaling"], Me = (s, e) => {
+  for (const o in s) {
+    const t = s[o];
+    e.buffers[o] = t, e.buffersCount++;
+  }
+}, Le = (s, e) => {
+  for (const o in s) {
+    const t = s[o];
+    e.shaders[o] = t, e.shaderscount++;
+  }
+}, M = (s, e, o) => {
+  for (const t in s) {
+    const n = s[t];
+    o[e][t] = n;
+  }
+}, Be = (s) => {
+  if (s)
+    for (let e = 0; e < s.length / 2; e++)
+      s[e * 2 + 1] = 1 - s[e * 2 + 1];
+}, te = (s) => {
+  if (s.semantic === "NORMAL")
+    return "normal";
+  if (s.semantic === "POSITION")
+    return "position";
+  if (s.semantic === "JOINT")
+    return "matricesIndices";
+  if (s.semantic === "WEIGHT")
+    return "matricesWeights";
+  if (s.semantic === "COLOR")
+    return "color";
+  if (s.semantic && s.semantic.indexOf("TEXCOORD_") !== -1) {
+    const e = Number(s.semantic.split("_")[1]);
+    return "uv" + (e === 0 ? "" : e + 1);
+  }
+  return null;
+}, ge = (s) => {
+  for (const e in s.animations) {
+    const o = s.animations[e];
+    if (!o.channels || !o.samplers)
+      continue;
+    let t = null;
+    for (let n = 0; n < o.channels.length; n++) {
+      const r = o.channels[n], i = o.samplers[r.sampler];
+      if (!i)
+        continue;
+      let a = null, l = null;
+      o.parameters ? (a = o.parameters[i.input], l = o.parameters[i.output]) : (a = i.input, l = i.output);
+      const c = g.GetBufferFromAccessor(s, s.accessors[a]), h = g.GetBufferFromAccessor(s, s.accessors[l]), d = r.target.id;
+      let u = s.scene.getNodeById(d);
+      if (u === null && (u = s.scene.getNodeByName(d)), u === null) {
+        T.Warn("Creating animation named " + e + ". But cannot find node named " + d + " to attach to");
+        continue;
+      }
+      const y = u instanceof z;
+      let x = r.target.path;
+      const O = Ie.indexOf(x);
+      O !== -1 && (x = Se[O]);
+      let E = W.ANIMATIONTYPE_MATRIX;
+      y || (x === "rotationQuaternion" ? (E = W.ANIMATIONTYPE_QUATERNION, u.rotationQuaternion = new w()) : E = W.ANIMATIONTYPE_VECTOR3);
+      let p = null;
+      const L = [];
+      let _ = 0, I = !1;
+      y && t && t.getKeys().length === c.length && (p = t, I = !0), I || (s.scene._blockEntityCollection = !!s.assetContainer, p = new W(e, y ? "_matrix" : x, 1, E, W.ANIMATIONLOOPMODE_CYCLE), s.scene._blockEntityCollection = !1);
+      for (let m = 0; m < c.length; m++) {
+        let b = null;
+        if (x === "rotationQuaternion" ? (b = w.FromArray([h[_], h[_ + 1], h[_ + 2], h[_ + 3]]), _ += 4) : (b = C.FromArray([h[_], h[_ + 1], h[_ + 2]]), _ += 3), y) {
+          const f = u;
+          let A = C.Zero(), B = new w(), P = C.Zero(), q = f.getBaseMatrix();
+          I && t && (q = t.getKeys()[m].value), q.decompose(P, B, A), x === "position" ? A = b : x === "rotationQuaternion" ? B = b : P = b, b = J.Compose(P, B, A);
+        }
+        I ? t && (t.getKeys()[m].value = b) : L.push({
+          frame: c[m],
+          value: b
+        });
+      }
+      !I && p && (p.setKeys(L), u.animations.push(p)), t = p, s.scene.stopAnimation(u), s.scene.beginAnimation(u, 0, c[c.length - 1], !0, 1);
+    }
+  }
+}, $ = (s) => {
+  let e = null;
+  if (s.translation || s.rotation || s.scale) {
+    const o = C.FromArray(s.scale || [1, 1, 1]), t = w.FromArray(s.rotation || [0, 0, 0, 1]), n = C.FromArray(s.translation || [0, 0, 0]);
+    e = J.Compose(o, t, n);
+  } else
+    e = J.FromArray(s.matrix);
+  return e;
+}, he = (s, e, o, t) => {
+  for (let r = 0; r < t.bones.length; r++)
+    if (t.bones[r].name === o)
+      return t.bones[r];
+  const n = s.nodes;
+  for (const r in n) {
+    const i = n[r];
+    if (!i.jointName)
+      continue;
+    const a = i.children;
+    for (let l = 0; l < a.length; l++) {
+      const c = s.nodes[a[l]];
+      if (c.jointName && c.jointName === o) {
+        const h = $(i), d = new z(i.name || "", t, he(s, e, i.jointName, t), h);
+        return d.id = r, d;
+      }
+    }
+  }
+  return null;
+}, Pe = (s, e) => {
+  for (let o = 0; o < s.length; o++) {
+    const t = s[o];
+    for (let n = 0; n < t.node.children.length; n++)
+      if (t.node.children[n] === e)
+        return t.bone;
+  }
+  return null;
+}, G = (s, e) => {
+  const o = s.nodes;
+  let t = o[e];
+  if (t)
+    return {
+      node: t,
+      id: e
+    };
+  for (const n in o)
+    if (t = o[n], t.jointName === e)
+      return {
+        node: t,
+        id: n
+      };
+  return null;
+}, Fe = (s, e) => {
+  for (let o = 0; o < s.jointNames.length; o++)
+    if (s.jointNames[o] === e)
+      return !0;
+  return !1;
+}, we = (s, e, o, t) => {
+  for (const n in s.nodes) {
+    const r = s.nodes[n], i = n;
+    if (!r.jointName || Fe(o, r.jointName))
+      continue;
+    const a = $(r), l = new z(r.name || "", e, null, a);
+    l.id = i, t.push({ bone: l, node: r, id: i });
+  }
+  for (let n = 0; n < t.length; n++) {
+    const r = t[n], i = r.node.children;
+    for (let a = 0; a < i.length; a++) {
+      let l = null;
+      for (let c = 0; c < t.length; c++)
+        if (t[c].id === i[a]) {
+          l = t[c];
+          break;
+        }
+      l && (l.bone._parent = r.bone, r.bone.children.push(l.bone));
+    }
+  }
+}, ke = (s, e, o, t) => {
+  if (t || (t = new ae(e.name || "", "", s.scene)), !e.babylonSkeleton)
+    return t;
+  const n = [], r = [];
+  we(s, t, e, n), t.bones = [];
+  for (let a = 0; a < e.jointNames.length; a++) {
+    const l = G(s, e.jointNames[a]);
+    if (!l)
+      continue;
+    const c = l.node;
+    if (!c) {
+      T.Warn("Joint named " + e.jointNames[a] + " does not exist");
+      continue;
+    }
+    const h = l.id, d = s.scene.getBoneById(h);
+    if (d) {
+      t.bones.push(d);
+      continue;
+    }
+    let u = !1, y = null;
+    for (let E = 0; E < a; E++) {
+      const p = G(s, e.jointNames[E]);
+      if (!p)
+        continue;
+      const L = p.node;
+      if (!L) {
+        T.Warn("Joint named " + e.jointNames[E] + " does not exist when looking for parent");
+        continue;
+      }
+      const _ = L.children;
+      if (_) {
+        u = !1;
+        for (let I = 0; I < _.length; I++)
+          if (_[I] === h) {
+            y = he(s, e, e.jointNames[E], t), u = !0;
+            break;
+          }
+        if (u)
+          break;
+      }
+    }
+    const x = $(c);
+    !y && n.length > 0 && (y = Pe(n, h), y && r.indexOf(y) === -1 && r.push(y));
+    const O = new z(c.jointName || "", t, y, x);
+    O.id = h;
+  }
+  const i = t.bones;
+  t.bones = [];
+  for (let a = 0; a < e.jointNames.length; a++) {
+    const l = G(s, e.jointNames[a]);
+    if (l) {
+      for (let c = 0; c < i.length; c++)
+        if (i[c].id === l.id) {
+          t.bones.push(i[c]);
+          break;
+        }
+    }
+  }
+  t.prepare();
+  for (let a = 0; a < r.length; a++)
+    t.bones.push(r[a]);
+  return t;
+}, se = (s, e, o, t, n) => {
+  if (n || (s.scene._blockEntityCollection = !!s.assetContainer, n = new X(e.name || "", s.scene), n._parentContainer = s.assetContainer, s.scene._blockEntityCollection = !1, n.id = t), !e.babylonNode)
+    return n;
+  const r = [];
+  let i = null;
+  const a = new Array(), l = new Array(), c = new Array(), h = new Array();
+  for (let y = 0; y < o.length; y++) {
+    const x = o[y], O = s.meshes[x];
+    if (O)
+      for (let E = 0; E < O.primitives.length; E++) {
+        const p = new Ae(), L = O.primitives[E];
+        L.mode;
+        const _ = L.attributes;
+        let I = null, m = null;
+        for (const f in _)
+          if (I = s.accessors[_[f]], m = g.GetBufferFromAccessor(s, I), f === "NORMAL")
+            p.normals = new Float32Array(m.length), p.normals.set(m);
+          else if (f === "POSITION") {
+            if (V.HomogeneousCoordinates) {
+              p.positions = new Float32Array(m.length - m.length / 4);
+              for (let A = 0; A < m.length; A += 4)
+                p.positions[A] = m[A], p.positions[A + 1] = m[A + 1], p.positions[A + 2] = m[A + 2];
+            } else
+              p.positions = new Float32Array(m.length), p.positions.set(m);
+            l.push(p.positions.length);
+          } else if (f.indexOf("TEXCOORD_") !== -1) {
+            const A = Number(f.split("_")[1]), B = be.UVKind + (A === 0 ? "" : A + 1), P = new Float32Array(m.length);
+            P.set(m), Be(P), p.set(P, B);
+          } else
+            f === "JOINT" ? (p.matricesIndices = new Float32Array(m.length), p.matricesIndices.set(m)) : f === "WEIGHT" ? (p.matricesWeights = new Float32Array(m.length), p.matricesWeights.set(m)) : f === "COLOR" && (p.colors = new Float32Array(m.length), p.colors.set(m));
+        if (I = s.accessors[L.indices], I)
+          m = g.GetBufferFromAccessor(s, I), p.indices = new Int32Array(m.length), p.indices.set(m), h.push(p.indices.length);
+        else {
+          const f = [];
+          for (let A = 0; A < p.positions.length / 3; A++)
+            f.push(A);
+          p.indices = new Int32Array(f), h.push(p.indices.length);
+        }
+        i ? i.merge(p) : i = p;
+        const b = s.scene.getMaterialById(L.material);
+        r.push(b === null ? g.GetDefaultMaterial(s.scene) : b), a.push(a.length === 0 ? 0 : a[a.length - 1] + l[l.length - 2]), c.push(c.length === 0 ? 0 : c[c.length - 1] + h[h.length - 2]);
+      }
+  }
+  let d;
+  s.scene._blockEntityCollection = !!s.assetContainer, r.length > 1 ? (d = new pe("multimat" + t, s.scene), d.subMaterials = r) : d = new ce("multimat" + t, s.scene), r.length === 1 && (d = r[0]), d._parentContainer = s.assetContainer, n.material || (n.material = d), new Ne(t, s.scene, i, !1, n), n.computeWorldMatrix(!0), s.scene._blockEntityCollection = !1, n.subMeshes = [];
+  let u = 0;
+  for (let y = 0; y < o.length; y++) {
+    const x = o[y], O = s.meshes[x];
+    if (O)
+      for (let E = 0; E < O.primitives.length; E++)
+        O.primitives[E].mode, Ee.AddToMesh(u, a[u], l[u], c[u], h[u], n, n, !0), u++;
+  }
+  return n;
+}, Y = (s, e, o, t) => {
+  s.position && (s.position = e), (s.rotationQuaternion || s.rotation) && (s.rotationQuaternion = o), s.scaling && (s.scaling = t);
+}, ve = (s, e) => {
+  if (e.matrix) {
+    const o = new C(0, 0, 0), t = new w(), n = new C(0, 0, 0);
+    J.FromArray(e.matrix).decompose(n, t, o), Y(s, o, t, n);
+  } else
+    e.translation && e.rotation && e.scale && Y(s, C.FromArray(e.translation), w.FromArray(e.rotation), C.FromArray(e.scale));
+  s.computeWorldMatrix(!0);
+}, Ue = (s, e, o) => {
+  let t = null;
+  if (s.importOnlyMeshes && (e.skin || e.meshes) && s.importMeshesNames && s.importMeshesNames.length > 0 && s.importMeshesNames.indexOf(e.name || "") === -1)
+    return null;
+  if (e.skin) {
+    if (e.meshes) {
+      const n = s.skins[e.skin], r = se(s, e, e.meshes, o, e.babylonNode);
+      r.skeleton = s.scene.getLastSkeletonById(e.skin), r.skeleton === null && (r.skeleton = ke(s, n, r, n.babylonSkeleton), n.babylonSkeleton || (n.babylonSkeleton = r.skeleton)), t = r;
+    }
+  } else if (e.meshes)
+    t = se(s, e, e.mesh ? [e.mesh] : e.meshes, o, e.babylonNode);
+  else if (e.light && !e.babylonNode && !s.importOnlyMeshes) {
+    const n = s.lights[e.light];
+    if (n) {
+      if (n.type === "ambient") {
+        const r = n[n.type], i = new Oe(e.light, C.Zero(), s.scene);
+        i.name = e.name || "", r.color && (i.diffuse = H.FromArray(r.color)), t = i;
+      } else if (n.type === "directional") {
+        const r = n[n.type], i = new _e(e.light, C.Zero(), s.scene);
+        i.name = e.name || "", r.color && (i.diffuse = H.FromArray(r.color)), t = i;
+      } else if (n.type === "point") {
+        const r = n[n.type], i = new Ce(e.light, C.Zero(), s.scene);
+        i.name = e.name || "", r.color && (i.diffuse = H.FromArray(r.color)), t = i;
+      } else if (n.type === "spot") {
+        const r = n[n.type], i = new Te(e.light, C.Zero(), C.Zero(), 0, 0, s.scene);
+        i.name = e.name || "", r.color && (i.diffuse = H.FromArray(r.color)), r.fallOfAngle && (i.angle = r.fallOfAngle), r.fallOffExponent && (i.exponent = r.fallOffExponent), t = i;
+      }
+    }
+  } else if (e.camera && !e.babylonNode && !s.importOnlyMeshes) {
+    const n = s.cameras[e.camera];
+    if (n) {
+      if (s.scene._blockEntityCollection = !!s.assetContainer, n.type === "orthographic") {
+        const r = new D(e.camera, C.Zero(), s.scene, !1);
+        r.name = e.name || "", r.mode = de.ORTHOGRAPHIC_CAMERA, r.attachControl(), t = r, r._parentContainer = s.assetContainer;
+      } else if (n.type === "perspective") {
+        const r = n[n.type], i = new D(e.camera, C.Zero(), s.scene, !1);
+        i.name = e.name || "", i.attachControl(), r.aspectRatio || (r.aspectRatio = s.scene.getEngine().getRenderWidth() / s.scene.getEngine().getRenderHeight()), r.znear && r.zfar && (i.maxZ = r.zfar, i.minZ = r.znear), t = i, i._parentContainer = s.assetContainer;
+      }
+      s.scene._blockEntityCollection = !1;
+    }
+  }
+  if (!e.jointName) {
+    if (e.babylonNode)
+      return e.babylonNode;
+    if (t === null) {
+      s.scene._blockEntityCollection = !!s.assetContainer;
+      const n = new X(e.name || "", s.scene);
+      n._parentContainer = s.assetContainer, s.scene._blockEntityCollection = !1, e.babylonNode = n, t = n;
+    }
+  }
+  if (t !== null) {
+    if (e.matrix && t instanceof X)
+      ve(t, e);
+    else {
+      const n = e.translation || [0, 0, 0], r = e.rotation || [0, 0, 0, 1], i = e.scale || [1, 1, 1];
+      Y(t, C.FromArray(n), w.FromArray(r), C.FromArray(i));
+    }
+    t.updateCache(!0), e.babylonNode = t;
+  }
+  return t;
+}, K = (s, e, o, t = !1) => {
+  const n = s.nodes[e];
+  let r = null;
+  if (s.importOnlyMeshes && !t && s.importMeshesNames ? s.importMeshesNames.indexOf(n.name || "") !== -1 || s.importMeshesNames.length === 0 ? t = !0 : t = !1 : t = !0, !n.jointName && t && (r = Ue(s, n, e), r !== null && (r.id = e, r.parent = o)), n.children)
+    for (let i = 0; i < n.children.length; i++)
+      K(s, n.children[i], r, t);
+}, re = (s) => {
+  let e = s.currentScene;
+  if (e)
+    for (let o = 0; o < e.nodes.length; o++)
+      K(s, e.nodes[o], null);
+  else
+    for (const o in s.scenes) {
+      e = s.scenes[o];
+      for (let t = 0; t < e.nodes.length; t++)
+        K(s, e.nodes[t], null);
+    }
+  ge(s);
+  for (let o = 0; o < s.scene.skeletons.length; o++) {
+    const t = s.scene.skeletons[o];
+    s.scene.beginAnimation(t, 0, Number.MAX_VALUE, !0, 1);
+  }
+}, je = (s, e, o, t, n, r, i) => {
+  const a = r.values || n.parameters;
+  for (const l in o) {
+    const c = o[l], h = c.type;
+    if (h === j.FLOAT_MAT2 || h === j.FLOAT_MAT3 || h === j.FLOAT_MAT4) {
+      if (c.semantic && !c.source && !c.node)
+        g.SetMatrix(e.scene, s, c, l, t.getEffect());
+      else if (c.semantic && (c.source || c.node)) {
+        let d = e.scene.getNodeByName(c.source || c.node || "");
+        if (d === null && (d = e.scene.getNodeById(c.source || c.node || "")), d === null)
+          continue;
+        g.SetMatrix(e.scene, d, c, l, t.getEffect());
+      }
+    } else {
+      const d = a[n.uniforms[l]];
+      if (!d)
+        continue;
+      if (h === j.SAMPLER_2D) {
+        const u = e.textures[r.values ? d : c.value].babylonTexture;
+        if (u == null)
+          continue;
+        t.getEffect().setTexture(l, u);
+      } else
+        g.SetUniform(t.getEffect(), l, d, h);
+    }
+  }
+  i(t);
+}, Ve = (s, e, o, t, n) => {
+  const r = t.values || o.parameters, i = o.uniforms;
+  for (const a in n) {
+    const l = n[a], c = l.type;
+    let h = r[i[a]];
+    if (h === void 0 && (h = l.value), !h)
+      continue;
+    const d = (u) => (y) => {
+      l.value && u && (e.setTexture(u, y), delete n[u]);
+    };
+    c === j.SAMPLER_2D ? S.LoadTextureAsync(s, t.values ? h : l.value, d(a), () => d(null)) : l.value && g.SetUniform(e, a, t.values ? h : l.value, c) && delete n[a];
+  }
+}, We = (s, e, o) => (t, n) => {
+  e.dispose(!0), o("Cannot compile program named " + s.name + ". Error: " + n + ". Default material will be applied");
+}, He = (s, e, o, t, n, r) => (i) => {
+  Ve(s, e, o, t, n), e.onBind = (a) => {
+    je(a, s, n, e, o, t, r);
+  };
+}, oe = (s, e, o) => {
+  for (const t in e.uniforms) {
+    const n = e.uniforms[t], r = e.parameters[n];
+    if (s.currentIdentifier === t && r.semantic && !r.source && !r.node) {
+      const i = le.indexOf(r.semantic);
+      if (i !== -1)
+        return delete o[t], fe[i];
+    }
+  }
+  return s.currentIdentifier;
+}, ie = (s) => {
+  for (const e in s.materials)
+    S.LoadMaterialAsync(s, e, () => {
+    }, () => {
+    });
+};
+class U {
+  static CreateRuntime(e, o, t) {
+    const n = {
+      extensions: {},
+      accessors: {},
+      buffers: {},
+      bufferViews: {},
+      meshes: {},
+      lights: {},
+      cameras: {},
+      nodes: {},
+      images: {},
+      textures: {},
+      shaders: {},
+      programs: {},
+      samplers: {},
+      techniques: {},
+      materials: {},
+      animations: {},
+      skins: {},
+      extensionsUsed: [],
+      scenes: {},
+      buffersCount: 0,
+      shaderscount: 0,
+      scene: o,
+      rootUrl: t,
+      loadedBufferCount: 0,
+      loadedBufferViews: {},
+      loadedShaderCount: 0,
+      importOnlyMeshes: !1,
+      dummyNodes: [],
+      assetContainer: null
+    };
+    return e.extensions && M(e.extensions, "extensions", n), e.extensionsUsed && M(e.extensionsUsed, "extensionsUsed", n), e.buffers && Me(e.buffers, n), e.bufferViews && M(e.bufferViews, "bufferViews", n), e.accessors && M(e.accessors, "accessors", n), e.meshes && M(e.meshes, "meshes", n), e.lights && M(e.lights, "lights", n), e.cameras && M(e.cameras, "cameras", n), e.nodes && M(e.nodes, "nodes", n), e.images && M(e.images, "images", n), e.textures && M(e.textures, "textures", n), e.shaders && Le(e.shaders, n), e.programs && M(e.programs, "programs", n), e.samplers && M(e.samplers, "samplers", n), e.techniques && M(e.techniques, "techniques", n), e.materials && M(e.materials, "materials", n), e.animations && M(e.animations, "animations", n), e.skins && M(e.skins, "skins", n), e.scenes && (n.scenes = e.scenes), e.scene && e.scenes && (n.currentScene = e.scenes[e.scene]), n;
+  }
+  static LoadBufferAsync(e, o, t, n, r) {
+    const i = e.buffers[o];
+    T.IsBase64(i.uri) ? setTimeout(() => t(new Uint8Array(T.DecodeBase64(i.uri)))) : T.LoadFile(e.rootUrl + i.uri, (a) => t(new Uint8Array(a)), r, void 0, !0, (a) => {
+      a && n(a.status + " " + a.statusText);
+    });
+  }
+  static LoadTextureBufferAsync(e, o, t, n) {
+    const r = e.textures[o];
+    if (!r || !r.source) {
+      n("");
+      return;
+    }
+    if (r.babylonTexture) {
+      t(null);
+      return;
+    }
+    const i = e.images[r.source];
+    T.IsBase64(i.uri) ? setTimeout(() => t(new Uint8Array(T.DecodeBase64(i.uri)))) : T.LoadFile(e.rootUrl + i.uri, (a) => t(new Uint8Array(a)), void 0, void 0, !0, (a) => {
+      a && n(a.status + " " + a.statusText);
+    });
+  }
+  static CreateTextureAsync(e, o, t, n) {
+    const r = e.textures[o];
+    if (r.babylonTexture) {
+      n(r.babylonTexture);
+      return;
+    }
+    const i = e.samplers[r.sampler], a = i.minFilter === Q.NEAREST_MIPMAP_NEAREST || i.minFilter === Q.NEAREST_MIPMAP_LINEAR || i.minFilter === Q.LINEAR_MIPMAP_NEAREST || i.minFilter === Q.LINEAR_MIPMAP_LINEAR, l = ee.BILINEAR_SAMPLINGMODE, c = t == null ? new Blob() : new Blob([t]), h = URL.createObjectURL(c), d = () => URL.revokeObjectURL(h), u = new ee(h, e.scene, !a, !0, l, d, d);
+    i.wrapS !== void 0 && (u.wrapU = g.GetWrapMode(i.wrapS)), i.wrapT !== void 0 && (u.wrapV = g.GetWrapMode(i.wrapT)), u.name = o, r.babylonTexture = u, n(u);
+  }
+  static LoadShaderStringAsync(e, o, t, n) {
+    const r = e.shaders[o];
+    if (T.IsBase64(r.uri)) {
+      const i = atob(r.uri.split(",")[1]);
+      t && t(i);
+    } else
+      T.LoadFile(e.rootUrl + r.uri, t, void 0, void 0, !1, (i) => {
+        i && n && n(i.status + " " + i.statusText);
+      });
+  }
+  static LoadMaterialAsync(e, o, t, n) {
+    const r = e.materials[o];
+    if (!r.technique) {
+      n && n("No technique found.");
+      return;
+    }
+    const i = e.techniques[r.technique];
+    if (!i) {
+      e.scene._blockEntityCollection = !!e.assetContainer;
+      const b = new ce(o, e.scene);
+      b._parentContainer = e.assetContainer, e.scene._blockEntityCollection = !1, b.diffuseColor = new H(0.5, 0.5, 0.5), b.sideOrientation = R.CounterClockWiseSideOrientation, t(b);
+      return;
+    }
+    const a = e.programs[i.program], l = i.states, c = Z.ShadersStore[a.vertexShader + "VertexShader"], h = Z.ShadersStore[a.fragmentShader + "PixelShader"];
+    let d = "", u = "";
+    const y = new ne(c), x = new ne(h), O = {}, E = [], p = [], L = [];
+    for (const b in i.uniforms) {
+      const f = i.uniforms[b], A = i.parameters[f];
+      if (O[b] = A, A.semantic && !A.node && !A.source) {
+        const B = le.indexOf(A.semantic);
+        B !== -1 ? (E.push(fe[B]), delete O[b]) : E.push(b);
+      } else
+        A.type === j.SAMPLER_2D ? L.push(b) : E.push(b);
+    }
+    for (const b in i.attributes) {
+      const f = i.attributes[b], A = i.parameters[f];
+      if (A.semantic) {
+        const B = te(A);
+        B && p.push(B);
+      }
+    }
+    for (; !y.isEnd() && y.getNextToken(); ) {
+      if (y.currentToken !== F.IDENTIFIER) {
+        d += y.currentString;
+        continue;
+      }
+      let f = !1;
+      for (const A in i.attributes) {
+        const B = i.attributes[A], P = i.parameters[B];
+        if (y.currentIdentifier === A && P.semantic) {
+          d += te(P), f = !0;
+          break;
+        }
+      }
+      f || (d += oe(y, i, O));
+    }
+    for (; !x.isEnd() && x.getNextToken(); ) {
+      if (x.currentToken !== F.IDENTIFIER) {
+        u += x.currentString;
+        continue;
+      }
+      u += oe(x, i, O);
+    }
+    const _ = {
+      vertex: a.vertexShader + o,
+      fragment: a.fragmentShader + o
+    }, I = {
+      attributes: p,
+      uniforms: E,
+      samplers: L,
+      needAlphaBlending: l && l.enable && l.enable.indexOf(3042) !== -1
+    };
+    Z.ShadersStore[a.vertexShader + o + "VertexShader"] = d, Z.ShadersStore[a.fragmentShader + o + "PixelShader"] = u;
+    const m = new ye(o, e.scene, _, I);
+    if (m.onError = We(a, m, n), m.onCompiled = He(e, m, i, r, O, t), m.sideOrientation = R.CounterClockWiseSideOrientation, l && l.functions) {
+      const b = l.functions;
+      b.cullFace && b.cullFace[0] !== ue.BACK && (m.backFaceCulling = !1);
+      const f = b.blendFuncSeparate;
+      f && (f[0] === N.SRC_ALPHA && f[1] === N.ONE_MINUS_SRC_ALPHA && f[2] === N.ONE && f[3] === N.ONE ? m.alphaMode = v.ALPHA_COMBINE : f[0] === N.ONE && f[1] === N.ONE && f[2] === N.ZERO && f[3] === N.ONE ? m.alphaMode = v.ALPHA_ONEONE : f[0] === N.SRC_ALPHA && f[1] === N.ONE && f[2] === N.ZERO && f[3] === N.ONE ? m.alphaMode = v.ALPHA_ADD : f[0] === N.ZERO && f[1] === N.ONE_MINUS_SRC_COLOR && f[2] === N.ONE && f[3] === N.ONE ? m.alphaMode = v.ALPHA_SUBTRACT : f[0] === N.DST_COLOR && f[1] === N.ZERO && f[2] === N.ONE && f[3] === N.ONE ? m.alphaMode = v.ALPHA_MULTIPLY : f[0] === N.SRC_ALPHA && f[1] === N.ONE_MINUS_SRC_COLOR && f[2] === N.ONE && f[3] === N.ONE && (m.alphaMode = v.ALPHA_MAXIMIZED));
+    }
+  }
+}
+class k {
+  static RegisterExtension(e) {
+    if (k.Extensions[e.name]) {
+      T.Error('Tool with the same name "' + e.name + '" already exists');
+      return;
+    }
+    k.Extensions[e.name] = e;
+  }
+  dispose() {
+  }
+  _importMeshAsync(e, o, t, n, r, i, a, l) {
+    return o.useRightHandedSystem = !0, S.LoadRuntimeAsync(o, t, n, (c) => {
+      c.assetContainer = r, c.importOnlyMeshes = !0, e === "" ? c.importMeshesNames = [] : typeof e == "string" ? c.importMeshesNames = [e] : e && !(e instanceof Array) ? c.importMeshesNames = [e] : (c.importMeshesNames = [], T.Warn("Argument meshesNames must be of type string or string[]")), this._createNodes(c);
+      const h = new Array(), d = new Array();
+      for (const u in c.nodes) {
+        const y = c.nodes[u];
+        y.babylonNode instanceof xe && h.push(y.babylonNode);
+      }
+      for (const u in c.skins) {
+        const y = c.skins[u];
+        y.babylonSkeleton instanceof ae && d.push(y.babylonSkeleton);
+      }
+      this._loadBuffersAsync(c, () => {
+        this._loadShadersAsync(c, () => {
+          ie(c), re(c), !V.IncrementalLoading && i && i(h, d);
+        });
+      }), V.IncrementalLoading && i && i(h, d);
+    }, l), !0;
+  }
+  /**
+   * Imports one or more meshes from a loaded gltf file and adds them to the scene
+   * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
+   * @param scene the scene the meshes should be added to
+   * @param assetContainer defines the asset container to use (can be null)
+   * @param data gltf data containing information of the meshes in a loaded file
+   * @param rootUrl root url to load from
+   * @param onProgress event that fires when loading progress has occured
+   * @returns a promise containg the loaded meshes, particles, skeletons and animations
+   */
+  importMeshAsync(e, o, t, n, r, i) {
+    return new Promise((a, l) => {
+      this._importMeshAsync(e, o, n, r, t, (c, h) => {
+        a({
+          meshes: c,
+          particleSystems: [],
+          skeletons: h,
+          animationGroups: [],
+          lights: [],
+          transformNodes: [],
+          geometries: []
+        });
+      }, i, (c) => {
+        l(new Error(c));
+      });
+    });
+  }
+  _loadAsync(e, o, t, n, r, i) {
+    e.useRightHandedSystem = !0, S.LoadRuntimeAsync(e, o, t, (a) => {
+      S.LoadRuntimeExtensionsAsync(a, () => {
+        this._createNodes(a), this._loadBuffersAsync(a, () => {
+          this._loadShadersAsync(a, () => {
+            ie(a), re(a), V.IncrementalLoading || n();
+          });
+        }), V.IncrementalLoading && n();
+      }, i);
+    }, i);
+  }
+  /**
+   * Imports all objects from a loaded gltf file and adds them to the scene
+   * @param scene the scene the objects should be added to
+   * @param data gltf data containing information of the meshes in a loaded file
+   * @param rootUrl root url to load from
+   * @param onProgress event that fires when loading progress has occured
+   * @returns a promise which completes when objects have been loaded to the scene
+   */
+  loadAsync(e, o, t, n) {
+    return new Promise((r, i) => {
+      this._loadAsync(e, o, t, () => {
+        r();
+      }, n, (a) => {
+        i(new Error(a));
+      });
+    });
+  }
+  _loadShadersAsync(e, o) {
+    let t = !1;
+    const n = (r, i) => {
+      S.LoadShaderStringAsync(e, r, (a) => {
+        a instanceof ArrayBuffer || (e.loadedShaderCount++, a && (Z.ShadersStore[r + (i.type === me.VERTEX ? "VertexShader" : "PixelShader")] = a), e.loadedShaderCount === e.shaderscount && o());
+      }, () => {
+        T.Error("Error when loading shader program named " + r + " located at " + i.uri);
+      });
+    };
+    for (const r in e.shaders) {
+      t = !0;
+      const i = e.shaders[r];
+      i ? n.bind(this, r, i)() : T.Error("No shader named: " + r);
+    }
+    t || o();
+  }
+  _loadBuffersAsync(e, o) {
+    let t = !1;
+    const n = (r, i) => {
+      S.LoadBufferAsync(e, r, (a) => {
+        e.loadedBufferCount++, a && (a.byteLength != e.buffers[r].byteLength && T.Error("Buffer named " + r + " is length " + a.byteLength + ". Expected: " + i.byteLength), e.loadedBufferViews[r] = a), e.loadedBufferCount === e.buffersCount && o();
+      }, () => {
+        T.Error("Error when loading buffer named " + r + " located at " + i.uri);
+      });
+    };
+    for (const r in e.buffers) {
+      t = !0;
+      const i = e.buffers[r];
+      i ? n.bind(this, r, i)() : T.Error("No buffer named: " + r);
+    }
+    t || o();
+  }
+  _createNodes(e) {
+    let o = e.currentScene;
+    if (o)
+      for (let t = 0; t < o.nodes.length; t++)
+        K(e, o.nodes[t], null);
+    else
+      for (const t in e.scenes) {
+        o = e.scenes[t];
+        for (let n = 0; n < o.nodes.length; n++)
+          K(e, o.nodes[n], null);
+      }
+  }
+}
+k.Extensions = {};
+class S {
+  constructor(e) {
+    this._name = e;
+  }
+  get name() {
+    return this._name;
+  }
+  /**
+   * Defines an override for loading the runtime
+   * Return true to stop further extensions from loading the runtime
+   * @param scene
+   * @param data
+   * @param rootUrl
+   * @param onSuccess
+   * @param onError
+   */
+  loadRuntimeAsync(e, o, t, n, r) {
+    return !1;
+  }
+  /**
+   * Defines an onverride for creating gltf runtime
+   * Return true to stop further extensions from creating the runtime
+   * @param gltfRuntime
+   * @param onSuccess
+   * @param onError
+   */
+  loadRuntimeExtensionsAsync(e, o, t) {
+    return !1;
+  }
+  /**
+   * Defines an override for loading buffers
+   * Return true to stop further extensions from loading this buffer
+   * @param gltfRuntime
+   * @param id
+   * @param onSuccess
+   * @param onError
+   * @param onProgress
+   */
+  loadBufferAsync(e, o, t, n, r) {
+    return !1;
+  }
+  /**
+   * Defines an override for loading texture buffers
+   * Return true to stop further extensions from loading this texture data
+   * @param gltfRuntime
+   * @param id
+   * @param onSuccess
+   * @param onError
+   */
+  loadTextureBufferAsync(e, o, t, n) {
+    return !1;
+  }
+  /**
+   * Defines an override for creating textures
+   * Return true to stop further extensions from loading this texture
+   * @param gltfRuntime
+   * @param id
+   * @param buffer
+   * @param onSuccess
+   * @param onError
+   */
+  createTextureAsync(e, o, t, n, r) {
+    return !1;
+  }
+  /**
+   * Defines an override for loading shader strings
+   * Return true to stop further extensions from loading this shader data
+   * @param gltfRuntime
+   * @param id
+   * @param onSuccess
+   * @param onError
+   */
+  loadShaderStringAsync(e, o, t, n) {
+    return !1;
+  }
+  /**
+   * Defines an override for loading materials
+   * Return true to stop further extensions from loading this material
+   * @param gltfRuntime
+   * @param id
+   * @param onSuccess
+   * @param onError
+   */
+  loadMaterialAsync(e, o, t, n) {
+    return !1;
+  }
+  // ---------
+  // Utilities
+  // ---------
+  static LoadRuntimeAsync(e, o, t, n, r) {
+    S._ApplyExtensions((i) => i.loadRuntimeAsync(e, o, t, n, r), () => {
+      setTimeout(() => {
+        n && n(U.CreateRuntime(o.json, e, t));
+      });
+    });
+  }
+  static LoadRuntimeExtensionsAsync(e, o, t) {
+    S._ApplyExtensions((n) => n.loadRuntimeExtensionsAsync(e, o, t), () => {
+      setTimeout(() => {
+        o();
+      });
+    });
+  }
+  static LoadBufferAsync(e, o, t, n, r) {
+    S._ApplyExtensions((i) => i.loadBufferAsync(e, o, t, n, r), () => {
+      U.LoadBufferAsync(e, o, t, n, r);
+    });
+  }
+  static LoadTextureAsync(e, o, t, n) {
+    S._LoadTextureBufferAsync(e, o, (r) => {
+      r && S._CreateTextureAsync(e, o, r, t, n);
+    }, n);
+  }
+  static LoadShaderStringAsync(e, o, t, n) {
+    S._ApplyExtensions((r) => r.loadShaderStringAsync(e, o, t, n), () => {
+      U.LoadShaderStringAsync(e, o, t, n);
+    });
+  }
+  static LoadMaterialAsync(e, o, t, n) {
+    S._ApplyExtensions((r) => r.loadMaterialAsync(e, o, t, n), () => {
+      U.LoadMaterialAsync(e, o, t, n);
+    });
+  }
+  static _LoadTextureBufferAsync(e, o, t, n) {
+    S._ApplyExtensions((r) => r.loadTextureBufferAsync(e, o, t, n), () => {
+      U.LoadTextureBufferAsync(e, o, t, n);
+    });
+  }
+  static _CreateTextureAsync(e, o, t, n, r) {
+    S._ApplyExtensions((i) => i.createTextureAsync(e, o, t, n, r), () => {
+      U.CreateTextureAsync(e, o, t, n);
+    });
+  }
+  static _ApplyExtensions(e, o) {
+    for (const t in k.Extensions) {
+      const n = k.Extensions[t];
+      if (e(n))
+        return;
+    }
+    o();
+  }
+}
+V._CreateGLTF1Loader = () => new k();
+export {
+  k as GLTFLoader,
+  U as GLTFLoaderBase,
+  S as GLTFLoaderExtension
+};