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

package/dist/node_modules/@babylonjs/core/Audio/weightedsound.esm.js

@@ -0,0 +1,117 @@
+import { Logger as r } from "../Misc/logger.esm.js";
+class u {
+  /**
+   * Creates a new WeightedSound from the list of sounds given.
+   * @param loop When true a Sound will be selected and played when the current playing Sound completes.
+   * @param sounds Array of Sounds that will be selected from.
+   * @param weights Array of number values for selection weights; length must equal sounds, values will be normalized to 1
+   */
+  constructor(e, n, o) {
+    if (this.loop = !1, this._coneInnerAngle = 360, this._coneOuterAngle = 360, this._volume = 1, this.isPlaying = !1, this.isPaused = !1, this._sounds = [], this._weights = [], n.length !== o.length)
+      throw new Error("Sounds length does not equal weights length");
+    this.loop = e, this._weights = o;
+    let s = 0;
+    for (const t of o)
+      s += t;
+    const i = s > 0 ? 1 / s : 0;
+    for (let t = 0; t < this._weights.length; t++)
+      this._weights[t] *= i;
+    this._sounds = n;
+    for (const t of this._sounds)
+      t.onEndedObservable.add(() => {
+        this._onended();
+      });
+  }
+  /**
+   * The size of cone in degrees for a directional sound in which there will be no attenuation.
+   */
+  get directionalConeInnerAngle() {
+    return this._coneInnerAngle;
+  }
+  /**
+   * The size of cone in degrees for a directional sound in which there will be no attenuation.
+   */
+  set directionalConeInnerAngle(e) {
+    if (e !== this._coneInnerAngle) {
+      if (this._coneOuterAngle < e) {
+        r.Error("directionalConeInnerAngle: outer angle of the cone must be superior or equal to the inner angle.");
+        return;
+      }
+      this._coneInnerAngle = e;
+      for (const n of this._sounds)
+        n.directionalConeInnerAngle = e;
+    }
+  }
+  /**
+   * Size of cone in degrees for a directional sound outside of which there will be no sound.
+   * Listener angles between innerAngle and outerAngle will falloff linearly.
+   */
+  get directionalConeOuterAngle() {
+    return this._coneOuterAngle;
+  }
+  /**
+   * Size of cone in degrees for a directional sound outside of which there will be no sound.
+   * Listener angles between innerAngle and outerAngle will falloff linearly.
+   */
+  set directionalConeOuterAngle(e) {
+    if (e !== this._coneOuterAngle) {
+      if (e < this._coneInnerAngle) {
+        r.Error("directionalConeOuterAngle: outer angle of the cone must be superior or equal to the inner angle.");
+        return;
+      }
+      this._coneOuterAngle = e;
+      for (const n of this._sounds)
+        n.directionalConeOuterAngle = e;
+    }
+  }
+  /**
+   * Playback volume.
+   */
+  get volume() {
+    return this._volume;
+  }
+  /**
+   * Playback volume.
+   */
+  set volume(e) {
+    if (e !== this._volume)
+      for (const n of this._sounds)
+        n.setVolume(e);
+  }
+  _onended() {
+    this._currentIndex !== void 0 && (this._sounds[this._currentIndex].autoplay = !1), this.loop && this.isPlaying ? this.play() : this.isPlaying = !1;
+  }
+  /**
+   * Suspend playback
+   */
+  pause() {
+    this.isPaused = !0, this._currentIndex !== void 0 && this._sounds[this._currentIndex].pause();
+  }
+  /**
+   * Stop playback
+   */
+  stop() {
+    this.isPlaying = !1, this._currentIndex !== void 0 && this._sounds[this._currentIndex].stop();
+  }
+  /**
+   * Start playback.
+   * @param startOffset Position the clip head at a specific time in seconds.
+   */
+  play(e) {
+    if (!this.isPaused) {
+      this.stop();
+      const o = Math.random();
+      let s = 0;
+      for (let i = 0; i < this._weights.length; i++)
+        if (s += this._weights[i], o <= s) {
+          this._currentIndex = i;
+          break;
+        }
+    }
+    const n = this._sounds[this._currentIndex];
+    n.isReady() ? n.play(0, this.isPaused ? void 0 : e) : n.autoplay = !0, this.isPlaying = !0, this.isPaused = !1;
+  }
+}
+export {
+  u as WeightedSound
+};

package/dist/node_modules/@babylonjs/core/Behaviors/Cameras/autoRotationBehavior.esm.js

@@ -0,0 +1,145 @@
+import { PointerEventTypes as s } from "../../Events/pointerEvents.esm.js";
+import { PrecisionDate as i } from "../../Misc/precisionDate.esm.js";
+import { Epsilon as h } from "../../Maths/math.constants.esm.js";
+class c {
+  constructor() {
+    this._zoomStopsAnimation = !1, this._idleRotationSpeed = 0.05, this._idleRotationWaitTime = 2e3, this._idleRotationSpinupTime = 2e3, this.targetAlpha = null, this._isPointerDown = !1, this._lastFrameTime = null, this._lastInteractionTime = -1 / 0, this._cameraRotationSpeed = 0, this._lastFrameRadius = 0;
+  }
+  /**
+   * Gets the name of the behavior.
+   */
+  get name() {
+    return "AutoRotation";
+  }
+  /**
+   * Sets the flag that indicates if user zooming should stop animation.
+   */
+  set zoomStopsAnimation(t) {
+    this._zoomStopsAnimation = t;
+  }
+  /**
+   * Gets the flag that indicates if user zooming should stop animation.
+   */
+  get zoomStopsAnimation() {
+    return this._zoomStopsAnimation;
+  }
+  /**
+   * Sets the default speed at which the camera rotates around the model.
+   */
+  set idleRotationSpeed(t) {
+    this._idleRotationSpeed = t;
+  }
+  /**
+   * Gets the default speed at which the camera rotates around the model.
+   */
+  get idleRotationSpeed() {
+    return this._idleRotationSpeed;
+  }
+  /**
+   * Sets the time (in milliseconds) to wait after user interaction before the camera starts rotating.
+   */
+  set idleRotationWaitTime(t) {
+    this._idleRotationWaitTime = t;
+  }
+  /**
+   * Gets the time (milliseconds) to wait after user interaction before the camera starts rotating.
+   */
+  get idleRotationWaitTime() {
+    return this._idleRotationWaitTime;
+  }
+  /**
+   * Sets the time (milliseconds) to take to spin up to the full idle rotation speed.
+   */
+  set idleRotationSpinupTime(t) {
+    this._idleRotationSpinupTime = t;
+  }
+  /**
+   * Gets the time (milliseconds) to take to spin up to the full idle rotation speed.
+   */
+  get idleRotationSpinupTime() {
+    return this._idleRotationSpinupTime;
+  }
+  /**
+   * Gets a value indicating if the camera is currently rotating because of this behavior
+   */
+  get rotationInProgress() {
+    return Math.abs(this._cameraRotationSpeed) > 0;
+  }
+  /**
+   * Initializes the behavior.
+   */
+  init() {
+  }
+  /**
+   * Attaches the behavior to its arc rotate camera.
+   * @param camera Defines the camera to attach the behavior to
+   */
+  attach(t) {
+    this._attachedCamera = t;
+    const r = this._attachedCamera.getScene();
+    this._onPrePointerObservableObserver = r.onPrePointerObservable.add((e) => {
+      if (e.type === s.POINTERDOWN) {
+        this._isPointerDown = !0;
+        return;
+      }
+      e.type === s.POINTERUP && (this._isPointerDown = !1);
+    }), this._onAfterCheckInputsObserver = t.onAfterCheckInputsObservable.add(() => {
+      if (this._reachTargetAlpha())
+        return;
+      const e = i.Now;
+      let a = 0;
+      this._lastFrameTime != null && (a = e - this._lastFrameTime), this._lastFrameTime = e, this._applyUserInteraction();
+      const n = e - this._lastInteractionTime - this._idleRotationWaitTime, o = Math.max(Math.min(n / this._idleRotationSpinupTime, 1), 0);
+      this._cameraRotationSpeed = this._idleRotationSpeed * o, this._attachedCamera && (this._attachedCamera.alpha -= this._cameraRotationSpeed * (a / 1e3));
+    });
+  }
+  /**
+   * Detaches the behavior from its current arc rotate camera.
+   */
+  detach() {
+    if (!this._attachedCamera)
+      return;
+    const t = this._attachedCamera.getScene();
+    this._onPrePointerObservableObserver && t.onPrePointerObservable.remove(this._onPrePointerObservableObserver), this._attachedCamera.onAfterCheckInputsObservable.remove(this._onAfterCheckInputsObserver), this._attachedCamera = null;
+  }
+  /**
+   * Force-reset the last interaction time
+   * @param customTime an optional time that will be used instead of the current last interaction time. For example `Date.now()`
+   */
+  resetLastInteractionTime(t) {
+    this._lastInteractionTime = t ?? i.Now;
+  }
+  /**
+   * Returns true if camera alpha reaches the target alpha
+   * @returns true if camera alpha reaches the target alpha
+   */
+  _reachTargetAlpha() {
+    return this._attachedCamera && this.targetAlpha ? Math.abs(this._attachedCamera.alpha - this.targetAlpha) < h : !1;
+  }
+  /**
+   * Returns true if user is scrolling.
+   * @returns true if user is scrolling.
+   */
+  _userIsZooming() {
+    return this._attachedCamera ? this._attachedCamera.inertialRadiusOffset !== 0 : !1;
+  }
+  _shouldAnimationStopForInteraction() {
+    if (!this._attachedCamera)
+      return !1;
+    let t = !1;
+    return this._lastFrameRadius === this._attachedCamera.radius && this._attachedCamera.inertialRadiusOffset !== 0 && (t = !0), this._lastFrameRadius = this._attachedCamera.radius, this._zoomStopsAnimation ? t : this._userIsZooming();
+  }
+  /**
+   *  Applies any current user interaction to the camera. Takes into account maximum alpha rotation.
+   */
+  _applyUserInteraction() {
+    this._userIsMoving() && !this._shouldAnimationStopForInteraction() && (this._lastInteractionTime = i.Now);
+  }
+  // Tools
+  _userIsMoving() {
+    return this._attachedCamera ? this._attachedCamera.inertialAlphaOffset !== 0 || this._attachedCamera.inertialBetaOffset !== 0 || this._attachedCamera.inertialRadiusOffset !== 0 || this._attachedCamera.inertialPanningX !== 0 || this._attachedCamera.inertialPanningY !== 0 || this._isPointerDown : !1;
+  }
+}
+export {
+  c as AutoRotationBehavior
+};

package/dist/node_modules/@babylonjs/core/Behaviors/Cameras/bouncingBehavior.esm.js

@@ -0,0 +1,93 @@
+import { BackEase as r, EasingFunction as h } from "../../Animations/easing.esm.js";
+import { Animation as s } from "../../Animations/animation.esm.js";
+class i {
+  constructor() {
+    this.transitionDuration = 450, this.lowerRadiusTransitionRange = 2, this.upperRadiusTransitionRange = -2, this._autoTransitionRange = !1, this._radiusIsAnimating = !1, this._radiusBounceTransition = null, this._animatables = new Array();
+  }
+  /**
+   * Gets the name of the behavior.
+   */
+  get name() {
+    return "Bouncing";
+  }
+  /**
+   * Gets a value indicating if the lowerRadiusTransitionRange and upperRadiusTransitionRange are defined automatically
+   */
+  get autoTransitionRange() {
+    return this._autoTransitionRange;
+  }
+  /**
+   * Sets a value indicating if the lowerRadiusTransitionRange and upperRadiusTransitionRange are defined automatically
+   * Transition ranges will be set to 5% of the bounding box diagonal in world space
+   */
+  set autoTransitionRange(a) {
+    if (this._autoTransitionRange === a)
+      return;
+    this._autoTransitionRange = a;
+    const t = this._attachedCamera;
+    t && (a ? this._onMeshTargetChangedObserver = t.onMeshTargetChangedObservable.add((e) => {
+      if (!e)
+        return;
+      e.computeWorldMatrix(!0);
+      const n = e.getBoundingInfo().diagonalLength;
+      this.lowerRadiusTransitionRange = n * 0.05, this.upperRadiusTransitionRange = n * 0.05;
+    }) : this._onMeshTargetChangedObserver && t.onMeshTargetChangedObservable.remove(this._onMeshTargetChangedObserver));
+  }
+  /**
+   * Initializes the behavior.
+   */
+  init() {
+  }
+  /**
+   * Attaches the behavior to its arc rotate camera.
+   * @param camera Defines the camera to attach the behavior to
+   */
+  attach(a) {
+    this._attachedCamera = a, this._onAfterCheckInputsObserver = a.onAfterCheckInputsObservable.add(() => {
+      this._attachedCamera && (this._isRadiusAtLimit(this._attachedCamera.lowerRadiusLimit) && this._applyBoundRadiusAnimation(this.lowerRadiusTransitionRange), this._isRadiusAtLimit(this._attachedCamera.upperRadiusLimit) && this._applyBoundRadiusAnimation(this.upperRadiusTransitionRange));
+    });
+  }
+  /**
+   * Detaches the behavior from its current arc rotate camera.
+   */
+  detach() {
+    this._attachedCamera && (this._onAfterCheckInputsObserver && this._attachedCamera.onAfterCheckInputsObservable.remove(this._onAfterCheckInputsObserver), this._onMeshTargetChangedObserver && this._attachedCamera.onMeshTargetChangedObservable.remove(this._onMeshTargetChangedObserver), this._attachedCamera = null);
+  }
+  /**
+   * Checks if the camera radius is at the specified limit. Takes into account animation locks.
+   * @param radiusLimit The limit to check against.
+   * @returns Bool to indicate if at limit.
+   */
+  _isRadiusAtLimit(a) {
+    return this._attachedCamera ? this._attachedCamera.radius === a && !this._radiusIsAnimating : !1;
+  }
+  /**
+   * Applies an animation to the radius of the camera, extending by the radiusDelta.
+   * @param radiusDelta The delta by which to animate to. Can be negative.
+   */
+  _applyBoundRadiusAnimation(a) {
+    if (!this._attachedCamera)
+      return;
+    this._radiusBounceTransition || (i.EasingFunction.setEasingMode(i.EasingMode), this._radiusBounceTransition = s.CreateAnimation("radius", s.ANIMATIONTYPE_FLOAT, 60, i.EasingFunction)), this._cachedWheelPrecision = this._attachedCamera.wheelPrecision, this._attachedCamera.wheelPrecision = 1 / 0, this._attachedCamera.inertialRadiusOffset = 0, this.stopAllAnimations(), this._radiusIsAnimating = !0;
+    const t = s.TransitionTo("radius", this._attachedCamera.radius + a, this._attachedCamera, this._attachedCamera.getScene(), 60, this._radiusBounceTransition, this.transitionDuration, () => this._clearAnimationLocks());
+    t && this._animatables.push(t);
+  }
+  /**
+   * Removes all animation locks. Allows new animations to be added to any of the camera properties.
+   */
+  _clearAnimationLocks() {
+    this._radiusIsAnimating = !1, this._attachedCamera && (this._attachedCamera.wheelPrecision = this._cachedWheelPrecision);
+  }
+  /**
+   * Stops and removes all animations that have been applied to the camera
+   */
+  stopAllAnimations() {
+    for (this._attachedCamera && (this._attachedCamera.animations = []); this._animatables.length; )
+      this._animatables[0].onAnimationEnd = null, this._animatables[0].stop(), this._animatables.shift();
+  }
+}
+i.EasingFunction = new r(0.3);
+i.EasingMode = h.EASINGMODE_EASEOUT;
+export {
+  i as BouncingBehavior
+};

package/dist/node_modules/@babylonjs/core/Behaviors/Cameras/framingBehavior.esm.js

@@ -0,0 +1,295 @@
+import { ExponentialEase as A, EasingFunction as p } from "../../Animations/easing.esm.js";
+import { Observable as C } from "../../Misc/observable.esm.js";
+import { PointerEventTypes as g } from "../../Events/pointerEvents.esm.js";
+import { PrecisionDate as f } from "../../Misc/precisionDate.esm.js";
+import { Vector3 as l, Vector2 as b } from "../../Maths/math.vector.esm.js";
+import { Animation as h } from "../../Animations/animation.esm.js";
+class s {
+  constructor() {
+    this.onTargetFramingAnimationEndObservable = new C(), this._mode = s.FitFrustumSidesMode, this._radiusScale = 1, this._positionScale = 0.5, this._defaultElevation = 0.3, this._elevationReturnTime = 1500, this._elevationReturnWaitTime = 1e3, this._zoomStopsAnimation = !1, this._framingTime = 1500, this.autoCorrectCameraLimitsAndSensibility = !0, this._isPointerDown = !1, this._lastInteractionTime = -1 / 0, this._animatables = new Array(), this._betaIsAnimating = !1;
+  }
+  /**
+   * Gets the name of the behavior.
+   */
+  get name() {
+    return "Framing";
+  }
+  /**
+   * Sets the current mode used by the behavior
+   */
+  set mode(t) {
+    this._mode = t;
+  }
+  /**
+   * Gets current mode used by the behavior.
+   */
+  get mode() {
+    return this._mode;
+  }
+  /**
+   * Sets the scale applied to the radius (1 by default)
+   */
+  set radiusScale(t) {
+    this._radiusScale = t;
+  }
+  /**
+   * Gets the scale applied to the radius
+   */
+  get radiusScale() {
+    return this._radiusScale;
+  }
+  /**
+   * Sets the scale to apply on Y axis to position camera focus. 0.5 by default which means the center of the bounding box.
+   */
+  set positionScale(t) {
+    this._positionScale = t;
+  }
+  /**
+   * Gets the scale to apply on Y axis to position camera focus. 0.5 by default which means the center of the bounding box.
+   */
+  get positionScale() {
+    return this._positionScale;
+  }
+  /**
+   * Sets the angle above/below the horizontal plane to return to when the return to default elevation idle
+   * behaviour is triggered, in radians.
+   */
+  set defaultElevation(t) {
+    this._defaultElevation = t;
+  }
+  /**
+   * Gets the angle above/below the horizontal plane to return to when the return to default elevation idle
+   * behaviour is triggered, in radians.
+   */
+  get defaultElevation() {
+    return this._defaultElevation;
+  }
+  /**
+   * Sets the time (in milliseconds) taken to return to the default beta position.
+   * Negative value indicates camera should not return to default.
+   */
+  set elevationReturnTime(t) {
+    this._elevationReturnTime = t;
+  }
+  /**
+   * Gets the time (in milliseconds) taken to return to the default beta position.
+   * Negative value indicates camera should not return to default.
+   */
+  get elevationReturnTime() {
+    return this._elevationReturnTime;
+  }
+  /**
+   * Sets the delay (in milliseconds) taken before the camera returns to the default beta position.
+   */
+  set elevationReturnWaitTime(t) {
+    this._elevationReturnWaitTime = t;
+  }
+  /**
+   * Gets the delay (in milliseconds) taken before the camera returns to the default beta position.
+   */
+  get elevationReturnWaitTime() {
+    return this._elevationReturnWaitTime;
+  }
+  /**
+   * Sets the flag that indicates if user zooming should stop animation.
+   */
+  set zoomStopsAnimation(t) {
+    this._zoomStopsAnimation = t;
+  }
+  /**
+   * Gets the flag that indicates if user zooming should stop animation.
+   */
+  get zoomStopsAnimation() {
+    return this._zoomStopsAnimation;
+  }
+  /**
+   * Sets the transition time when framing the mesh, in milliseconds
+   */
+  set framingTime(t) {
+    this._framingTime = t;
+  }
+  /**
+   * Gets the transition time when framing the mesh, in milliseconds
+   */
+  get framingTime() {
+    return this._framingTime;
+  }
+  /**
+   * Initializes the behavior.
+   */
+  init() {
+  }
+  /**
+   * Attaches the behavior to its arc rotate camera.
+   * @param camera Defines the camera to attach the behavior to
+   */
+  attach(t) {
+    this._attachedCamera = t;
+    const i = this._attachedCamera.getScene();
+    s.EasingFunction.setEasingMode(s.EasingMode), this._onPrePointerObservableObserver = i.onPrePointerObservable.add((a) => {
+      if (a.type === g.POINTERDOWN) {
+        this._isPointerDown = !0;
+        return;
+      }
+      a.type === g.POINTERUP && (this._isPointerDown = !1);
+    }), this._onMeshTargetChangedObserver = t.onMeshTargetChangedObservable.add((a) => {
+      a && this.zoomOnMesh(a, void 0, () => {
+        this.onTargetFramingAnimationEndObservable.notifyObservers();
+      });
+    }), this._onAfterCheckInputsObserver = t.onAfterCheckInputsObservable.add(() => {
+      this._applyUserInteraction(), this._maintainCameraAboveGround();
+    });
+  }
+  /**
+   * Detaches the behavior from its current arc rotate camera.
+   */
+  detach() {
+    if (!this._attachedCamera)
+      return;
+    const t = this._attachedCamera.getScene();
+    this._onPrePointerObservableObserver && t.onPrePointerObservable.remove(this._onPrePointerObservableObserver), this._onAfterCheckInputsObserver && this._attachedCamera.onAfterCheckInputsObservable.remove(this._onAfterCheckInputsObserver), this._onMeshTargetChangedObserver && this._attachedCamera.onMeshTargetChangedObservable.remove(this._onMeshTargetChangedObserver), this._attachedCamera = null;
+  }
+  /**
+   * Targets the given mesh and updates zoom level accordingly.
+   * @param mesh  The mesh to target.
+   * @param focusOnOriginXZ Determines if the camera should focus on 0 in the X and Z axis instead of the mesh
+   * @param onAnimationEnd Callback triggered at the end of the framing animation
+   */
+  zoomOnMesh(t, i = !1, a = null) {
+    t.computeWorldMatrix(!0);
+    const e = t.getBoundingInfo().boundingBox;
+    this.zoomOnBoundingInfo(e.minimumWorld, e.maximumWorld, i, a);
+  }
+  /**
+   * Targets the given mesh with its children and updates zoom level accordingly.
+   * @param mesh  The mesh to target.
+   * @param focusOnOriginXZ Determines if the camera should focus on 0 in the X and Z axis instead of the mesh
+   * @param onAnimationEnd Callback triggered at the end of the framing animation
+   */
+  zoomOnMeshHierarchy(t, i = !1, a = null) {
+    t.computeWorldMatrix(!0);
+    const e = t.getHierarchyBoundingVectors(!0);
+    this.zoomOnBoundingInfo(e.min, e.max, i, a);
+  }
+  /**
+   * Targets the given meshes with their children and updates zoom level accordingly.
+   * @param meshes  The mesh to target.
+   * @param focusOnOriginXZ Determines if the camera should focus on 0 in the X and Z axis instead of the mesh
+   * @param onAnimationEnd Callback triggered at the end of the framing animation
+   */
+  zoomOnMeshesHierarchy(t, i = !1, a = null) {
+    const e = new l(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE), n = new l(-Number.MAX_VALUE, -Number.MAX_VALUE, -Number.MAX_VALUE);
+    for (let m = 0; m < t.length; m++) {
+      const u = t[m].getHierarchyBoundingVectors(!0);
+      l.CheckExtends(u.min, e, n), l.CheckExtends(u.max, e, n);
+    }
+    this.zoomOnBoundingInfo(e, n, i, a);
+  }
+  /**
+   * Targets the bounding box info defined by its extends and updates zoom level accordingly.
+   * @param minimumWorld Determines the smaller position of the bounding box extend
+   * @param maximumWorld Determines the bigger position of the bounding box extend
+   * @param focusOnOriginXZ Determines if the camera should focus on 0 in the X and Z axis instead of the mesh
+   * @param onAnimationEnd Callback triggered at the end of the framing animation
+   */
+  zoomOnBoundingInfo(t, i, a = !1, e = null) {
+    let n;
+    if (!this._attachedCamera)
+      return;
+    const m = t.y, u = i.y, d = m + (u - m) * this._positionScale, _ = i.subtract(t).scale(0.5);
+    if (a)
+      n = new l(0, d, 0);
+    else {
+      const c = t.add(_);
+      n = new l(c.x, d, c.z);
+    }
+    this._vectorTransition || (this._vectorTransition = h.CreateAnimation("target", h.ANIMATIONTYPE_VECTOR3, 60, s.EasingFunction)), this._betaIsAnimating = !0;
+    let o = h.TransitionTo("target", n, this._attachedCamera, this._attachedCamera.getScene(), 60, this._vectorTransition, this._framingTime);
+    o && this._animatables.push(o);
+    let r = 0;
+    if (this._mode === s.FitFrustumSidesMode) {
+      const c = this._calculateLowerRadiusFromModelBoundingSphere(t, i);
+      this.autoCorrectCameraLimitsAndSensibility && (this._attachedCamera.lowerRadiusLimit = _.length() + this._attachedCamera.minZ), r = c;
+    } else
+      this._mode === s.IgnoreBoundsSizeMode && (r = this._calculateLowerRadiusFromModelBoundingSphere(t, i), this.autoCorrectCameraLimitsAndSensibility && this._attachedCamera.lowerRadiusLimit === null && (this._attachedCamera.lowerRadiusLimit = this._attachedCamera.minZ));
+    if (this.autoCorrectCameraLimitsAndSensibility) {
+      const c = i.subtract(t).length();
+      this._attachedCamera.panningSensibility = 5e3 / c, this._attachedCamera.wheelPrecision = 100 / r;
+    }
+    this._radiusTransition || (this._radiusTransition = h.CreateAnimation("radius", h.ANIMATIONTYPE_FLOAT, 60, s.EasingFunction)), o = h.TransitionTo("radius", r, this._attachedCamera, this._attachedCamera.getScene(), 60, this._radiusTransition, this._framingTime, () => {
+      this.stopAllAnimations(), e && e(), this._attachedCamera && this._attachedCamera.useInputToRestoreState && this._attachedCamera.storeState();
+    }), o && this._animatables.push(o);
+  }
+  /**
+   * Calculates the lowest radius for the camera based on the bounding box of the mesh.
+   * @param minimumWorld
+   * @param maximumWorld
+   * @returns The minimum distance from the primary mesh's center point at which the camera must be kept in order
+   *		 to fully enclose the mesh in the viewing frustum.
+   */
+  _calculateLowerRadiusFromModelBoundingSphere(t, i) {
+    const e = i.subtract(t).length(), n = this._getFrustumSlope(), u = e * 0.5 * this._radiusScale, d = u * Math.sqrt(1 + 1 / (n.x * n.x)), _ = u * Math.sqrt(1 + 1 / (n.y * n.y));
+    let o = Math.max(d, _);
+    const r = this._attachedCamera;
+    return r ? (r.lowerRadiusLimit && this._mode === s.IgnoreBoundsSizeMode && (o = o < r.lowerRadiusLimit ? r.lowerRadiusLimit : o), r.upperRadiusLimit && (o = o > r.upperRadiusLimit ? r.upperRadiusLimit : o), o) : 0;
+  }
+  /**
+   * Keeps the camera above the ground plane. If the user pulls the camera below the ground plane, the camera
+   * is automatically returned to its default position (expected to be above ground plane).
+   */
+  _maintainCameraAboveGround() {
+    if (this._elevationReturnTime < 0)
+      return;
+    const t = f.Now - this._lastInteractionTime, i = Math.PI * 0.5 - this._defaultElevation, a = Math.PI * 0.5;
+    if (this._attachedCamera && !this._betaIsAnimating && this._attachedCamera.beta > a && t >= this._elevationReturnWaitTime) {
+      this._betaIsAnimating = !0, this.stopAllAnimations(), this._betaTransition || (this._betaTransition = h.CreateAnimation("beta", h.ANIMATIONTYPE_FLOAT, 60, s.EasingFunction));
+      const e = h.TransitionTo("beta", i, this._attachedCamera, this._attachedCamera.getScene(), 60, this._betaTransition, this._elevationReturnTime, () => {
+        this._clearAnimationLocks(), this.stopAllAnimations();
+      });
+      e && this._animatables.push(e);
+    }
+  }
+  /**
+   * Returns the frustum slope based on the canvas ratio and camera FOV
+   * @returns The frustum slope represented as a Vector2 with X and Y slopes
+   */
+  _getFrustumSlope() {
+    const t = this._attachedCamera;
+    if (!t)
+      return b.Zero();
+    const a = t.getScene().getEngine().getAspectRatio(t), e = Math.tan(t.fov / 2), n = e * a;
+    return new b(n, e);
+  }
+  /**
+   * Removes all animation locks. Allows new animations to be added to any of the arcCamera properties.
+   */
+  _clearAnimationLocks() {
+    this._betaIsAnimating = !1;
+  }
+  /**
+   *  Applies any current user interaction to the camera. Takes into account maximum alpha rotation.
+   */
+  _applyUserInteraction() {
+    this.isUserIsMoving && (this._lastInteractionTime = f.Now, this.stopAllAnimations(), this._clearAnimationLocks());
+  }
+  /**
+   * Stops and removes all animations that have been applied to the camera
+   */
+  stopAllAnimations() {
+    for (this._attachedCamera && (this._attachedCamera.animations = []); this._animatables.length; )
+      this._animatables[0] && (this._animatables[0].onAnimationEnd = null, this._animatables[0].stop()), this._animatables.shift();
+  }
+  /**
+   * Gets a value indicating if the user is moving the camera
+   */
+  get isUserIsMoving() {
+    return this._attachedCamera ? this._attachedCamera.inertialAlphaOffset !== 0 || this._attachedCamera.inertialBetaOffset !== 0 || this._attachedCamera.inertialRadiusOffset !== 0 || this._attachedCamera.inertialPanningX !== 0 || this._attachedCamera.inertialPanningY !== 0 || this._isPointerDown : !1;
+  }
+}
+s.EasingFunction = new A();
+s.EasingMode = p.EASINGMODE_EASEINOUT;
+s.IgnoreBoundsSizeMode = 0;
+s.FitFrustumSidesMode = 1;
+export {
+  s as FramingBehavior
+};