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

package/dist/node_modules/@babylonjs/core/Maths/math.viewport.esm.js

@@ -0,0 +1,41 @@
+class s {
+  /**
+   * Creates a Viewport object located at (x, y) and sized (width, height)
+   * @param x defines viewport left coordinate
+   * @param y defines viewport top coordinate
+   * @param width defines the viewport width
+   * @param height defines the viewport height
+   */
+  constructor(t, h, i, o) {
+    this.x = t, this.y = h, this.width = i, this.height = o;
+  }
+  /**
+   * Creates a new viewport using absolute sizing (from 0-> width, 0-> height instead of 0->1)
+   * @param renderWidth defines the rendering width
+   * @param renderHeight defines the rendering height
+   * @returns a new Viewport
+   */
+  toGlobal(t, h) {
+    return new s(this.x * t, this.y * h, this.width * t, this.height * h);
+  }
+  /**
+   * Stores absolute viewport value into a target viewport (from 0-> width, 0-> height instead of 0->1)
+   * @param renderWidth defines the rendering width
+   * @param renderHeight defines the rendering height
+   * @param ref defines the target viewport
+   * @returns the current viewport
+   */
+  toGlobalToRef(t, h, i) {
+    return i.x = this.x * t, i.y = this.y * h, i.width = this.width * t, i.height = this.height * h, this;
+  }
+  /**
+   * Returns a new Viewport copied from the current one
+   * @returns a new Viewport
+   */
+  clone() {
+    return new s(this.x, this.y, this.width, this.height);
+  }
+}
+export {
+  s as Viewport
+};

package/dist/node_modules/@babylonjs/core/Maths/sphericalPolynomial.esm.js

@@ -0,0 +1,177 @@
+import { Vector3 as s, TmpVectors as c } from "./math.vector.esm.js";
+import "./math.axis.esm.js";
+import "./math.color.esm.js";
+import "./math.plane.esm.js";
+import "./math.path.esm.js";
+const a = [
+  Math.sqrt(1 / (4 * Math.PI)),
+  -Math.sqrt(3 / (4 * Math.PI)),
+  Math.sqrt(3 / (4 * Math.PI)),
+  -Math.sqrt(3 / (4 * Math.PI)),
+  Math.sqrt(15 / (4 * Math.PI)),
+  -Math.sqrt(15 / (4 * Math.PI)),
+  Math.sqrt(5 / (16 * Math.PI)),
+  -Math.sqrt(15 / (4 * Math.PI)),
+  Math.sqrt(15 / (16 * Math.PI))
+  // l22
+], y = [
+  () => 1,
+  (t) => t.y,
+  (t) => t.z,
+  (t) => t.x,
+  (t) => t.x * t.y,
+  (t) => t.y * t.z,
+  (t) => 3 * t.z * t.z - 1,
+  (t) => t.x * t.z,
+  (t) => t.x * t.x - t.y * t.y
+  // l22
+], o = (t, e) => a[t] * y[t](e), h = [Math.PI, 2 * Math.PI / 3, 2 * Math.PI / 3, 2 * Math.PI / 3, Math.PI / 4, Math.PI / 4, Math.PI / 4, Math.PI / 4, Math.PI / 4];
+class I {
+  constructor() {
+    this.preScaled = !1, this.l00 = s.Zero(), this.l1_1 = s.Zero(), this.l10 = s.Zero(), this.l11 = s.Zero(), this.l2_2 = s.Zero(), this.l2_1 = s.Zero(), this.l20 = s.Zero(), this.l21 = s.Zero(), this.l22 = s.Zero();
+  }
+  /**
+   * Adds a light to the spherical harmonics
+   * @param direction the direction of the light
+   * @param color the color of the light
+   * @param deltaSolidAngle the delta solid angle of the light
+   */
+  addLight(e, l, i) {
+    c.Vector3[0].set(l.r, l.g, l.b);
+    const n = c.Vector3[0], r = c.Vector3[1];
+    n.scaleToRef(i, r), r.scaleToRef(o(0, e), c.Vector3[2]), this.l00.addInPlace(c.Vector3[2]), r.scaleToRef(o(1, e), c.Vector3[2]), this.l1_1.addInPlace(c.Vector3[2]), r.scaleToRef(o(2, e), c.Vector3[2]), this.l10.addInPlace(c.Vector3[2]), r.scaleToRef(o(3, e), c.Vector3[2]), this.l11.addInPlace(c.Vector3[2]), r.scaleToRef(o(4, e), c.Vector3[2]), this.l2_2.addInPlace(c.Vector3[2]), r.scaleToRef(o(5, e), c.Vector3[2]), this.l2_1.addInPlace(c.Vector3[2]), r.scaleToRef(o(6, e), c.Vector3[2]), this.l20.addInPlace(c.Vector3[2]), r.scaleToRef(o(7, e), c.Vector3[2]), this.l21.addInPlace(c.Vector3[2]), r.scaleToRef(o(8, e), c.Vector3[2]), this.l22.addInPlace(c.Vector3[2]);
+  }
+  /**
+   * Scales the spherical harmonics by the given amount
+   * @param scale the amount to scale
+   */
+  scaleInPlace(e) {
+    this.l00.scaleInPlace(e), this.l1_1.scaleInPlace(e), this.l10.scaleInPlace(e), this.l11.scaleInPlace(e), this.l2_2.scaleInPlace(e), this.l2_1.scaleInPlace(e), this.l20.scaleInPlace(e), this.l21.scaleInPlace(e), this.l22.scaleInPlace(e);
+  }
+  /**
+   * Convert from incident radiance (Li) to irradiance (E) by applying convolution with the cosine-weighted hemisphere.
+   *
+   * ```
+   * E_lm = A_l * L_lm
+   * ```
+   *
+   * In spherical harmonics this convolution amounts to scaling factors for each frequency band.
+   * This corresponds to equation 5 in "An Efficient Representation for Irradiance Environment Maps", where
+   * the scaling factors are given in equation 9.
+   */
+  convertIncidentRadianceToIrradiance() {
+    this.l00.scaleInPlace(h[0]), this.l1_1.scaleInPlace(h[1]), this.l10.scaleInPlace(h[2]), this.l11.scaleInPlace(h[3]), this.l2_2.scaleInPlace(h[4]), this.l2_1.scaleInPlace(h[5]), this.l20.scaleInPlace(h[6]), this.l21.scaleInPlace(h[7]), this.l22.scaleInPlace(h[8]);
+  }
+  /**
+   * Convert from irradiance to outgoing radiance for Lambertian BDRF, suitable for efficient shader evaluation.
+   *
+   * ```
+   * L = (1/pi) * E * rho
+   * ```
+   *
+   * This is done by an additional scale by 1/pi, so is a fairly trivial operation but important conceptually.
+   */
+  convertIrradianceToLambertianRadiance() {
+    this.scaleInPlace(1 / Math.PI);
+  }
+  /**
+   * Integrates the reconstruction coefficients directly in to the SH preventing further
+   * required operations at run time.
+   *
+   * This is simply done by scaling back the SH with Ylm constants parameter.
+   * The trigonometric part being applied by the shader at run time.
+   */
+  preScaleForRendering() {
+    this.preScaled = !0, this.l00.scaleInPlace(a[0]), this.l1_1.scaleInPlace(a[1]), this.l10.scaleInPlace(a[2]), this.l11.scaleInPlace(a[3]), this.l2_2.scaleInPlace(a[4]), this.l2_1.scaleInPlace(a[5]), this.l20.scaleInPlace(a[6]), this.l21.scaleInPlace(a[7]), this.l22.scaleInPlace(a[8]);
+  }
+  /**
+   * update the spherical harmonics coefficients from the given array
+   * @param data defines the 9x3 coefficients (l00, l1-1, l10, l11, l2-2, l2-1, l20, l21, l22)
+   * @returns the spherical harmonics (this)
+   */
+  updateFromArray(e) {
+    return s.FromArrayToRef(e[0], 0, this.l00), s.FromArrayToRef(e[1], 0, this.l1_1), s.FromArrayToRef(e[2], 0, this.l10), s.FromArrayToRef(e[3], 0, this.l11), s.FromArrayToRef(e[4], 0, this.l2_2), s.FromArrayToRef(e[5], 0, this.l2_1), s.FromArrayToRef(e[6], 0, this.l20), s.FromArrayToRef(e[7], 0, this.l21), s.FromArrayToRef(e[8], 0, this.l22), this;
+  }
+  /**
+   * update the spherical harmonics coefficients from the given floats array
+   * @param data defines the 9x3 coefficients (l00, l1-1, l10, l11, l2-2, l2-1, l20, l21, l22)
+   * @returns the spherical harmonics (this)
+   */
+  updateFromFloatsArray(e) {
+    return s.FromFloatsToRef(e[0], e[1], e[2], this.l00), s.FromFloatsToRef(e[3], e[4], e[5], this.l1_1), s.FromFloatsToRef(e[6], e[7], e[8], this.l10), s.FromFloatsToRef(e[9], e[10], e[11], this.l11), s.FromFloatsToRef(e[12], e[13], e[14], this.l2_2), s.FromFloatsToRef(e[15], e[16], e[17], this.l2_1), s.FromFloatsToRef(e[18], e[19], e[20], this.l20), s.FromFloatsToRef(e[21], e[22], e[23], this.l21), s.FromFloatsToRef(e[24], e[25], e[26], this.l22), this;
+  }
+  /**
+   * Constructs a spherical harmonics from an array.
+   * @param data defines the 9x3 coefficients (l00, l1-1, l10, l11, l2-2, l2-1, l20, l21, l22)
+   * @returns the spherical harmonics
+   */
+  static FromArray(e) {
+    return new I().updateFromArray(e);
+  }
+  // Keep for references.
+  /**
+   * Gets the spherical harmonics from polynomial
+   * @param polynomial the spherical polynomial
+   * @returns the spherical harmonics
+   */
+  static FromPolynomial(e) {
+    const l = new I();
+    return l.l00 = e.xx.scale(0.376127).add(e.yy.scale(0.376127)).add(e.zz.scale(0.376126)), l.l1_1 = e.y.scale(0.977204), l.l10 = e.z.scale(0.977204), l.l11 = e.x.scale(0.977204), l.l2_2 = e.xy.scale(1.16538), l.l2_1 = e.yz.scale(1.16538), l.l20 = e.zz.scale(1.34567).subtract(e.xx.scale(0.672834)).subtract(e.yy.scale(0.672834)), l.l21 = e.zx.scale(1.16538), l.l22 = e.xx.scale(1.16538).subtract(e.yy.scale(1.16538)), l.l1_1.scaleInPlace(-1), l.l11.scaleInPlace(-1), l.l2_1.scaleInPlace(-1), l.l21.scaleInPlace(-1), l.scaleInPlace(Math.PI), l;
+  }
+}
+class P {
+  constructor() {
+    this.x = s.Zero(), this.y = s.Zero(), this.z = s.Zero(), this.xx = s.Zero(), this.yy = s.Zero(), this.zz = s.Zero(), this.xy = s.Zero(), this.yz = s.Zero(), this.zx = s.Zero();
+  }
+  /**
+   * The spherical harmonics used to create the polynomials.
+   */
+  get preScaledHarmonics() {
+    return this._harmonics || (this._harmonics = I.FromPolynomial(this)), this._harmonics.preScaled || this._harmonics.preScaleForRendering(), this._harmonics;
+  }
+  /**
+   * Adds an ambient color to the spherical polynomial
+   * @param color the color to add
+   */
+  addAmbient(e) {
+    c.Vector3[0].copyFromFloats(e.r, e.g, e.b);
+    const l = c.Vector3[0];
+    this.xx.addInPlace(l), this.yy.addInPlace(l), this.zz.addInPlace(l);
+  }
+  /**
+   * Scales the spherical polynomial by the given amount
+   * @param scale the amount to scale
+   */
+  scaleInPlace(e) {
+    this.x.scaleInPlace(e), this.y.scaleInPlace(e), this.z.scaleInPlace(e), this.xx.scaleInPlace(e), this.yy.scaleInPlace(e), this.zz.scaleInPlace(e), this.yz.scaleInPlace(e), this.zx.scaleInPlace(e), this.xy.scaleInPlace(e);
+  }
+  /**
+   * Updates the spherical polynomial from harmonics
+   * @param harmonics the spherical harmonics
+   * @returns the spherical polynomial
+   */
+  updateFromHarmonics(e) {
+    return this._harmonics = e, this.x.copyFrom(e.l11), this.x.scaleInPlace(1.02333).scaleInPlace(-1), this.y.copyFrom(e.l1_1), this.y.scaleInPlace(1.02333).scaleInPlace(-1), this.z.copyFrom(e.l10), this.z.scaleInPlace(1.02333), this.xx.copyFrom(e.l00), c.Vector3[0].copyFrom(e.l20).scaleInPlace(0.247708), c.Vector3[1].copyFrom(e.l22).scaleInPlace(0.429043), this.xx.scaleInPlace(0.886277).subtractInPlace(c.Vector3[0]).addInPlace(c.Vector3[1]), this.yy.copyFrom(e.l00), this.yy.scaleInPlace(0.886277).subtractInPlace(c.Vector3[0]).subtractInPlace(c.Vector3[1]), this.zz.copyFrom(e.l00), c.Vector3[0].copyFrom(e.l20).scaleInPlace(0.495417), this.zz.scaleInPlace(0.886277).addInPlace(c.Vector3[0]), this.yz.copyFrom(e.l2_1), this.yz.scaleInPlace(0.858086).scaleInPlace(-1), this.zx.copyFrom(e.l21), this.zx.scaleInPlace(0.858086).scaleInPlace(-1), this.xy.copyFrom(e.l2_2), this.xy.scaleInPlace(0.858086), this.scaleInPlace(1 / Math.PI), this;
+  }
+  /**
+   * Gets the spherical polynomial from harmonics
+   * @param harmonics the spherical harmonics
+   * @returns the spherical polynomial
+   */
+  static FromHarmonics(e) {
+    return new P().updateFromHarmonics(e);
+  }
+  /**
+   * Constructs a spherical polynomial from an array.
+   * @param data defines the 9x3 coefficients (x, y, z, xx, yy, zz, yz, zx, xy)
+   * @returns the spherical polynomial
+   */
+  static FromArray(e) {
+    const l = new P();
+    return s.FromArrayToRef(e[0], 0, l.x), s.FromArrayToRef(e[1], 0, l.y), s.FromArrayToRef(e[2], 0, l.z), s.FromArrayToRef(e[3], 0, l.xx), s.FromArrayToRef(e[4], 0, l.yy), s.FromArrayToRef(e[5], 0, l.zz), s.FromArrayToRef(e[6], 0, l.yz), s.FromArrayToRef(e[7], 0, l.zx), s.FromArrayToRef(e[8], 0, l.xy), l;
+  }
+}
+export {
+  I as SphericalHarmonics,
+  P as SphericalPolynomial
+};

package/dist/node_modules/@babylonjs/core/Meshes/Builders/boxBuilder.esm.js

@@ -0,0 +1,260 @@
+import { Vector4 as G } from "../../Maths/math.vector.esm.js";
+import { Color4 as S } from "../../Maths/math.color.esm.js";
+import { Mesh as w } from "../mesh.esm.js";
+import { VertexData as u } from "../mesh.vertexData.esm.js";
+import { CompatibilityOptions as m } from "../../Compat/compatibilityOptions.esm.js";
+function V(t) {
+  let a = [0, 1, 2, 0, 2, 3, 4, 5, 6, 4, 6, 7, 8, 9, 10, 8, 10, 11, 12, 13, 14, 12, 14, 15, 16, 17, 18, 16, 18, 19, 20, 21, 22, 20, 22, 23];
+  const l = [
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0,
+    0,
+    -1,
+    0
+  ], s = [];
+  let p = [];
+  const C = t.width || t.size || 1, D = t.height || t.size || 1, A = t.depth || t.size || 1, y = t.wrap || !1;
+  let x = t.topBaseAt === void 0 ? 1 : t.topBaseAt, b = t.bottomBaseAt === void 0 ? 0 : t.bottomBaseAt;
+  x = (x + 4) % 4, b = (b + 4) % 4;
+  const v = [2, 0, 3, 1], L = [2, 0, 1, 3];
+  let B = v[x], U = L[b], h = [
+    1,
+    -1,
+    1,
+    -1,
+    -1,
+    1,
+    -1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    -1,
+    -1,
+    1,
+    -1,
+    -1,
+    -1,
+    -1,
+    1,
+    -1,
+    -1,
+    1,
+    1,
+    -1,
+    1,
+    -1,
+    -1,
+    1,
+    -1,
+    1,
+    1,
+    1,
+    1,
+    -1,
+    1,
+    1,
+    -1,
+    -1,
+    1,
+    -1,
+    -1,
+    -1,
+    -1,
+    1,
+    -1,
+    -1,
+    1,
+    1,
+    -1,
+    1,
+    -1,
+    1,
+    1,
+    -1,
+    1,
+    1,
+    1,
+    1,
+    -1,
+    1,
+    1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    -1,
+    1
+  ];
+  if (y) {
+    a = [2, 3, 0, 2, 0, 1, 4, 5, 6, 4, 6, 7, 9, 10, 11, 9, 11, 8, 12, 14, 15, 12, 13, 14], h = [
+      -1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      -1,
+      1,
+      -1,
+      -1,
+      1,
+      1,
+      1,
+      -1,
+      -1,
+      1,
+      -1,
+      -1,
+      -1,
+      -1,
+      1,
+      -1,
+      -1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      -1,
+      1,
+      -1,
+      -1,
+      1,
+      -1,
+      1,
+      -1,
+      1,
+      -1,
+      -1,
+      1,
+      1,
+      -1,
+      -1,
+      1,
+      -1,
+      -1,
+      -1
+    ];
+    let e = [
+      [1, 1, 1],
+      [-1, 1, 1],
+      [-1, 1, -1],
+      [1, 1, -1]
+    ], r = [
+      [-1, -1, 1],
+      [1, -1, 1],
+      [1, -1, -1],
+      [-1, -1, -1]
+    ];
+    const n = [17, 18, 19, 16], d = [22, 23, 20, 21];
+    for (; B > 0; )
+      e.unshift(e.pop()), n.unshift(n.pop()), B--;
+    for (; U > 0; )
+      r.unshift(r.pop()), d.unshift(d.pop()), U--;
+    e = e.flat(), r = r.flat(), h = h.concat(e).concat(r), a.push(n[0], n[2], n[3], n[0], n[1], n[2]), a.push(d[0], d[2], d[3], d[0], d[1], d[2]);
+  }
+  const z = [C / 2, D / 2, A / 2];
+  p = h.reduce((e, r, n) => e.concat(r * z[n % 3]), []);
+  const F = t.sideOrientation === 0 ? 0 : t.sideOrientation || u.DEFAULTSIDE, o = t.faceUV || new Array(6), i = t.faceColors, O = [];
+  for (let e = 0; e < 6; e++)
+    o[e] === void 0 && (o[e] = new G(0, 0, 1, 1)), i && i[e] === void 0 && (i[e] = new S(1, 1, 1, 1));
+  for (let e = 0; e < 6; e++)
+    if (s.push(o[e].z, m.UseOpenGLOrientationForUV ? 1 - o[e].w : o[e].w), s.push(o[e].x, m.UseOpenGLOrientationForUV ? 1 - o[e].w : o[e].w), s.push(o[e].x, m.UseOpenGLOrientationForUV ? 1 - o[e].y : o[e].y), s.push(o[e].z, m.UseOpenGLOrientationForUV ? 1 - o[e].y : o[e].y), i)
+      for (let r = 0; r < 4; r++)
+        O.push(i[e].r, i[e].g, i[e].b, i[e].a);
+  u._ComputeSides(F, p, a, l, s, t.frontUVs, t.backUVs);
+  const f = new u();
+  if (f.indices = a, f.positions = p, f.normals = l, f.uvs = s, i) {
+    const e = F === u.DOUBLESIDE ? O.concat(O) : O;
+    f.colors = e;
+  }
+  return f;
+}
+function g(t, c = {}, a = null) {
+  const l = new w(t, a);
+  return c.sideOrientation = w._GetDefaultSideOrientation(c.sideOrientation), l._originalBuilderSideOrientation = c.sideOrientation, V(c).applyToMesh(l, c.updatable), l;
+}
+u.CreateBox = V;
+w.CreateBox = (t, c, a = null, l, s) => g(t, {
+  size: c,
+  sideOrientation: s,
+  updatable: l
+}, a);
+export {
+  g as CreateBox,
+  V as CreateBoxVertexData
+};

package/dist/node_modules/@babylonjs/core/Meshes/Compression/dracoCompression.esm.js

@@ -0,0 +1,233 @@
+import { Tools as A } from "../../Misc/tools.esm.js";
+import { AutoReleaseWorkerPool as k } from "../../Misc/workerPool.esm.js";
+import { VertexData as D } from "../mesh.vertexData.esm.js";
+function B(t) {
+  return new Promise((o) => {
+    DracoDecoderModule({ wasmBinary: t }).then((n) => {
+      o({ module: n });
+    });
+  });
+}
+function L(t, o, n, a, i, w) {
+  const m = new t.DecoderBuffer();
+  m.Init(o, o.byteLength);
+  const l = new t.Decoder();
+  let e, c;
+  try {
+    const h = l.GetEncodedGeometryType(m);
+    switch (h) {
+      case t.TRIANGULAR_MESH:
+        e = new t.Mesh(), c = l.DecodeBufferToMesh(m, e);
+        break;
+      case t.POINT_CLOUD:
+        e = new t.PointCloud(), c = l.DecodeBufferToPointCloud(m, e);
+        break;
+      default:
+        throw new Error(`Invalid geometry type ${h}`);
+    }
+    if (!c.ok() || !e.ptr)
+      throw new Error(c.error_msg());
+    if (h === t.TRIANGULAR_MESH) {
+      const f = e.num_faces() * 3, r = f * 4, u = t._malloc(r);
+      try {
+        l.GetTrianglesUInt32Array(e, r, u);
+        const P = new Uint32Array(f);
+        P.set(new Uint32Array(t.HEAPF32.buffer, u, f)), a(P);
+      } finally {
+        t._free(u);
+      }
+    }
+    const v = (s, f, r = 1) => {
+      const u = f.num_components(), P = e.num_points(), p = P * u, U = p * Float32Array.BYTES_PER_ELEMENT, _ = t._malloc(U);
+      try {
+        l.GetAttributeDataArrayForAllPoints(e, f, t.DT_FLOAT32, U, _);
+        const g = new Float32Array(t.HEAPF32.buffer, _, p);
+        if (s === "color" && u === 3) {
+          const d = new Float32Array(P * 4);
+          for (let b = 0, E = 0; b < d.length; b += 4, E += u)
+            d[b + 0] = g[E + 0], d[b + 1] = g[E + 1], d[b + 2] = g[E + 2], d[b + 3] = 1;
+          i(s, d);
+        } else {
+          const d = new Float32Array(p);
+          if (d.set(new Float32Array(t.HEAPF32.buffer, _, p)), r !== 1)
+            for (let b = 0; b < d.length; b++)
+              d[b] = d[b] / r;
+          i(s, d);
+        }
+      } finally {
+        t._free(_);
+      }
+    };
+    if (n)
+      for (const s in n) {
+        const f = n[s], r = l.GetAttributeByUniqueId(e, f), u = w && w[s] || 1;
+        v(s, r, u);
+      }
+    else {
+      const s = {
+        position: "POSITION",
+        normal: "NORMAL",
+        color: "COLOR",
+        uv: "TEX_COORD"
+      };
+      for (const f in s) {
+        const r = l.GetAttributeId(e, t[s[f]]);
+        if (r !== -1) {
+          const u = l.GetAttribute(e, r);
+          v(f, u);
+        }
+      }
+    }
+  } finally {
+    e && t.destroy(e), t.destroy(l), t.destroy(m);
+  }
+}
+function T() {
+  let t;
+  onmessage = (o) => {
+    const n = o.data;
+    switch (n.id) {
+      case "init": {
+        const a = n.decoder;
+        a.url && (importScripts(a.url), t = DracoDecoderModule({ wasmBinary: a.wasmBinary })), postMessage("done");
+        break;
+      }
+      case "decodeMesh": {
+        if (!t)
+          throw new Error("Draco decoder module is not available");
+        t.then((a) => {
+          L(a, n.dataView, n.attributes, (i) => {
+            postMessage({ id: "indices", value: i }, [i.buffer]);
+          }, (i, w) => {
+            postMessage({ id: i, value: w }, [w.buffer]);
+          }), postMessage("done");
+        });
+        break;
+      }
+    }
+  };
+}
+class y {
+  /**
+   * Returns true if the decoder configuration is available.
+   */
+  static get DecoderAvailable() {
+    const o = y.Configuration.decoder;
+    return !!(o.wasmUrl && o.wasmBinaryUrl && typeof WebAssembly == "object" || o.fallbackUrl);
+  }
+  static GetDefaultNumWorkers() {
+    return typeof navigator != "object" || !navigator.hardwareConcurrency ? 1 : Math.min(Math.floor(navigator.hardwareConcurrency * 0.5), 4);
+  }
+  /**
+   * Default instance for the draco compression object.
+   */
+  static get Default() {
+    return y._Default || (y._Default = new y()), y._Default;
+  }
+  /**
+   * Constructor
+   * @param numWorkers The number of workers for async operations. Specify `0` to disable web workers and run synchronously in the current context.
+   */
+  constructor(o = y.DefaultNumWorkers) {
+    const n = y.Configuration.decoder, a = n.wasmUrl && n.wasmBinaryUrl && typeof WebAssembly == "object" ? {
+      url: A.GetAbsoluteUrl(n.wasmUrl),
+      wasmBinaryPromise: A.LoadFileAsync(A.GetAbsoluteUrl(n.wasmBinaryUrl))
+    } : {
+      url: A.GetAbsoluteUrl(n.fallbackUrl),
+      wasmBinaryPromise: Promise.resolve(void 0)
+    };
+    o && typeof Worker == "function" && typeof URL == "function" ? this._workerPoolPromise = a.wasmBinaryPromise.then((i) => {
+      const w = `${L}(${T})()`, m = URL.createObjectURL(new Blob([w], { type: "application/javascript" }));
+      return new k(o, () => new Promise((l, e) => {
+        const c = new Worker(m), h = (s) => {
+          c.removeEventListener("error", h), c.removeEventListener("message", v), e(s);
+        }, v = (s) => {
+          s.data === "done" && (c.removeEventListener("error", h), c.removeEventListener("message", v), l(c));
+        };
+        c.addEventListener("error", h), c.addEventListener("message", v), c.postMessage({
+          id: "init",
+          decoder: {
+            url: a.url,
+            wasmBinary: i
+          }
+        });
+      }));
+    }) : this._decoderModulePromise = a.wasmBinaryPromise.then((i) => {
+      if (!a.url)
+        throw new Error("Draco decoder module is not available");
+      return A.LoadScriptAsync(a.url).then(() => B(i));
+    });
+  }
+  /**
+   * Stop all async operations and release resources.
+   */
+  dispose() {
+    this._workerPoolPromise && this._workerPoolPromise.then((o) => {
+      o.dispose();
+    }), delete this._workerPoolPromise, delete this._decoderModulePromise;
+  }
+  /**
+   * Returns a promise that resolves when ready. Call this manually to ensure draco compression is ready before use.
+   * @returns a promise that resolves when ready
+   */
+  whenReadyAsync() {
+    return this._workerPoolPromise ? this._workerPoolPromise.then(() => {
+    }) : this._decoderModulePromise ? this._decoderModulePromise.then(() => {
+    }) : Promise.resolve();
+  }
+  /**
+   * Decode Draco compressed mesh data to vertex data.
+   * @param data The ArrayBuffer or ArrayBufferView for the Draco compression data
+   * @param attributes A map of attributes from vertex buffer kinds to Draco unique ids
+   * @param dividers a list of optional dividers for normalization
+   * @returns A promise that resolves with the decoded vertex data
+   */
+  decodeMeshAsync(o, n, a) {
+    const i = o instanceof ArrayBuffer ? new Uint8Array(o) : o;
+    if (this._workerPoolPromise)
+      return this._workerPoolPromise.then((w) => new Promise((m, l) => {
+        w.push((e, c) => {
+          const h = new D(), v = (r) => {
+            e.removeEventListener("error", v), e.removeEventListener("message", s), l(r), c();
+          }, s = (r) => {
+            if (r.data === "done")
+              e.removeEventListener("error", v), e.removeEventListener("message", s), m(h), c();
+            else if (r.data.id === "indices")
+              h.indices = r.data.value;
+            else {
+              const u = a && a[r.data.id] ? a[r.data.id] : 1;
+              if (u !== 1)
+                for (let P = 0; P < r.data.value.length; P++)
+                  r.data.value[P] = r.data.value[P] / u;
+              h.set(r.data.value, r.data.id);
+            }
+          };
+          e.addEventListener("error", v), e.addEventListener("message", s);
+          const f = new Uint8Array(i.byteLength);
+          f.set(new Uint8Array(i.buffer, i.byteOffset, i.byteLength)), e.postMessage({ id: "decodeMesh", dataView: f, attributes: n }, [f.buffer]);
+        });
+      }));
+    if (this._decoderModulePromise)
+      return this._decoderModulePromise.then((w) => {
+        const m = new D();
+        return L(w.module, i, n, (l) => {
+          m.indices = l;
+        }, (l, e) => {
+          m.set(e, l);
+        }, a), m;
+      });
+    throw new Error("Draco decoder module is not available");
+  }
+}
+y.Configuration = {
+  decoder: {
+    wasmUrl: "https://preview.babylonjs.com/draco_wasm_wrapper_gltf.js",
+    wasmBinaryUrl: "https://preview.babylonjs.com/draco_decoder_gltf.wasm",
+    fallbackUrl: "https://preview.babylonjs.com/draco_decoder_gltf.js"
+  }
+};
+y.DefaultNumWorkers = y.GetDefaultNumWorkers();
+y._Default = null;
+export {
+  y as DracoCompression
+};