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

package/dist/node_modules/@babylonjs/core/Collisions/pickingInfo.esm.js

@@ -1,59 +0,0 @@
-import { TmpVectors as h, Vector3 as o, Vector2 as m } from "../Maths/math.vector.esm.js";
-import { VertexBuffer as p } from "../Buffers/buffer.esm.js";
-class g {
-  constructor() {
-    this.hit = !1, this.distance = 0, this.pickedPoint = null, this.pickedMesh = null, this.bu = 0, this.bv = 0, this.faceId = -1, this.subMeshFaceId = -1, this.subMeshId = 0, this.pickedSprite = null, this.thinInstanceIndex = -1, this.ray = null, this.originMesh = null, this.aimTransform = null, this.gripTransform = null;
-  }
-  /**
-   * Gets the normal corresponding to the face the pick collided with
-   * @param useWorldCoordinates If the resulting normal should be relative to the world (default: false)
-   * @param useVerticesNormals If the vertices normals should be used to calculate the normal instead of the normal map (default: true)
-   * @returns The normal corresponding to the face the pick collided with
-   * @remarks Note that the returned normal will always point towards the picking ray.
-   */
-  getNormal(f = !1, n = !0) {
-    if (!this.pickedMesh || n && !this.pickedMesh.isVerticesDataPresent(p.NormalKind))
-      return null;
-    let e = this.pickedMesh.getIndices();
-    (e == null ? void 0 : e.length) === 0 && (e = null);
-    let i;
-    const c = h.Vector3[0], a = h.Vector3[1], d = h.Vector3[2];
-    if (n) {
-      const t = this.pickedMesh.getVerticesData(p.NormalKind);
-      let r = e ? o.FromArrayToRef(t, e[this.faceId * 3] * 3, c) : c.copyFromFloats(t[this.faceId * 3 * 3], t[this.faceId * 3 * 3 + 1], t[this.faceId * 3 * 3 + 2]), s = e ? o.FromArrayToRef(t, e[this.faceId * 3 + 1] * 3, a) : a.copyFromFloats(t[(this.faceId * 3 + 1) * 3], t[(this.faceId * 3 + 1) * 3 + 1], t[(this.faceId * 3 + 1) * 3 + 2]), l = e ? o.FromArrayToRef(t, e[this.faceId * 3 + 2] * 3, d) : d.copyFromFloats(t[(this.faceId * 3 + 2) * 3], t[(this.faceId * 3 + 2) * 3 + 1], t[(this.faceId * 3 + 2) * 3 + 2]);
-      r = r.scale(this.bu), s = s.scale(this.bv), l = l.scale(1 - this.bu - this.bv), i = new o(r.x + s.x + l.x, r.y + s.y + l.y, r.z + s.z + l.z);
-    } else {
-      const t = this.pickedMesh.getVerticesData(p.PositionKind), r = e ? o.FromArrayToRef(t, e[this.faceId * 3] * 3, c) : c.copyFromFloats(t[this.faceId * 3 * 3], t[this.faceId * 3 * 3 + 1], t[this.faceId * 3 * 3 + 2]), s = e ? o.FromArrayToRef(t, e[this.faceId * 3 + 1] * 3, a) : a.copyFromFloats(t[(this.faceId * 3 + 1) * 3], t[(this.faceId * 3 + 1) * 3 + 1], t[(this.faceId * 3 + 1) * 3 + 2]), l = e ? o.FromArrayToRef(t, e[this.faceId * 3 + 2] * 3, d) : d.copyFromFloats(t[(this.faceId * 3 + 2) * 3], t[(this.faceId * 3 + 2) * 3 + 1], t[(this.faceId * 3 + 2) * 3 + 2]), u = r.subtract(s), F = l.subtract(s);
-      i = o.Cross(u, F);
-    }
-    const I = (t, r) => {
-      let s = t.getWorldMatrix();
-      t.nonUniformScaling && (h.Matrix[0].copyFrom(s), s = h.Matrix[0], s.setTranslationFromFloats(0, 0, 0), s.invert(), s.transposeToRef(h.Matrix[1]), s = h.Matrix[1]), o.TransformNormalToRef(r, s, r);
-    };
-    if (f && I(this.pickedMesh, i), this.ray) {
-      const t = h.Vector3[0].copyFrom(i);
-      f || I(this.pickedMesh, t), o.Dot(t, this.ray.direction) > 0 && i.negateInPlace();
-    }
-    return i.normalize(), i;
-  }
-  /**
-   * Gets the texture coordinates of where the pick occurred
-   * @param uvSet The UV set to use to calculate the texture coordinates (default: VertexBuffer.UVKind)
-   * @returns The vector containing the coordinates of the texture
-   */
-  getTextureCoordinates(f = p.UVKind) {
-    if (!this.pickedMesh || !this.pickedMesh.isVerticesDataPresent(f))
-      return null;
-    const n = this.pickedMesh.getIndices();
-    if (!n)
-      return null;
-    const e = this.pickedMesh.getVerticesData(f);
-    if (!e)
-      return null;
-    let i = m.FromArray(e, n[this.faceId * 3] * 2), c = m.FromArray(e, n[this.faceId * 3 + 1] * 2), a = m.FromArray(e, n[this.faceId * 3 + 2] * 2);
-    return i = i.scale(this.bu), c = c.scale(this.bv), a = a.scale(1 - this.bu - this.bv), new m(i.x + c.x + a.x, i.y + c.y + a.y);
-  }
-}
-export {
-  g as PickingInfo
-};

package/dist/node_modules/@babylonjs/core/Compat/compatibilityOptions.esm.js

@@ -1,6 +0,0 @@
-class i {
-}
-i.UseOpenGLOrientationForUV = !1;
-export {
-  i as CompatibilityOptions
-};

package/dist/node_modules/@babylonjs/core/Culling/boundingBox.esm.js

@@ -1,174 +0,0 @@
-import { ArrayTools as f } from "../Misc/arrayTools.esm.js";
-import { Vector3 as n, Matrix as W } from "../Maths/math.vector.esm.js";
-import { Epsilon as I } from "../Maths/math.constants.esm.js";
-class d {
-  /**
-   * Creates a new bounding box
-   * @param min defines the minimum vector (in local space)
-   * @param max defines the maximum vector (in local space)
-   * @param worldMatrix defines the new world matrix
-   */
-  constructor(t, r, e) {
-    this.vectors = f.BuildArray(8, n.Zero), this.center = n.Zero(), this.centerWorld = n.Zero(), this.extendSize = n.Zero(), this.extendSizeWorld = n.Zero(), this.directions = f.BuildArray(3, n.Zero), this.vectorsWorld = f.BuildArray(8, n.Zero), this.minimumWorld = n.Zero(), this.maximumWorld = n.Zero(), this.minimum = n.Zero(), this.maximum = n.Zero(), this._drawWrapperFront = null, this._drawWrapperBack = null, this.reConstruct(t, r, e);
-  }
-  // Methods
-  /**
-   * Recreates the entire bounding box from scratch as if we call the constructor in place
-   * @param min defines the new minimum vector (in local space)
-   * @param max defines the new maximum vector (in local space)
-   * @param worldMatrix defines the new world matrix
-   */
-  reConstruct(t, r, e) {
-    const o = t.x, s = t.y, m = t.z, i = r.x, a = r.y, l = r.z, c = this.vectors;
-    this.minimum.copyFromFloats(o, s, m), this.maximum.copyFromFloats(i, a, l), c[0].copyFromFloats(o, s, m), c[1].copyFromFloats(i, a, l), c[2].copyFromFloats(i, s, m), c[3].copyFromFloats(o, a, m), c[4].copyFromFloats(o, s, l), c[5].copyFromFloats(i, a, m), c[6].copyFromFloats(o, a, l), c[7].copyFromFloats(i, s, l), r.addToRef(t, this.center).scaleInPlace(0.5), r.subtractToRef(t, this.extendSize).scaleInPlace(0.5), this._worldMatrix = e || W.IdentityReadOnly, this._update(this._worldMatrix);
-  }
-  /**
-   * Scale the current bounding box by applying a scale factor
-   * @param factor defines the scale factor to apply
-   * @returns the current bounding box
-   */
-  scale(t) {
-    const r = d._TmpVector3, e = this.maximum.subtractToRef(this.minimum, r[0]), o = e.length();
-    e.normalizeFromLength(o);
-    const s = o * t, m = e.scaleInPlace(s * 0.5), i = this.center.subtractToRef(m, r[1]), a = this.center.addToRef(m, r[2]);
-    return this.reConstruct(i, a, this._worldMatrix), this;
-  }
-  /**
-   * Gets the world matrix of the bounding box
-   * @returns a matrix
-   */
-  getWorldMatrix() {
-    return this._worldMatrix;
-  }
-  /**
-   * @internal
-   */
-  _update(t) {
-    const r = this.minimumWorld, e = this.maximumWorld, o = this.directions, s = this.vectorsWorld, m = this.vectors;
-    if (t.isIdentity()) {
-      r.copyFrom(this.minimum), e.copyFrom(this.maximum);
-      for (let i = 0; i < 8; ++i)
-        s[i].copyFrom(m[i]);
-      this.extendSizeWorld.copyFrom(this.extendSize), this.centerWorld.copyFrom(this.center);
-    } else {
-      r.setAll(Number.MAX_VALUE), e.setAll(-Number.MAX_VALUE);
-      for (let i = 0; i < 8; ++i) {
-        const a = s[i];
-        n.TransformCoordinatesToRef(m[i], t, a), r.minimizeInPlace(a), e.maximizeInPlace(a);
-      }
-      e.subtractToRef(r, this.extendSizeWorld).scaleInPlace(0.5), e.addToRef(r, this.centerWorld).scaleInPlace(0.5);
-    }
-    n.FromArrayToRef(t.m, 0, o[0]), n.FromArrayToRef(t.m, 4, o[1]), n.FromArrayToRef(t.m, 8, o[2]), this._worldMatrix = t;
-  }
-  /**
-   * Tests if the bounding box is intersecting the frustum planes
-   * @param frustumPlanes defines the frustum planes to test
-   * @returns true if there is an intersection
-   */
-  isInFrustum(t) {
-    return d.IsInFrustum(this.vectorsWorld, t);
-  }
-  /**
-   * Tests if the bounding box is entirely inside the frustum planes
-   * @param frustumPlanes defines the frustum planes to test
-   * @returns true if there is an inclusion
-   */
-  isCompletelyInFrustum(t) {
-    return d.IsCompletelyInFrustum(this.vectorsWorld, t);
-  }
-  /**
-   * Tests if a point is inside the bounding box
-   * @param point defines the point to test
-   * @returns true if the point is inside the bounding box
-   */
-  intersectsPoint(t) {
-    const r = this.minimumWorld, e = this.maximumWorld, o = r.x, s = r.y, m = r.z, i = e.x, a = e.y, l = e.z, c = t.x, h = t.y, y = t.z, u = -I;
-    return !(i - c < u || u > c - o || a - h < u || u > h - s || l - y < u || u > y - m);
-  }
-  /**
-   * Tests if the bounding box intersects with a bounding sphere
-   * @param sphere defines the sphere to test
-   * @returns true if there is an intersection
-   */
-  intersectsSphere(t) {
-    return d.IntersectsSphere(this.minimumWorld, this.maximumWorld, t.centerWorld, t.radiusWorld);
-  }
-  /**
-   * Tests if the bounding box intersects with a box defined by a min and max vectors
-   * @param min defines the min vector to use
-   * @param max defines the max vector to use
-   * @returns true if there is an intersection
-   */
-  intersectsMinMax(t, r) {
-    const e = this.minimumWorld, o = this.maximumWorld, s = e.x, m = e.y, i = e.z, a = o.x, l = o.y, c = o.z, h = t.x, y = t.y, u = t.z, p = r.x, x = r.y, F = r.z;
-    return !(a < h || s > p || l < y || m > x || c < u || i > F);
-  }
-  /**
-   * Disposes the resources of the class
-   */
-  dispose() {
-    var t, r;
-    (t = this._drawWrapperFront) === null || t === void 0 || t.dispose(), (r = this._drawWrapperBack) === null || r === void 0 || r.dispose();
-  }
-  // Statics
-  /**
-   * Tests if two bounding boxes are intersections
-   * @param box0 defines the first box to test
-   * @param box1 defines the second box to test
-   * @returns true if there is an intersection
-   */
-  static Intersects(t, r) {
-    return t.intersectsMinMax(r.minimumWorld, r.maximumWorld);
-  }
-  /**
-   * Tests if a bounding box defines by a min/max vectors intersects a sphere
-   * @param minPoint defines the minimum vector of the bounding box
-   * @param maxPoint defines the maximum vector of the bounding box
-   * @param sphereCenter defines the sphere center
-   * @param sphereRadius defines the sphere radius
-   * @returns true if there is an intersection
-   */
-  static IntersectsSphere(t, r, e, o) {
-    const s = d._TmpVector3[0];
-    return n.ClampToRef(e, t, r, s), n.DistanceSquared(e, s) <= o * o;
-  }
-  /**
-   * Tests if a bounding box defined with 8 vectors is entirely inside frustum planes
-   * @param boundingVectors defines an array of 8 vectors representing a bounding box
-   * @param frustumPlanes defines the frustum planes to test
-   * @returns true if there is an inclusion
-   */
-  static IsCompletelyInFrustum(t, r) {
-    for (let e = 0; e < 6; ++e) {
-      const o = r[e];
-      for (let s = 0; s < 8; ++s)
-        if (o.dotCoordinate(t[s]) < 0)
-          return !1;
-    }
-    return !0;
-  }
-  /**
-   * Tests if a bounding box defined with 8 vectors intersects frustum planes
-   * @param boundingVectors defines an array of 8 vectors representing a bounding box
-   * @param frustumPlanes defines the frustum planes to test
-   * @returns true if there is an intersection
-   */
-  static IsInFrustum(t, r) {
-    for (let e = 0; e < 6; ++e) {
-      let o = !0;
-      const s = r[e];
-      for (let m = 0; m < 8; ++m)
-        if (s.dotCoordinate(t[m]) >= 0) {
-          o = !1;
-          break;
-        }
-      if (o)
-        return !1;
-    }
-    return !0;
-  }
-}
-d._TmpVector3 = f.BuildArray(3, n.Zero);
-export {
-  d as BoundingBox
-};

package/dist/node_modules/@babylonjs/core/Culling/boundingInfo.esm.js

@@ -1,159 +0,0 @@
-import { ArrayTools as b } from "../Misc/arrayTools.esm.js";
-import { Vector3 as r, TmpVectors as h } from "../Maths/math.vector.esm.js";
-import { BoundingBox as a } from "./boundingBox.esm.js";
-import { BoundingSphere as l } from "./boundingSphere.esm.js";
-const c = { min: 0, max: 0 }, d = { min: 0, max: 0 }, f = (o, i, e) => {
-  const t = r.Dot(i.centerWorld, o), n = Math.abs(r.Dot(i.directions[0], o)) * i.extendSize.x, g = Math.abs(r.Dot(i.directions[1], o)) * i.extendSize.y, x = Math.abs(r.Dot(i.directions[2], o)) * i.extendSize.z, m = n + g + x;
-  e.min = t - m, e.max = t + m;
-}, s = (o, i, e) => (f(o, i, c), f(o, e, d), !(c.min > d.max || d.min > c.max));
-class u {
-  /**
-   * Constructs bounding info
-   * @param minimum min vector of the bounding box/sphere
-   * @param maximum max vector of the bounding box/sphere
-   * @param worldMatrix defines the new world matrix
-   */
-  constructor(i, e, t) {
-    this._isLocked = !1, this.boundingBox = new a(i, e, t), this.boundingSphere = new l(i, e, t);
-  }
-  /**
-   * Recreates the entire bounding info from scratch as if we call the constructor in place
-   * @param min defines the new minimum vector (in local space)
-   * @param max defines the new maximum vector (in local space)
-   * @param worldMatrix defines the new world matrix
-   */
-  reConstruct(i, e, t) {
-    this.boundingBox.reConstruct(i, e, t), this.boundingSphere.reConstruct(i, e, t);
-  }
-  /**
-   * min vector of the bounding box/sphere
-   */
-  get minimum() {
-    return this.boundingBox.minimum;
-  }
-  /**
-   * max vector of the bounding box/sphere
-   */
-  get maximum() {
-    return this.boundingBox.maximum;
-  }
-  /**
-   * If the info is locked and won't be updated to avoid perf overhead
-   */
-  get isLocked() {
-    return this._isLocked;
-  }
-  set isLocked(i) {
-    this._isLocked = i;
-  }
-  // Methods
-  /**
-   * Updates the bounding sphere and box
-   * @param world world matrix to be used to update
-   */
-  update(i) {
-    this._isLocked || (this.boundingBox._update(i), this.boundingSphere._update(i));
-  }
-  /**
-   * Recreate the bounding info to be centered around a specific point given a specific extend.
-   * @param center New center of the bounding info
-   * @param extend New extend of the bounding info
-   * @returns the current bounding info
-   */
-  centerOn(i, e) {
-    const t = u._TmpVector3[0].copyFrom(i).subtractInPlace(e), n = u._TmpVector3[1].copyFrom(i).addInPlace(e);
-    return this.boundingBox.reConstruct(t, n, this.boundingBox.getWorldMatrix()), this.boundingSphere.reConstruct(t, n, this.boundingBox.getWorldMatrix()), this;
-  }
-  /**
-   * Grows the bounding info to include the given point.
-   * @param point The point that will be included in the current bounding info (in local space)
-   * @returns the current bounding info
-   */
-  encapsulate(i) {
-    const e = r.Minimize(this.minimum, i), t = r.Maximize(this.maximum, i);
-    return this.reConstruct(e, t, this.boundingBox.getWorldMatrix()), this;
-  }
-  /**
-   * Grows the bounding info to encapsulate the given bounding info.
-   * @param toEncapsulate The bounding info that will be encapsulated in the current bounding info
-   * @returns the current bounding info
-   */
-  encapsulateBoundingInfo(i) {
-    const e = h.Matrix[0];
-    this.boundingBox.getWorldMatrix().invertToRef(e);
-    const t = h.Vector3[0];
-    return r.TransformCoordinatesToRef(i.boundingBox.minimumWorld, e, t), this.encapsulate(t), r.TransformCoordinatesToRef(i.boundingBox.maximumWorld, e, t), this.encapsulate(t), this;
-  }
-  /**
-   * Scale the current bounding info by applying a scale factor
-   * @param factor defines the scale factor to apply
-   * @returns the current bounding info
-   */
-  scale(i) {
-    return this.boundingBox.scale(i), this.boundingSphere.scale(i), this;
-  }
-  /**
-   * Returns `true` if the bounding info is within the frustum defined by the passed array of planes.
-   * @param frustumPlanes defines the frustum to test
-   * @param strategy defines the strategy to use for the culling (default is BABYLON.AbstractMesh.CULLINGSTRATEGY_STANDARD)
-   * The different strategies available are:
-   * * BABYLON.AbstractMesh.CULLINGSTRATEGY_STANDARD most accurate but slower @see https://doc.babylonjs.com/typedoc/classes/BABYLON.AbstractMesh#CULLINGSTRATEGY_STANDARD
-   * * BABYLON.AbstractMesh.CULLINGSTRATEGY_BOUNDINGSPHERE_ONLY faster but less accurate @see https://doc.babylonjs.com/typedoc/classes/BABYLON.AbstractMesh#CULLINGSTRATEGY_BOUNDINGSPHERE_ONLY
-   * * BABYLON.AbstractMesh.CULLINGSTRATEGY_OPTIMISTIC_INCLUSION can be faster if always visible @see https://doc.babylonjs.com/typedoc/classes/BABYLON.AbstractMesh#CULLINGSTRATEGY_OPTIMISTIC_INCLUSION
-   * * BABYLON.AbstractMesh.CULLINGSTRATEGY_OPTIMISTIC_INCLUSION_THEN_BSPHERE_ONLY can be faster if always visible @see https://doc.babylonjs.com/typedoc/classes/BABYLON.AbstractMesh#CULLINGSTRATEGY_OPTIMISTIC_INCLUSION_THEN_BSPHERE_ONLY
-   * @returns true if the bounding info is in the frustum planes
-   */
-  isInFrustum(i, e = 0) {
-    return (e === 2 || e === 3) && this.boundingSphere.isCenterInFrustum(i) ? !0 : this.boundingSphere.isInFrustum(i) ? e === 1 || e === 3 ? !0 : this.boundingBox.isInFrustum(i) : !1;
-  }
-  /**
-   * Gets the world distance between the min and max points of the bounding box
-   */
-  get diagonalLength() {
-    const i = this.boundingBox;
-    return i.maximumWorld.subtractToRef(i.minimumWorld, u._TmpVector3[0]).length();
-  }
-  /**
-   * Checks if a cullable object (mesh...) is in the camera frustum
-   * Unlike isInFrustum this checks the full bounding box
-   * @param frustumPlanes Camera near/planes
-   * @returns true if the object is in frustum otherwise false
-   */
-  isCompletelyInFrustum(i) {
-    return this.boundingBox.isCompletelyInFrustum(i);
-  }
-  /**
-   * @internal
-   */
-  _checkCollision(i) {
-    return i._canDoCollision(this.boundingSphere.centerWorld, this.boundingSphere.radiusWorld, this.boundingBox.minimumWorld, this.boundingBox.maximumWorld);
-  }
-  /**
-   * Checks if a point is inside the bounding box and bounding sphere or the mesh
-   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/interactions/mesh_intersect
-   * @param point the point to check intersection with
-   * @returns if the point intersects
-   */
-  intersectsPoint(i) {
-    return !(!this.boundingSphere.centerWorld || !this.boundingSphere.intersectsPoint(i) || !this.boundingBox.intersectsPoint(i));
-  }
-  /**
-   * Checks if another bounding info intersects the bounding box and bounding sphere or the mesh
-   * @see https://doc.babylonjs.com/features/featuresDeepDive/mesh/interactions/mesh_intersect
-   * @param boundingInfo the bounding info to check intersection with
-   * @param precise if the intersection should be done using OBB
-   * @returns if the bounding info intersects
-   */
-  intersects(i, e) {
-    if (!l.Intersects(this.boundingSphere, i.boundingSphere) || !a.Intersects(this.boundingBox, i.boundingBox))
-      return !1;
-    if (!e)
-      return !0;
-    const t = this.boundingBox, n = i.boundingBox;
-    return !(!s(t.directions[0], t, n) || !s(t.directions[1], t, n) || !s(t.directions[2], t, n) || !s(n.directions[0], t, n) || !s(n.directions[1], t, n) || !s(n.directions[2], t, n) || !s(r.Cross(t.directions[0], n.directions[0]), t, n) || !s(r.Cross(t.directions[0], n.directions[1]), t, n) || !s(r.Cross(t.directions[0], n.directions[2]), t, n) || !s(r.Cross(t.directions[1], n.directions[0]), t, n) || !s(r.Cross(t.directions[1], n.directions[1]), t, n) || !s(r.Cross(t.directions[1], n.directions[2]), t, n) || !s(r.Cross(t.directions[2], n.directions[0]), t, n) || !s(r.Cross(t.directions[2], n.directions[1]), t, n) || !s(r.Cross(t.directions[2], n.directions[2]), t, n));
-  }
-}
-u._TmpVector3 = b.BuildArray(2, r.Zero);
-export {
-  u as BoundingInfo
-};

package/dist/node_modules/@babylonjs/core/Culling/boundingSphere.esm.js

@@ -1,114 +0,0 @@
-import { ArrayTools as d } from "../Misc/arrayTools.esm.js";
-import { Vector3 as o, Matrix as c } from "../Maths/math.vector.esm.js";
-class i {
-  /**
-   * Creates a new bounding sphere
-   * @param min defines the minimum vector (in local space)
-   * @param max defines the maximum vector (in local space)
-   * @param worldMatrix defines the new world matrix
-   */
-  constructor(t, r, e) {
-    this.center = o.Zero(), this.centerWorld = o.Zero(), this.minimum = o.Zero(), this.maximum = o.Zero(), this.reConstruct(t, r, e);
-  }
-  /**
-   * Recreates the entire bounding sphere from scratch as if we call the constructor in place
-   * @param min defines the new minimum vector (in local space)
-   * @param max defines the new maximum vector (in local space)
-   * @param worldMatrix defines the new world matrix
-   */
-  reConstruct(t, r, e) {
-    this.minimum.copyFrom(t), this.maximum.copyFrom(r);
-    const s = o.Distance(t, r);
-    r.addToRef(t, this.center).scaleInPlace(0.5), this.radius = s * 0.5, this._update(e || c.IdentityReadOnly);
-  }
-  /**
-   * Scale the current bounding sphere by applying a scale factor
-   * @param factor defines the scale factor to apply
-   * @returns the current bounding box
-   */
-  scale(t) {
-    const r = this.radius * t, e = i._TmpVector3, s = e[0].setAll(r), a = this.center.subtractToRef(s, e[1]), n = this.center.addToRef(s, e[2]);
-    return this.reConstruct(a, n, this._worldMatrix), this;
-  }
-  /**
-   * Gets the world matrix of the bounding box
-   * @returns a matrix
-   */
-  getWorldMatrix() {
-    return this._worldMatrix;
-  }
-  // Methods
-  /**
-   * @internal
-   */
-  _update(t) {
-    if (t.isIdentity())
-      this.centerWorld.copyFrom(this.center), this.radiusWorld = this.radius;
-    else {
-      o.TransformCoordinatesToRef(this.center, t, this.centerWorld);
-      const r = i._TmpVector3[0];
-      o.TransformNormalFromFloatsToRef(1, 1, 1, t, r), this.radiusWorld = Math.max(Math.abs(r.x), Math.abs(r.y), Math.abs(r.z)) * this.radius;
-    }
-  }
-  /**
-   * Tests if the bounding sphere is intersecting the frustum planes
-   * @param frustumPlanes defines the frustum planes to test
-   * @returns true if there is an intersection
-   */
-  isInFrustum(t) {
-    const r = this.centerWorld, e = this.radiusWorld;
-    for (let s = 0; s < 6; s++)
-      if (t[s].dotCoordinate(r) <= -e)
-        return !1;
-    return !0;
-  }
-  /**
-   * Tests if the bounding sphere center is in between the frustum planes.
-   * Used for optimistic fast inclusion.
-   * @param frustumPlanes defines the frustum planes to test
-   * @returns true if the sphere center is in between the frustum planes
-   */
-  isCenterInFrustum(t) {
-    const r = this.centerWorld;
-    for (let e = 0; e < 6; e++)
-      if (t[e].dotCoordinate(r) < 0)
-        return !1;
-    return !0;
-  }
-  /**
-   * Tests if a point is inside the bounding sphere
-   * @param point defines the point to test
-   * @returns true if the point is inside the bounding sphere
-   */
-  intersectsPoint(t) {
-    const r = o.DistanceSquared(this.centerWorld, t);
-    return !(this.radiusWorld * this.radiusWorld < r);
-  }
-  // Statics
-  /**
-   * Checks if two sphere intersect
-   * @param sphere0 sphere 0
-   * @param sphere1 sphere 1
-   * @returns true if the spheres intersect
-   */
-  static Intersects(t, r) {
-    const e = o.DistanceSquared(t.centerWorld, r.centerWorld), s = t.radiusWorld + r.radiusWorld;
-    return !(s * s < e);
-  }
-  /**
-   * Creates a sphere from a center and a radius
-   * @param center The center
-   * @param radius radius
-   * @param matrix Optional worldMatrix
-   * @returns The sphere
-   */
-  static CreateFromCenterAndRadius(t, r, e) {
-    this._TmpVector3[0].copyFrom(t), this._TmpVector3[1].copyFromFloats(0, 0, r), this._TmpVector3[2].copyFrom(t), this._TmpVector3[0].addInPlace(this._TmpVector3[1]), this._TmpVector3[2].subtractInPlace(this._TmpVector3[1]);
-    const s = new i(this._TmpVector3[0], this._TmpVector3[2]);
-    return e ? s._worldMatrix = e : s._worldMatrix = c.Identity(), s;
-  }
-}
-i._TmpVector3 = d.BuildArray(3, o.Zero);
-export {
-  i as BoundingSphere
-};

package/dist/node_modules/@babylonjs/core/DeviceInput/InputDevices/deviceEnums.esm.js

@@ -1,37 +0,0 @@
-var R;
-(function(L) {
-  L[L.Generic = 0] = "Generic", L[L.Keyboard = 1] = "Keyboard", L[L.Mouse = 2] = "Mouse", L[L.Touch = 3] = "Touch", L[L.DualShock = 4] = "DualShock", L[L.Xbox = 5] = "Xbox", L[L.Switch = 6] = "Switch", L[L.DualSense = 7] = "DualSense";
-})(R || (R = {}));
-var d;
-(function(L) {
-  L[L.Horizontal = 0] = "Horizontal", L[L.Vertical = 1] = "Vertical", L[L.LeftClick = 2] = "LeftClick", L[L.MiddleClick = 3] = "MiddleClick", L[L.RightClick = 4] = "RightClick", L[L.BrowserBack = 5] = "BrowserBack", L[L.BrowserForward = 6] = "BrowserForward", L[L.MouseWheelX = 7] = "MouseWheelX", L[L.MouseWheelY = 8] = "MouseWheelY", L[L.MouseWheelZ = 9] = "MouseWheelZ", L[L.Move = 12] = "Move";
-})(d || (d = {}));
-var A;
-(function(L) {
-  L[L.Horizontal = 0] = "Horizontal", L[L.Vertical = 1] = "Vertical", L[L.LeftClick = 2] = "LeftClick", L[L.MiddleClick = 3] = "MiddleClick", L[L.RightClick = 4] = "RightClick", L[L.BrowserBack = 5] = "BrowserBack", L[L.BrowserForward = 6] = "BrowserForward", L[L.MouseWheelX = 7] = "MouseWheelX", L[L.MouseWheelY = 8] = "MouseWheelY", L[L.MouseWheelZ = 9] = "MouseWheelZ", L[L.DeltaHorizontal = 10] = "DeltaHorizontal", L[L.DeltaVertical = 11] = "DeltaVertical";
-})(A || (A = {}));
-var r;
-(function(L) {
-  L[L.Cross = 0] = "Cross", L[L.Circle = 1] = "Circle", L[L.Square = 2] = "Square", L[L.Triangle = 3] = "Triangle", L[L.L1 = 4] = "L1", L[L.R1 = 5] = "R1", L[L.L2 = 6] = "L2", L[L.R2 = 7] = "R2", L[L.Share = 8] = "Share", L[L.Options = 9] = "Options", L[L.L3 = 10] = "L3", L[L.R3 = 11] = "R3", L[L.DPadUp = 12] = "DPadUp", L[L.DPadDown = 13] = "DPadDown", L[L.DPadLeft = 14] = "DPadLeft", L[L.DPadRight = 15] = "DPadRight", L[L.Home = 16] = "Home", L[L.TouchPad = 17] = "TouchPad", L[L.LStickXAxis = 18] = "LStickXAxis", L[L.LStickYAxis = 19] = "LStickYAxis", L[L.RStickXAxis = 20] = "RStickXAxis", L[L.RStickYAxis = 21] = "RStickYAxis";
-})(r || (r = {}));
-var s;
-(function(L) {
-  L[L.Cross = 0] = "Cross", L[L.Circle = 1] = "Circle", L[L.Square = 2] = "Square", L[L.Triangle = 3] = "Triangle", L[L.L1 = 4] = "L1", L[L.R1 = 5] = "R1", L[L.L2 = 6] = "L2", L[L.R2 = 7] = "R2", L[L.Create = 8] = "Create", L[L.Options = 9] = "Options", L[L.L3 = 10] = "L3", L[L.R3 = 11] = "R3", L[L.DPadUp = 12] = "DPadUp", L[L.DPadDown = 13] = "DPadDown", L[L.DPadLeft = 14] = "DPadLeft", L[L.DPadRight = 15] = "DPadRight", L[L.Home = 16] = "Home", L[L.TouchPad = 17] = "TouchPad", L[L.LStickXAxis = 18] = "LStickXAxis", L[L.LStickYAxis = 19] = "LStickYAxis", L[L.RStickXAxis = 20] = "RStickXAxis", L[L.RStickYAxis = 21] = "RStickYAxis";
-})(s || (s = {}));
-var C;
-(function(L) {
-  L[L.A = 0] = "A", L[L.B = 1] = "B", L[L.X = 2] = "X", L[L.Y = 3] = "Y", L[L.LB = 4] = "LB", L[L.RB = 5] = "RB", L[L.LT = 6] = "LT", L[L.RT = 7] = "RT", L[L.Back = 8] = "Back", L[L.Start = 9] = "Start", L[L.LS = 10] = "LS", L[L.RS = 11] = "RS", L[L.DPadUp = 12] = "DPadUp", L[L.DPadDown = 13] = "DPadDown", L[L.DPadLeft = 14] = "DPadLeft", L[L.DPadRight = 15] = "DPadRight", L[L.Home = 16] = "Home", L[L.LStickXAxis = 17] = "LStickXAxis", L[L.LStickYAxis = 18] = "LStickYAxis", L[L.RStickXAxis = 19] = "RStickXAxis", L[L.RStickYAxis = 20] = "RStickYAxis";
-})(C || (C = {}));
-var Y;
-(function(L) {
-  L[L.B = 0] = "B", L[L.A = 1] = "A", L[L.Y = 2] = "Y", L[L.X = 3] = "X", L[L.L = 4] = "L", L[L.R = 5] = "R", L[L.ZL = 6] = "ZL", L[L.ZR = 7] = "ZR", L[L.Minus = 8] = "Minus", L[L.Plus = 9] = "Plus", L[L.LS = 10] = "LS", L[L.RS = 11] = "RS", L[L.DPadUp = 12] = "DPadUp", L[L.DPadDown = 13] = "DPadDown", L[L.DPadLeft = 14] = "DPadLeft", L[L.DPadRight = 15] = "DPadRight", L[L.Home = 16] = "Home", L[L.Capture = 17] = "Capture", L[L.LStickXAxis = 18] = "LStickXAxis", L[L.LStickYAxis = 19] = "LStickYAxis", L[L.RStickXAxis = 20] = "RStickXAxis", L[L.RStickYAxis = 21] = "RStickYAxis";
-})(Y || (Y = {}));
-export {
-  R as DeviceType,
-  s as DualSenseInput,
-  r as DualShockInput,
-  A as NativePointerInput,
-  d as PointerInput,
-  Y as SwitchInput,
-  C as XboxInput
-};

package/dist/node_modules/@babylonjs/core/DeviceInput/InputDevices/deviceSource.esm.js

@@ -1,23 +0,0 @@
-import { Observable as s } from "../../Misc/observable.esm.js";
-class o {
-  /**
-   * Default Constructor
-   * @param deviceInputSystem - Reference to DeviceInputSystem
-   * @param deviceType - Type of device
-   * @param deviceSlot - "Slot" or index that device is referenced in
-   */
-  constructor(e, t, i = 0) {
-    this.deviceType = t, this.deviceSlot = i, this.onInputChangedObservable = new s(), this._deviceInputSystem = e;
-  }
-  /**
-   * Get input for specific input
-   * @param inputIndex - index of specific input on device
-   * @returns Input value from DeviceInputSystem
-   */
-  getInput(e) {
-    return this._deviceInputSystem.pollInput(this.deviceType, this.deviceSlot, e);
-  }
-}
-export {
-  o as DeviceSource
-};