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

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

@@ -0,0 +1,66 @@
+import { Animation as m } from "../../../core/Animations/animation.esm.js";
+import { Vector3 as h, Quaternion as p } from "../../../core/Maths/math.vector.esm.js";
+function c(a, n, t, e) {
+  return h.FromArray(n, t).scaleInPlace(e);
+}
+function f(a, n, t, e) {
+  return p.FromArray(n, t).scaleInPlace(e);
+}
+function b(a, n, t, e) {
+  const o = new Array(a._numMorphTargets);
+  for (let r = 0; r < o.length; r++)
+    o[r] = n[t++] * e;
+  return o;
+}
+class A {
+  /** @internal */
+  constructor(n, t, e, o) {
+    this.type = n, this.name = t, this.getValue = e, this.getStride = o;
+  }
+  _buildAnimation(n, t, e) {
+    const o = new m(n, this.name, t, this.type);
+    return o.setKeys(e), o;
+  }
+}
+class l extends A {
+  /** @internal */
+  buildAnimations(n, t, e, o, r) {
+    r(n._babylonTransformNode, this._buildAnimation(t, e, o));
+  }
+}
+class _ extends A {
+  buildAnimations(n, t, e, o, r) {
+    if (n._numMorphTargets)
+      for (let s = 0; s < n._numMorphTargets; s++) {
+        const u = new m(`${t}_${s}`, this.name, e, this.type);
+        if (u.setKeys(o.map((i) => ({
+          frame: i.frame,
+          inTangent: i.inTangent ? i.inTangent[s] : void 0,
+          value: i.value[s],
+          outTangent: i.outTangent ? i.outTangent[s] : void 0,
+          interpolation: i.interpolation
+        }))), n._primitiveBabylonMeshes) {
+          for (const i of n._primitiveBabylonMeshes)
+            if (i.morphTargetManager) {
+              const T = i.morphTargetManager.getTarget(s), g = u.clone();
+              T.animations.push(g), r(T, g);
+            }
+        }
+      }
+  }
+}
+const M = {
+  translation: [new l(m.ANIMATIONTYPE_VECTOR3, "position", c, () => 3)],
+  rotation: [new l(m.ANIMATIONTYPE_QUATERNION, "rotationQuaternion", f, () => 4)],
+  scale: [new l(m.ANIMATIONTYPE_VECTOR3, "scaling", c, () => 3)],
+  weights: [new _(m.ANIMATIONTYPE_FLOAT, "influence", b, (a) => a._numMorphTargets)]
+};
+export {
+  A as AnimationPropertyInfo,
+  l as TransformNodeAnimationPropertyInfo,
+  _ as WeightAnimationPropertyInfo,
+  f as getQuaternion,
+  c as getVector3,
+  b as getWeights,
+  M as nodeAnimationData
+};

package/dist/node_modules/@babylonjs/loaders/glTF/glTFFileLoader.esm.js

@@ -0,0 +1,462 @@
+import { Observable as c } from "../../core/Misc/observable.esm.js";
+import { Tools as _ } from "../../core/Misc/tools.esm.js";
+import { SceneLoader as C } from "../../core/Loading/sceneLoader.esm.js";
+import { AssetContainer as L } from "../../core/assetContainer.esm.js";
+import { Logger as g } from "../../core/Misc/logger.esm.js";
+import { DataReader as f } from "../../core/Misc/dataReader.esm.js";
+import { GLTFValidation as M } from "./glTFValidation.esm.js";
+import { DecodeBase64UrlToBinary as k } from "../../core/Misc/fileTools.esm.js";
+import { RuntimeError as B, ErrorCodes as x } from "../../core/Misc/error.esm.js";
+function A(l, e, s) {
+  try {
+    return Promise.resolve(new Uint8Array(l, e, s));
+  } catch (r) {
+    return Promise.reject(r);
+  }
+}
+function V(l, e, s) {
+  try {
+    if (l.byteOffset + s > l.byteLength)
+      throw new Error("Array length out of bounds.");
+    return Promise.resolve(new Uint8Array(l.buffer, l.byteOffset + e, s));
+  } catch (r) {
+    return Promise.reject(r);
+  }
+}
+var v;
+(function(l) {
+  l[l.AUTO = 0] = "AUTO", l[l.FORCE_RIGHT_HANDED = 1] = "FORCE_RIGHT_HANDED";
+})(v || (v = {}));
+var y;
+(function(l) {
+  l[l.NONE = 0] = "NONE", l[l.FIRST = 1] = "FIRST", l[l.ALL = 2] = "ALL";
+})(y || (y = {}));
+var O;
+(function(l) {
+  l[l.LOADING = 0] = "LOADING", l[l.READY = 1] = "READY", l[l.COMPLETE = 2] = "COMPLETE";
+})(O || (O = {}));
+class h {
+  constructor() {
+    this.onParsedObservable = new c(), this.coordinateSystemMode = v.AUTO, this.animationStartMode = y.FIRST, this.compileMaterials = !1, this.useClipPlane = !1, this.compileShadowGenerators = !1, this.transparencyAsCoverage = !1, this.useRangeRequests = !1, this.createInstances = !0, this.alwaysComputeBoundingBox = !1, this.loadAllMaterials = !1, this.loadOnlyMaterials = !1, this.skipMaterials = !1, this.useSRGBBuffers = !0, this.targetFps = 60, this.alwaysComputeSkeletonRootNode = !1, this.preprocessUrlAsync = (e) => Promise.resolve(e), this.onMeshLoadedObservable = new c(), this.onSkinLoadedObservable = new c(), this.onTextureLoadedObservable = new c(), this.onMaterialLoadedObservable = new c(), this.onCameraLoadedObservable = new c(), this.onCompleteObservable = new c(), this.onErrorObservable = new c(), this.onDisposeObservable = new c(), this.onExtensionLoadedObservable = new c(), this.validate = !1, this.onValidatedObservable = new c(), this._loader = null, this._state = null, this._requests = new Array(), this.name = "gltf", this.extensions = {
+      ".gltf": { isBinary: !1 },
+      ".glb": { isBinary: !0 }
+    }, this.onLoaderStateChangedObservable = new c(), this._logIndentLevel = 0, this._loggingEnabled = !1, this._log = this._logDisabled, this._capturePerformanceCounters = !1, this._startPerformanceCounter = this._startPerformanceCounterDisabled, this._endPerformanceCounter = this._endPerformanceCounterDisabled;
+  }
+  /**
+   * Raised when the asset has been parsed
+   */
+  set onParsed(e) {
+    this._onParsedObserver && this.onParsedObservable.remove(this._onParsedObserver), this._onParsedObserver = this.onParsedObservable.add(e);
+  }
+  /**
+   * Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.
+   * Note that the callback is called as soon as the mesh object is created, meaning some data may not have been setup yet for this mesh (vertex data, morph targets, material, ...)
+   */
+  set onMeshLoaded(e) {
+    this._onMeshLoadedObserver && this.onMeshLoadedObservable.remove(this._onMeshLoadedObserver), this._onMeshLoadedObserver = this.onMeshLoadedObservable.add(e);
+  }
+  /**
+   * Callback raised when the loader creates a texture after parsing the glTF properties of the texture.
+   */
+  set onTextureLoaded(e) {
+    this._onTextureLoadedObserver && this.onTextureLoadedObservable.remove(this._onTextureLoadedObserver), this._onTextureLoadedObserver = this.onTextureLoadedObservable.add(e);
+  }
+  /**
+   * Callback raised when the loader creates a material after parsing the glTF properties of the material.
+   */
+  set onMaterialLoaded(e) {
+    this._onMaterialLoadedObserver && this.onMaterialLoadedObservable.remove(this._onMaterialLoadedObserver), this._onMaterialLoadedObserver = this.onMaterialLoadedObservable.add(e);
+  }
+  /**
+   * Callback raised when the loader creates a camera after parsing the glTF properties of the camera.
+   */
+  set onCameraLoaded(e) {
+    this._onCameraLoadedObserver && this.onCameraLoadedObservable.remove(this._onCameraLoadedObserver), this._onCameraLoadedObserver = this.onCameraLoadedObservable.add(e);
+  }
+  /**
+   * Callback raised when the asset is completely loaded, immediately before the loader is disposed.
+   * For assets with LODs, raised when all of the LODs are complete.
+   * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.
+   */
+  set onComplete(e) {
+    this._onCompleteObserver && this.onCompleteObservable.remove(this._onCompleteObserver), this._onCompleteObserver = this.onCompleteObservable.add(e);
+  }
+  /**
+   * Callback raised when an error occurs.
+   */
+  set onError(e) {
+    this._onErrorObserver && this.onErrorObservable.remove(this._onErrorObserver), this._onErrorObserver = this.onErrorObservable.add(e);
+  }
+  /**
+   * Callback raised after the loader is disposed.
+   */
+  set onDispose(e) {
+    this._onDisposeObserver && this.onDisposeObservable.remove(this._onDisposeObserver), this._onDisposeObserver = this.onDisposeObservable.add(e);
+  }
+  /**
+   * Callback raised after a loader extension is created.
+   */
+  set onExtensionLoaded(e) {
+    this._onExtensionLoadedObserver && this.onExtensionLoadedObservable.remove(this._onExtensionLoadedObserver), this._onExtensionLoadedObserver = this.onExtensionLoadedObservable.add(e);
+  }
+  /**
+   * Defines if the loader logging is enabled.
+   */
+  get loggingEnabled() {
+    return this._loggingEnabled;
+  }
+  set loggingEnabled(e) {
+    this._loggingEnabled !== e && (this._loggingEnabled = e, this._loggingEnabled ? this._log = this._logEnabled : this._log = this._logDisabled);
+  }
+  /**
+   * Defines if the loader should capture performance counters.
+   */
+  get capturePerformanceCounters() {
+    return this._capturePerformanceCounters;
+  }
+  set capturePerformanceCounters(e) {
+    this._capturePerformanceCounters !== e && (this._capturePerformanceCounters = e, this._capturePerformanceCounters ? (this._startPerformanceCounter = this._startPerformanceCounterEnabled, this._endPerformanceCounter = this._endPerformanceCounterEnabled) : (this._startPerformanceCounter = this._startPerformanceCounterDisabled, this._endPerformanceCounter = this._endPerformanceCounterDisabled));
+  }
+  /**
+   * Callback raised after a loader extension is created.
+   */
+  set onValidated(e) {
+    this._onValidatedObserver && this.onValidatedObservable.remove(this._onValidatedObserver), this._onValidatedObserver = this.onValidatedObservable.add(e);
+  }
+  /**
+   * Disposes the loader, releases resources during load, and cancels any outstanding requests.
+   */
+  dispose() {
+    this._loader && (this._loader.dispose(), this._loader = null);
+    for (const e of this._requests)
+      e.abort();
+    this._requests.length = 0, delete this._progressCallback, this.preprocessUrlAsync = (e) => Promise.resolve(e), this.onMeshLoadedObservable.clear(), this.onSkinLoadedObservable.clear(), this.onTextureLoadedObservable.clear(), this.onMaterialLoadedObservable.clear(), this.onCameraLoadedObservable.clear(), this.onCompleteObservable.clear(), this.onExtensionLoadedObservable.clear(), this.onDisposeObservable.notifyObservers(void 0), this.onDisposeObservable.clear();
+  }
+  /**
+   * @internal
+   */
+  loadFile(e, s, r, o, n, t, a, b) {
+    if (ArrayBuffer.isView(s))
+      return this._loadBinary(e, s, r, o, a, b), null;
+    this._progressCallback = n;
+    const p = s.name || _.GetFilename(s);
+    if (t) {
+      if (this.useRangeRequests) {
+        this.validate && g.Warn("glTF validation is not supported when range requests are enabled");
+        const d = {
+          abort: () => {
+          },
+          onCompleteObservable: new c()
+        }, i = {
+          readAsync: (u, P) => new Promise((E, w) => {
+            this._loadFile(e, s, (m) => {
+              E(new Uint8Array(m));
+            }, !0, (m) => {
+              w(m);
+            }, (m) => {
+              m.setRequestHeader("Range", `bytes=${u}-${u + P - 1}`);
+            });
+          }),
+          byteLength: 0
+        };
+        return this._unpackBinaryAsync(new f(i)).then((u) => {
+          d.onCompleteObservable.notifyObservers(d), o(u);
+        }, a ? (u) => a(void 0, u) : void 0), d;
+      }
+      return this._loadFile(e, s, (d) => {
+        this._validate(e, new Uint8Array(d), r, p), this._unpackBinaryAsync(new f({
+          readAsync: (i, u) => A(d, i, u),
+          byteLength: d.byteLength
+        })).then((i) => {
+          o(i);
+        }, a ? (i) => a(void 0, i) : void 0);
+      }, !0, a);
+    }
+    return this._loadFile(e, s, (d) => {
+      this._validate(e, new Uint8Array(d), r, p), o({ json: this._parseJson(d) });
+    }, t, a);
+  }
+  /**
+   * @internal
+   */
+  _loadBinary(e, s, r, o, n, t) {
+    this._validate(e, s, r, t), this._unpackBinaryAsync(new f({
+      readAsync: (a, b) => V(s, a, b),
+      byteLength: s.byteLength
+    })).then((a) => {
+      o(a);
+    }, n ? (a) => n(void 0, a) : void 0);
+  }
+  /**
+   * @internal
+   */
+  importMeshAsync(e, s, r, o, n, t) {
+    return Promise.resolve().then(() => (this.onParsedObservable.notifyObservers(r), this.onParsedObservable.clear(), this._log(`Loading ${t || ""}`), this._loader = this._getLoader(r), this._loader.importMeshAsync(e, s, null, r, o, n, t)));
+  }
+  /**
+   * @internal
+   */
+  loadAsync(e, s, r, o, n) {
+    return Promise.resolve().then(() => (this.onParsedObservable.notifyObservers(s), this.onParsedObservable.clear(), this._log(`Loading ${n || ""}`), this._loader = this._getLoader(s), this._loader.loadAsync(e, s, r, o, n)));
+  }
+  /**
+   * @internal
+   */
+  loadAssetContainerAsync(e, s, r, o, n) {
+    return Promise.resolve().then(() => {
+      this.onParsedObservable.notifyObservers(s), this.onParsedObservable.clear(), this._log(`Loading ${n || ""}`), this._loader = this._getLoader(s);
+      const t = new L(e), a = [];
+      this.onMaterialLoadedObservable.add((i) => {
+        a.push(i);
+      });
+      const b = [];
+      this.onTextureLoadedObservable.add((i) => {
+        b.push(i);
+      });
+      const p = [];
+      this.onCameraLoadedObservable.add((i) => {
+        p.push(i);
+      });
+      const d = [];
+      return this.onMeshLoadedObservable.add((i) => {
+        i.morphTargetManager && d.push(i.morphTargetManager);
+      }), this._loader.importMeshAsync(null, e, t, s, r, o, n).then((i) => (Array.prototype.push.apply(t.geometries, i.geometries), Array.prototype.push.apply(t.meshes, i.meshes), Array.prototype.push.apply(t.particleSystems, i.particleSystems), Array.prototype.push.apply(t.skeletons, i.skeletons), Array.prototype.push.apply(t.animationGroups, i.animationGroups), Array.prototype.push.apply(t.materials, a), Array.prototype.push.apply(t.textures, b), Array.prototype.push.apply(t.lights, i.lights), Array.prototype.push.apply(t.transformNodes, i.transformNodes), Array.prototype.push.apply(t.cameras, p), Array.prototype.push.apply(t.morphTargetManagers, d), t));
+    });
+  }
+  /**
+   * @internal
+   */
+  canDirectLoad(e) {
+    return e.indexOf("asset") !== -1 && e.indexOf("version") !== -1 || e.startsWith("data:base64," + h._MagicBase64Encoded) || // this is technically incorrect, but will continue to support for backcompat.
+    e.startsWith("data:;base64," + h._MagicBase64Encoded) || e.startsWith("data:application/octet-stream;base64," + h._MagicBase64Encoded) || e.startsWith("data:model/gltf-binary;base64," + h._MagicBase64Encoded);
+  }
+  /**
+   * @internal
+   */
+  directLoad(e, s) {
+    if (s.startsWith("base64," + h._MagicBase64Encoded) || // this is technically incorrect, but will continue to support for backcompat.
+    s.startsWith(";base64," + h._MagicBase64Encoded) || s.startsWith("application/octet-stream;base64," + h._MagicBase64Encoded) || s.startsWith("model/gltf-binary;base64," + h._MagicBase64Encoded)) {
+      const r = k(s);
+      return this._validate(e, new Uint8Array(r)), this._unpackBinaryAsync(new f({
+        readAsync: (o, n) => A(r, o, n),
+        byteLength: r.byteLength
+      }));
+    }
+    return this._validate(e, s), Promise.resolve({ json: this._parseJson(s) });
+  }
+  /** @internal */
+  createPlugin() {
+    return new h();
+  }
+  /**
+   * The loader state or null if the loader is not active.
+   */
+  get loaderState() {
+    return this._state;
+  }
+  /**
+   * Returns a promise that resolves when the asset is completely loaded.
+   * @returns a promise that resolves when the asset is completely loaded.
+   */
+  whenCompleteAsync() {
+    return new Promise((e, s) => {
+      this.onCompleteObservable.addOnce(() => {
+        e();
+      }), this.onErrorObservable.addOnce((r) => {
+        s(r);
+      });
+    });
+  }
+  /**
+   * @internal
+   */
+  _setState(e) {
+    this._state !== e && (this._state = e, this.onLoaderStateChangedObservable.notifyObservers(this._state), this._log(O[this._state]));
+  }
+  /**
+   * @internal
+   */
+  _loadFile(e, s, r, o, n, t) {
+    const a = e._loadFile(s, r, (b) => {
+      this._onProgress(b, a);
+    }, !0, o, n, t);
+    return a.onCompleteObservable.add((b) => {
+      this._requests.splice(this._requests.indexOf(b), 1);
+    }), this._requests.push(a), a;
+  }
+  _onProgress(e, s) {
+    if (!this._progressCallback)
+      return;
+    s._lengthComputable = e.lengthComputable, s._loaded = e.loaded, s._total = e.total;
+    let r = !0, o = 0, n = 0;
+    for (const t of this._requests) {
+      if (t._lengthComputable === void 0 || t._loaded === void 0 || t._total === void 0)
+        return;
+      r = r && t._lengthComputable, o += t._loaded, n += t._total;
+    }
+    this._progressCallback({
+      lengthComputable: r,
+      loaded: o,
+      total: r ? n : 0
+    });
+  }
+  _validate(e, s, r = "", o = "") {
+    this.validate && (this._startPerformanceCounter("Validate JSON"), M.ValidateAsync(s, r, o, (n) => this.preprocessUrlAsync(r + n).then((t) => e._loadFileAsync(t, void 0, !0, !0))).then((n) => {
+      this._endPerformanceCounter("Validate JSON"), this.onValidatedObservable.notifyObservers(n), this.onValidatedObservable.clear();
+    }, (n) => {
+      this._endPerformanceCounter("Validate JSON"), _.Warn(`Failed to validate: ${n.message}`), this.onValidatedObservable.clear();
+    }));
+  }
+  _getLoader(e) {
+    const s = e.json.asset || {};
+    this._log(`Asset version: ${s.version}`), s.minVersion && this._log(`Asset minimum version: ${s.minVersion}`), s.generator && this._log(`Asset generator: ${s.generator}`);
+    const r = h._parseVersion(s.version);
+    if (!r)
+      throw new Error("Invalid version: " + s.version);
+    if (s.minVersion !== void 0) {
+      const t = h._parseVersion(s.minVersion);
+      if (!t)
+        throw new Error("Invalid minimum version: " + s.minVersion);
+      if (h._compareVersion(t, { major: 2, minor: 0 }) > 0)
+        throw new Error("Incompatible minimum version: " + s.minVersion);
+    }
+    const n = {
+      1: h._CreateGLTF1Loader,
+      2: h._CreateGLTF2Loader
+    }[r.major];
+    if (!n)
+      throw new Error("Unsupported version: " + s.version);
+    return n(this);
+  }
+  _parseJson(e) {
+    this._startPerformanceCounter("Parse JSON"), this._log(`JSON length: ${e.length}`);
+    const s = JSON.parse(e);
+    return this._endPerformanceCounter("Parse JSON"), s;
+  }
+  _unpackBinaryAsync(e) {
+    return this._startPerformanceCounter("Unpack Binary"), e.loadAsync(20).then(() => {
+      const s = {
+        Magic: 1179937895
+      }, r = e.readUint32();
+      if (r !== s.Magic)
+        throw new B("Unexpected magic: " + r, x.GLTFLoaderUnexpectedMagicError);
+      const o = e.readUint32();
+      this.loggingEnabled && this._log(`Binary version: ${o}`);
+      const n = e.readUint32();
+      !this.useRangeRequests && n !== e.buffer.byteLength && g.Warn(`Length in header does not match actual data length: ${n} != ${e.buffer.byteLength}`);
+      let t;
+      switch (o) {
+        case 1: {
+          t = this._unpackBinaryV1Async(e, n);
+          break;
+        }
+        case 2: {
+          t = this._unpackBinaryV2Async(e, n);
+          break;
+        }
+        default:
+          throw new Error("Unsupported version: " + o);
+      }
+      return this._endPerformanceCounter("Unpack Binary"), t;
+    });
+  }
+  _unpackBinaryV1Async(e, s) {
+    const r = {
+      JSON: 0
+    }, o = e.readUint32(), n = e.readUint32();
+    if (n !== r.JSON)
+      throw new Error(`Unexpected content format: ${n}`);
+    const t = s - e.byteOffset, a = { json: this._parseJson(e.readString(o)), bin: null };
+    if (t !== 0) {
+      const b = e.byteOffset;
+      a.bin = {
+        readAsync: (p, d) => e.buffer.readAsync(b + p, d),
+        byteLength: t
+      };
+    }
+    return Promise.resolve(a);
+  }
+  _unpackBinaryV2Async(e, s) {
+    const r = {
+      JSON: 1313821514,
+      BIN: 5130562
+    }, o = e.readUint32();
+    if (e.readUint32() !== r.JSON)
+      throw new Error("First chunk format is not JSON");
+    return e.byteOffset + o === s ? e.loadAsync(o).then(() => ({ json: this._parseJson(e.readString(o)), bin: null })) : e.loadAsync(o + 8).then(() => {
+      const t = { json: this._parseJson(e.readString(o)), bin: null }, a = () => {
+        const b = e.readUint32();
+        switch (e.readUint32()) {
+          case r.JSON:
+            throw new Error("Unexpected JSON chunk");
+          case r.BIN: {
+            const d = e.byteOffset;
+            t.bin = {
+              readAsync: (i, u) => e.buffer.readAsync(d + i, u),
+              byteLength: b
+            }, e.skipBytes(b);
+            break;
+          }
+          default: {
+            e.skipBytes(b);
+            break;
+          }
+        }
+        return e.byteOffset !== s ? e.loadAsync(8).then(a) : Promise.resolve(t);
+      };
+      return a();
+    });
+  }
+  static _parseVersion(e) {
+    if (e === "1.0" || e === "1.0.1")
+      return {
+        major: 1,
+        minor: 0
+      };
+    const s = (e + "").match(/^(\d+)\.(\d+)/);
+    return s ? {
+      major: parseInt(s[1]),
+      minor: parseInt(s[2])
+    } : null;
+  }
+  static _compareVersion(e, s) {
+    return e.major > s.major ? 1 : e.major < s.major ? -1 : e.minor > s.minor ? 1 : e.minor < s.minor ? -1 : 0;
+  }
+  /**
+   * @internal
+   */
+  _logOpen(e) {
+    this._log(e), this._logIndentLevel++;
+  }
+  /** @internal */
+  _logClose() {
+    --this._logIndentLevel;
+  }
+  _logEnabled(e) {
+    const s = h._logSpaces.substr(0, this._logIndentLevel * 2);
+    g.Log(`${s}${e}`);
+  }
+  _logDisabled(e) {
+  }
+  _startPerformanceCounterEnabled(e) {
+    _.StartPerformanceCounter(e);
+  }
+  _startPerformanceCounterDisabled(e) {
+  }
+  _endPerformanceCounterEnabled(e) {
+    _.EndPerformanceCounter(e);
+  }
+  _endPerformanceCounterDisabled(e) {
+  }
+}
+h.IncrementalLoading = !0;
+h.HomogeneousCoordinates = !1;
+h._MagicBase64Encoded = "Z2xURg";
+h._logSpaces = "                                ";
+C && C.RegisterPlugin(new h());
+export {
+  h as GLTFFileLoader,
+  y as GLTFLoaderAnimationStartMode,
+  v as GLTFLoaderCoordinateSystemMode,
+  O as GLTFLoaderState
+};

package/dist/node_modules/@babylonjs/loaders/glTF/glTFValidation.esm.js

@@ -0,0 +1,81 @@
+import { Tools as L } from "../../core/Misc/tools.esm.js";
+function p(s, n, e, t) {
+  const a = {
+    externalResourceFunction: (i) => t(i).then((c) => new Uint8Array(c))
+  };
+  return e && (a.uri = n === "file:" ? e : n + e), s instanceof ArrayBuffer ? GLTFValidator.validateBytes(new Uint8Array(s), a) : GLTFValidator.validateString(s, a);
+}
+function x() {
+  const s = [];
+  onmessage = (n) => {
+    const e = n.data;
+    switch (e.id) {
+      case "init": {
+        importScripts(e.url);
+        break;
+      }
+      case "validate": {
+        p(e.data, e.rootUrl, e.fileName, (t) => new Promise((a, i) => {
+          const c = s.length;
+          s.push({ resolve: a, reject: i }), postMessage({ id: "getExternalResource", index: c, uri: t });
+        })).then((t) => {
+          postMessage({ id: "validate.resolve", value: t });
+        }, (t) => {
+          postMessage({ id: "validate.reject", reason: t });
+        });
+        break;
+      }
+      case "getExternalResource.resolve": {
+        s[e.index].resolve(e.value);
+        break;
+      }
+      case "getExternalResource.reject": {
+        s[e.index].reject(e.reason);
+        break;
+      }
+    }
+  };
+}
+class E {
+  /**
+   * Validate a glTF asset using the glTF-Validator.
+   * @param data The JSON of a glTF or the array buffer of a binary glTF
+   * @param rootUrl The root url for the glTF
+   * @param fileName The file name for the glTF
+   * @param getExternalResource The callback to get external resources for the glTF validator
+   * @returns A promise that resolves with the glTF validation results once complete
+   */
+  static ValidateAsync(n, e, t, a) {
+    const i = ArrayBuffer.isView(n) ? n.slice().buffer : n;
+    return typeof Worker == "function" ? new Promise((c, g) => {
+      const m = `${p}(${x})()`, f = URL.createObjectURL(new Blob([m], { type: "application/javascript" })), r = new Worker(f), l = (v) => {
+        r.removeEventListener("error", l), r.removeEventListener("message", d), g(v);
+      }, d = (v) => {
+        const o = v.data;
+        switch (o.id) {
+          case "getExternalResource": {
+            a(o.uri).then((u) => {
+              r.postMessage({ id: "getExternalResource.resolve", index: o.index, value: u }, [u]);
+            }, (u) => {
+              r.postMessage({ id: "getExternalResource.reject", index: o.index, reason: u });
+            });
+            break;
+          }
+          case "validate.resolve": {
+            r.removeEventListener("error", l), r.removeEventListener("message", d), c(o.value), r.terminate();
+            break;
+          }
+          case "validate.reject":
+            r.removeEventListener("error", l), r.removeEventListener("message", d), g(o.reason), r.terminate();
+        }
+      };
+      r.addEventListener("error", l), r.addEventListener("message", d), r.postMessage({ id: "init", url: this.Configuration.url }), r.postMessage({ id: "validate", data: i, rootUrl: e, fileName: t });
+    }) : (this._LoadScriptPromise || (this._LoadScriptPromise = L.LoadScriptAsync(this.Configuration.url)), this._LoadScriptPromise.then(() => p(i, e, t, a)));
+  }
+}
+E.Configuration = {
+  url: "https://preview.babylonjs.com/gltf_validator.js"
+};
+export {
+  E as GLTFValidation
+};

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@spiffcommerce/preview",
-  "version": "3.6.2-rc.3",
+  "version": "3.6.2-rc.5",
   "description": "An internal implementation of the ThreeDPreviewService interface used by Spiff Commerce",
   "source": "src/index.ts",
   "main": "dist/index.umd.js",
-  "module": "dist/src/index.esm.js",
+  "module": "dist/index.esm.js",
   "types": "dist/index.d.mts",
   "license": "UNLICENSED",
   "scripts": {
@@ -43,11 +43,13 @@
   "size-limit": [
     {
       "limit": "485 KB",
-      "path": "dist/src/index.esm.js"
+      "path": "dist/index.esm.js"
     }
   ],
   "files": [
-    "dist/src/index.esm.js",
+    "dist/lib/*.js",
+    "dist/node_modules/**/*.js",
+    "dist/index.esm.js",
     "dist/index.umd.js",
     "dist/index.d.mts"
   ],