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

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

@@ -1,6 +0,0 @@
-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

@@ -1,91 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,145 +0,0 @@
-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

@@ -1,284 +0,0 @@
-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
-};