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

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

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

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

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

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