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

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

@@ -0,0 +1,6 @@
+const o = 0.45454545454545453, a = 2.2, c = 1e-3;
+export {
+  c as Epsilon,
+  o as ToGammaSpace,
+  a as ToLinearSpace
+};

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

@@ -0,0 +1,91 @@
+import { Plane as n } from "./math.plane.esm.js";
+class i {
+  /**
+   * Gets the planes representing the frustum
+   * @param transform matrix to be applied to the returned planes
+   * @returns a new array of 6 Frustum planes computed by the given transformation matrix.
+   */
+  static GetPlanes(a) {
+    const e = [];
+    for (let o = 0; o < 6; o++)
+      e.push(new n(0, 0, 0, 0));
+    return i.GetPlanesToRef(a, e), e;
+  }
+  /**
+   * Gets the near frustum plane transformed by the transform matrix
+   * @param transform transformation matrix to be applied to the resulting frustum plane
+   * @param frustumPlane the resulting frustum plane
+   */
+  static GetNearPlaneToRef(a, e) {
+    const o = a.m;
+    e.normal.x = o[3] + o[2], e.normal.y = o[7] + o[6], e.normal.z = o[11] + o[10], e.d = o[15] + o[14], e.normalize();
+  }
+  /**
+   * Gets the far frustum plane transformed by the transform matrix
+   * @param transform transformation matrix to be applied to the resulting frustum plane
+   * @param frustumPlane the resulting frustum plane
+   */
+  static GetFarPlaneToRef(a, e) {
+    const o = a.m;
+    e.normal.x = o[3] - o[2], e.normal.y = o[7] - o[6], e.normal.z = o[11] - o[10], e.d = o[15] - o[14], e.normalize();
+  }
+  /**
+   * Gets the left frustum plane transformed by the transform matrix
+   * @param transform transformation matrix to be applied to the resulting frustum plane
+   * @param frustumPlane the resulting frustum plane
+   */
+  static GetLeftPlaneToRef(a, e) {
+    const o = a.m;
+    e.normal.x = o[3] + o[0], e.normal.y = o[7] + o[4], e.normal.z = o[11] + o[8], e.d = o[15] + o[12], e.normalize();
+  }
+  /**
+   * Gets the right frustum plane transformed by the transform matrix
+   * @param transform transformation matrix to be applied to the resulting frustum plane
+   * @param frustumPlane the resulting frustum plane
+   */
+  static GetRightPlaneToRef(a, e) {
+    const o = a.m;
+    e.normal.x = o[3] - o[0], e.normal.y = o[7] - o[4], e.normal.z = o[11] - o[8], e.d = o[15] - o[12], e.normalize();
+  }
+  /**
+   * Gets the top frustum plane transformed by the transform matrix
+   * @param transform transformation matrix to be applied to the resulting frustum plane
+   * @param frustumPlane the resulting frustum plane
+   */
+  static GetTopPlaneToRef(a, e) {
+    const o = a.m;
+    e.normal.x = o[3] - o[1], e.normal.y = o[7] - o[5], e.normal.z = o[11] - o[9], e.d = o[15] - o[13], e.normalize();
+  }
+  /**
+   * Gets the bottom frustum plane transformed by the transform matrix
+   * @param transform transformation matrix to be applied to the resulting frustum plane
+   * @param frustumPlane the resulting frustum plane
+   */
+  static GetBottomPlaneToRef(a, e) {
+    const o = a.m;
+    e.normal.x = o[3] + o[1], e.normal.y = o[7] + o[5], e.normal.z = o[11] + o[9], e.d = o[15] + o[13], e.normalize();
+  }
+  /**
+   * Sets the given array "frustumPlanes" with the 6 Frustum planes computed by the given transformation matrix.
+   * @param transform transformation matrix to be applied to the resulting frustum planes
+   * @param frustumPlanes the resulting frustum planes
+   */
+  static GetPlanesToRef(a, e) {
+    i.GetNearPlaneToRef(a, e[0]), i.GetFarPlaneToRef(a, e[1]), i.GetLeftPlaneToRef(a, e[2]), i.GetRightPlaneToRef(a, e[3]), i.GetTopPlaneToRef(a, e[4]), i.GetBottomPlaneToRef(a, e[5]);
+  }
+  /**
+   * Tests if a point is located between the frustum planes.
+   * @param point defines the point to test
+   * @param frustumPlanes defines the frustum planes to test
+   * @returns true if the point is located between the frustum planes
+   */
+  static IsPointInFrustum(a, e) {
+    for (let o = 0; o < 6; o++)
+      if (e[o].dotCoordinate(a) < 0)
+        return !1;
+    return !0;
+  }
+}
+export {
+  i as Frustum
+};

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

@@ -0,0 +1,43 @@
+import { __decorate as f } from "../tslib.es6.esm.js";
+import { Vector3 as l } from "./math.vector.esm.js";
+import { nativeOverride as a } from "../Misc/decorators.esm.js";
+class d {
+  static extractMinAndMaxIndexed(x, t, r, e, m, n) {
+    for (let M = r; M < r + e; M++) {
+      const c = t[M] * 3, u = x[c], y = x[c + 1], o = x[c + 2];
+      m.minimizeInPlaceFromFloats(u, y, o), n.maximizeInPlaceFromFloats(u, y, o);
+    }
+  }
+  static extractMinAndMax(x, t, r, e, m, n) {
+    for (let M = t, c = t * e; M < t + r; M++, c += e) {
+      const u = x[c], y = x[c + 1], o = x[c + 2];
+      m.minimizeInPlaceFromFloats(u, y, o), n.maximizeInPlaceFromFloats(u, y, o);
+    }
+  }
+}
+f([
+  a.filter((...[A, x]) => !Array.isArray(A) && !Array.isArray(x))
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+], d, "extractMinAndMaxIndexed", null);
+f([
+  a.filter((...[A]) => !Array.isArray(A))
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+], d, "extractMinAndMax", null);
+function V(A, x, t, r, e = null) {
+  const m = new l(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE), n = new l(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
+  return d.extractMinAndMaxIndexed(A, x, t, r, m, n), e && (m.x -= m.x * e.x + e.y, m.y -= m.y * e.x + e.y, m.z -= m.z * e.x + e.y, n.x += n.x * e.x + e.y, n.y += n.y * e.x + e.y, n.z += n.z * e.x + e.y), {
+    minimum: m,
+    maximum: n
+  };
+}
+function E(A, x, t, r = null, e) {
+  const m = new l(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE), n = new l(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
+  return e || (e = 3), d.extractMinAndMax(A, x, t, e, m, n), r && (m.x -= m.x * r.x + r.y, m.y -= m.y * r.x + r.y, m.z -= m.z * r.x + r.y, n.x += n.x * r.x + r.y, n.y += n.y * r.x + r.y, n.z += n.z * r.x + r.y), {
+    minimum: m,
+    maximum: n
+  };
+}
+export {
+  E as extractMinAndMax,
+  V as extractMinAndMaxIndexed
+};

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

@@ -0,0 +1,9 @@
+import "./math.scalar.esm.js";
+import "./math.vector.esm.js";
+var W;
+(function(C) {
+  C[C.CW = 0] = "CW", C[C.CCW = 1] = "CCW";
+})(W || (W = {}));
+export {
+  W as Orientation
+};

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

@@ -0,0 +1,145 @@
+import { Matrix as u, Vector3 as y } from "./math.vector.esm.js";
+class o {
+  /**
+   * Creates a Plane object according to the given floats a, b, c, d and the plane equation : ax + by + cz + d = 0
+   * @param a a component of the plane
+   * @param b b component of the plane
+   * @param c c component of the plane
+   * @param d d component of the plane
+   */
+  constructor(t, r, s, n) {
+    this.normal = new y(t, r, s), this.d = n;
+  }
+  /**
+   * @returns the plane coordinates as a new array of 4 elements [a, b, c, d].
+   */
+  asArray() {
+    return [this.normal.x, this.normal.y, this.normal.z, this.d];
+  }
+  // Methods
+  /**
+   * @returns a new plane copied from the current Plane.
+   */
+  clone() {
+    return new o(this.normal.x, this.normal.y, this.normal.z, this.d);
+  }
+  /**
+   * @returns the string "Plane".
+   */
+  getClassName() {
+    return "Plane";
+  }
+  /**
+   * @returns the Plane hash code.
+   */
+  getHashCode() {
+    let t = this.normal.getHashCode();
+    return t = t * 397 ^ (this.d | 0), t;
+  }
+  /**
+   * Normalize the current Plane in place.
+   * @returns the updated Plane.
+   */
+  normalize() {
+    const t = Math.sqrt(this.normal.x * this.normal.x + this.normal.y * this.normal.y + this.normal.z * this.normal.z);
+    let r = 0;
+    return t !== 0 && (r = 1 / t), this.normal.x *= r, this.normal.y *= r, this.normal.z *= r, this.d *= r, this;
+  }
+  /**
+   * Applies a transformation the plane and returns the result
+   * @param transformation the transformation matrix to be applied to the plane
+   * @returns a new Plane as the result of the transformation of the current Plane by the given matrix.
+   */
+  transform(t) {
+    const r = o._TmpMatrix;
+    t.invertToRef(r);
+    const s = r.m, n = this.normal.x, i = this.normal.y, h = this.normal.z, a = this.d, l = n * s[0] + i * s[1] + h * s[2] + a * s[3], x = n * s[4] + i * s[5] + h * s[6] + a * s[7], m = n * s[8] + i * s[9] + h * s[10] + a * s[11], e = n * s[12] + i * s[13] + h * s[14] + a * s[15];
+    return new o(l, x, m, e);
+  }
+  /**
+   * Compute the dot product between the point and the plane normal
+   * @param point point to calculate the dot product with
+   * @returns the dot product (float) of the point coordinates and the plane normal.
+   */
+  dotCoordinate(t) {
+    return this.normal.x * t.x + this.normal.y * t.y + this.normal.z * t.z + this.d;
+  }
+  /**
+   * Updates the current Plane from the plane defined by the three given points.
+   * @param point1 one of the points used to construct the plane
+   * @param point2 one of the points used to construct the plane
+   * @param point3 one of the points used to construct the plane
+   * @returns the updated Plane.
+   */
+  copyFromPoints(t, r, s) {
+    const n = r.x - t.x, i = r.y - t.y, h = r.z - t.z, a = s.x - t.x, l = s.y - t.y, x = s.z - t.z, m = i * x - h * l, e = h * a - n * x, z = n * l - i * a, d = Math.sqrt(m * m + e * e + z * z);
+    let c;
+    return d !== 0 ? c = 1 / d : c = 0, this.normal.x = m * c, this.normal.y = e * c, this.normal.z = z * c, this.d = -(this.normal.x * t.x + this.normal.y * t.y + this.normal.z * t.z), this;
+  }
+  /**
+   * Checks if the plane is facing a given direction (meaning if the plane's normal is pointing in the opposite direction of the given vector).
+   * Note that for this function to work as expected you should make sure that:
+   *   - direction and the plane normal are normalized
+   *   - epsilon is a number just bigger than -1, something like -0.99 for eg
+   * @param direction the direction to check if the plane is facing
+   * @param epsilon value the dot product is compared against (returns true if dot <= epsilon)
+   * @returns True if the plane is facing the given direction
+   */
+  isFrontFacingTo(t, r) {
+    return y.Dot(this.normal, t) <= r;
+  }
+  /**
+   * Calculates the distance to a point
+   * @param point point to calculate distance to
+   * @returns the signed distance (float) from the given point to the Plane.
+   */
+  signedDistanceTo(t) {
+    return y.Dot(t, this.normal) + this.d;
+  }
+  // Statics
+  /**
+   * Creates a plane from an  array
+   * @param array the array to create a plane from
+   * @returns a new Plane from the given array.
+   */
+  static FromArray(t) {
+    return new o(t[0], t[1], t[2], t[3]);
+  }
+  /**
+   * Creates a plane from three points
+   * @param point1 point used to create the plane
+   * @param point2 point used to create the plane
+   * @param point3 point used to create the plane
+   * @returns a new Plane defined by the three given points.
+   */
+  static FromPoints(t, r, s) {
+    const n = new o(0, 0, 0, 0);
+    return n.copyFromPoints(t, r, s), n;
+  }
+  /**
+   * Creates a plane from an origin point and a normal
+   * @param origin origin of the plane to be constructed
+   * @param normal normal of the plane to be constructed
+   * @returns a new Plane the normal vector to this plane at the given origin point.
+   * Note : the vector "normal" is updated because normalized.
+   */
+  static FromPositionAndNormal(t, r) {
+    const s = new o(0, 0, 0, 0);
+    return r.normalize(), s.normal = r, s.d = -(r.x * t.x + r.y * t.y + r.z * t.z), s;
+  }
+  /**
+   * Calculates the distance from a plane and a point
+   * @param origin origin of the plane to be constructed
+   * @param normal normal of the plane to be constructed
+   * @param point point to calculate distance to
+   * @returns the signed distance between the plane defined by the normal vector at the "origin"" point and the given other point.
+   */
+  static SignedDistanceToPlaneFromPositionAndNormal(t, r, s) {
+    const n = -(r.x * t.x + r.y * t.y + r.z * t.z);
+    return y.Dot(s, r) + n;
+  }
+}
+o._TmpMatrix = u.Identity();
+export {
+  o as Plane
+};

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

@@ -0,0 +1,284 @@
+class i {
+  /**
+   * Boolean : true if the absolute difference between a and b is lower than epsilon (default = 1.401298E-45)
+   * @param a number
+   * @param b number
+   * @param epsilon (default = 1.401298E-45)
+   * @returns true if the absolute difference between a and b is lower than epsilon (default = 1.401298E-45)
+   */
+  static WithinEpsilon(t, r, e = 1401298e-51) {
+    return Math.abs(t - r) <= e;
+  }
+  /**
+   * Returns a string : the upper case translation of the number i to hexadecimal.
+   * @param i number
+   * @returns the upper case translation of the number i to hexadecimal.
+   */
+  static ToHex(t) {
+    const r = t.toString(16);
+    return t <= 15 ? ("0" + r).toUpperCase() : r.toUpperCase();
+  }
+  /**
+   * Returns -1 if value is negative and +1 is value is positive.
+   * @param value the value
+   * @returns the value itself if it's equal to zero.
+   */
+  static Sign(t) {
+    return t = +t, t === 0 || isNaN(t) ? t : t > 0 ? 1 : -1;
+  }
+  /**
+   * Returns the value itself if it's between min and max.
+   * Returns min if the value is lower than min.
+   * Returns max if the value is greater than max.
+   * @param value the value to clmap
+   * @param min the min value to clamp to (default: 0)
+   * @param max the max value to clamp to (default: 1)
+   * @returns the clamped value
+   */
+  static Clamp(t, r = 0, e = 1) {
+    return Math.min(e, Math.max(r, t));
+  }
+  /**
+   * the log2 of value.
+   * @param value the value to compute log2 of
+   * @returns the log2 of value.
+   */
+  static Log2(t) {
+    return Math.log(t) * Math.LOG2E;
+  }
+  /**
+   * the floor part of a log2 value.
+   * @param value the value to compute log2 of
+   * @returns the log2 of value.
+   */
+  static ILog2(t) {
+    if (Math.log2)
+      return Math.floor(Math.log2(t));
+    if (t < 0)
+      return NaN;
+    if (t === 0)
+      return -1 / 0;
+    let r = 0;
+    if (t < 1) {
+      for (; t < 1; )
+        r++, t = t * 2;
+      r = -r;
+    } else if (t > 1)
+      for (; t > 1; )
+        r++, t = Math.floor(t / 2);
+    return r;
+  }
+  /**
+   * Loops the value, so that it is never larger than length and never smaller than 0.
+   *
+   * This is similar to the modulo operator but it works with floating point numbers.
+   * For example, using 3.0 for t and 2.5 for length, the result would be 0.5.
+   * With t = 5 and length = 2.5, the result would be 0.0.
+   * Note, however, that the behaviour is not defined for negative numbers as it is for the modulo operator
+   * @param value the value
+   * @param length the length
+   * @returns the looped value
+   */
+  static Repeat(t, r) {
+    return t - Math.floor(t / r) * r;
+  }
+  /**
+   * Normalize the value between 0.0 and 1.0 using min and max values
+   * @param value value to normalize
+   * @param min max to normalize between
+   * @param max min to normalize between
+   * @returns the normalized value
+   */
+  static Normalize(t, r, e) {
+    return (t - r) / (e - r);
+  }
+  /**
+   * Denormalize the value from 0.0 and 1.0 using min and max values
+   * @param normalized value to denormalize
+   * @param min max to denormalize between
+   * @param max min to denormalize between
+   * @returns the denormalized value
+   */
+  static Denormalize(t, r, e) {
+    return t * (e - r) + r;
+  }
+  /**
+   * Calculates the shortest difference between two given angles given in degrees.
+   * @param current current angle in degrees
+   * @param target target angle in degrees
+   * @returns the delta
+   */
+  static DeltaAngle(t, r) {
+    let e = i.Repeat(r - t, 360);
+    return e > 180 && (e -= 360), e;
+  }
+  /**
+   * PingPongs the value t, so that it is never larger than length and never smaller than 0.
+   * @param tx value
+   * @param length length
+   * @returns The returned value will move back and forth between 0 and length
+   */
+  static PingPong(t, r) {
+    const e = i.Repeat(t, r * 2);
+    return r - Math.abs(e - r);
+  }
+  /**
+   * Interpolates between min and max with smoothing at the limits.
+   *
+   * This function interpolates between min and max in a similar way to Lerp. However, the interpolation will gradually speed up
+   * from the start and slow down toward the end. This is useful for creating natural-looking animation, fading and other transitions.
+   * @param from from
+   * @param to to
+   * @param tx value
+   * @returns the smooth stepped value
+   */
+  static SmoothStep(t, r, e) {
+    let s = i.Clamp(e);
+    return s = -2 * s * s * s + 3 * s * s, r * s + t * (1 - s);
+  }
+  /**
+   * Moves a value current towards target.
+   *
+   * This is essentially the same as Mathf.Lerp but instead the function will ensure that the speed never exceeds maxDelta.
+   * Negative values of maxDelta pushes the value away from target.
+   * @param current current value
+   * @param target target value
+   * @param maxDelta max distance to move
+   * @returns resulting value
+   */
+  static MoveTowards(t, r, e) {
+    let s = 0;
+    return Math.abs(r - t) <= e ? s = r : s = t + i.Sign(r - t) * e, s;
+  }
+  /**
+   * Same as MoveTowards but makes sure the values interpolate correctly when they wrap around 360 degrees.
+   *
+   * Variables current and target are assumed to be in degrees. For optimization reasons, negative values of maxDelta
+   *  are not supported and may cause oscillation. To push current away from a target angle, add 180 to that angle instead.
+   * @param current current value
+   * @param target target value
+   * @param maxDelta max distance to move
+   * @returns resulting angle
+   */
+  static MoveTowardsAngle(t, r, e) {
+    const s = i.DeltaAngle(t, r);
+    let n = 0;
+    return -e < s && s < e ? n = r : (r = t + s, n = i.MoveTowards(t, r, e)), n;
+  }
+  /**
+   * Creates a new scalar with values linearly interpolated of "amount" between the start scalar and the end scalar.
+   * @param start start value
+   * @param end target value
+   * @param amount amount to lerp between
+   * @returns the lerped value
+   */
+  static Lerp(t, r, e) {
+    return t + (r - t) * e;
+  }
+  /**
+   * Same as Lerp but makes sure the values interpolate correctly when they wrap around 360 degrees.
+   * The parameter t is clamped to the range [0, 1]. Variables a and b are assumed to be in degrees.
+   * @param start start value
+   * @param end target value
+   * @param amount amount to lerp between
+   * @returns the lerped value
+   */
+  static LerpAngle(t, r, e) {
+    let s = i.Repeat(r - t, 360);
+    return s > 180 && (s -= 360), t + s * i.Clamp(e);
+  }
+  /**
+   * Calculates the linear parameter t that produces the interpolant value within the range [a, b].
+   * @param a start value
+   * @param b target value
+   * @param value value between a and b
+   * @returns the inverseLerp value
+   */
+  static InverseLerp(t, r, e) {
+    let s = 0;
+    return t != r ? s = i.Clamp((e - t) / (r - t)) : s = 0, s;
+  }
+  /**
+   * Returns a new scalar located for "amount" (float) on the Hermite spline defined by the scalars "value1", "value3", "tangent1", "tangent2".
+   * @see http://mathworld.wolfram.com/HermitePolynomial.html
+   * @param value1 defines the first control point
+   * @param tangent1 defines the first tangent
+   * @param value2 defines the second control point
+   * @param tangent2 defines the second tangent
+   * @param amount defines the amount on the interpolation spline (between 0 and 1)
+   * @returns hermite result
+   */
+  static Hermite(t, r, e, s, n) {
+    const o = n * n, c = n * o, p = 2 * c - 3 * o + 1, a = -2 * c + 3 * o, f = c - 2 * o + n, M = c - o;
+    return t * p + e * a + r * f + s * M;
+  }
+  /**
+   * Returns a new scalar which is the 1st derivative of the Hermite spline defined by the scalars "value1", "value2", "tangent1", "tangent2".
+   * @param value1 defines the first control point
+   * @param tangent1 defines the first tangent
+   * @param value2 defines the second control point
+   * @param tangent2 defines the second tangent
+   * @param time define where the derivative must be done
+   * @returns 1st derivative
+   */
+  static Hermite1stDerivative(t, r, e, s, n) {
+    const o = n * n;
+    return (o - n) * 6 * t + (3 * o - 4 * n + 1) * r + (-o + n) * 6 * e + (3 * o - 2 * n) * s;
+  }
+  /**
+   * Returns a random float number between and min and max values
+   * @param min min value of random
+   * @param max max value of random
+   * @returns random value
+   */
+  static RandomRange(t, r) {
+    return t === r ? t : Math.random() * (r - t) + t;
+  }
+  /**
+   * This function returns percentage of a number in a given range.
+   *
+   * RangeToPercent(40,20,60) will return 0.5 (50%)
+   * RangeToPercent(34,0,100) will return 0.34 (34%)
+   * @param number to convert to percentage
+   * @param min min range
+   * @param max max range
+   * @returns the percentage
+   */
+  static RangeToPercent(t, r, e) {
+    return (t - r) / (e - r);
+  }
+  /**
+   * This function returns number that corresponds to the percentage in a given range.
+   *
+   * PercentToRange(0.34,0,100) will return 34.
+   * @param percent to convert to number
+   * @param min min range
+   * @param max max range
+   * @returns the number
+   */
+  static PercentToRange(t, r, e) {
+    return (e - r) * t + r;
+  }
+  /**
+   * Returns the angle converted to equivalent value between -Math.PI and Math.PI radians.
+   * @param angle The angle to normalize in radian.
+   * @returns The converted angle.
+   */
+  static NormalizeRadians(t) {
+    return t -= i.TwoPi * Math.floor((t + Math.PI) / i.TwoPi), t;
+  }
+  /**
+   * Returns the highest common factor of two integers.
+   * @param a first parameter
+   * @param b second parameter
+   * @returns HCF of a and b
+   */
+  static HCF(t, r) {
+    const e = t % r;
+    return e === 0 ? r : i.HCF(r, e);
+  }
+}
+i.TwoPi = Math.PI * 2;
+export {
+  i as Scalar
+};