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

package/dist/node_modules/@babylonjs/core/Animations/animation.esm.js

@@ -1,866 +0,0 @@
-import { Quaternion as g, Vector3 as y, Vector2 as C, TmpVectors as E, Matrix as P } from "../Maths/math.vector.esm.js";
-import { Color3 as v, Color4 as M } from "../Maths/math.color.esm.js";
-import { Scalar as Y } from "../Maths/math.scalar.esm.js";
-import { SerializationHelper as F } from "../Misc/decorators.esm.js";
-import { RegisterClass as b } from "../Misc/typeStore.esm.js";
-import { AnimationKeyInterpolation as D } from "./animationKey.esm.js";
-import { AnimationRange as R } from "./animationRange.esm.js";
-import { Node as w } from "../node.esm.js";
-import { Size as S } from "../Maths/math.size.esm.js";
-import { WebRequest as m } from "../Misc/webRequest.esm.js";
-class a {
-  /**
-   * @internal Internal use
-   */
-  static _PrepareAnimation(t, e, s, i, r, n, o, c) {
-    let u;
-    if (!isNaN(parseFloat(r)) && isFinite(r) ? u = a.ANIMATIONTYPE_FLOAT : r instanceof g ? u = a.ANIMATIONTYPE_QUATERNION : r instanceof y ? u = a.ANIMATIONTYPE_VECTOR3 : r instanceof C ? u = a.ANIMATIONTYPE_VECTOR2 : r instanceof v ? u = a.ANIMATIONTYPE_COLOR3 : r instanceof M ? u = a.ANIMATIONTYPE_COLOR4 : r instanceof S && (u = a.ANIMATIONTYPE_SIZE), u == null)
-      return null;
-    const f = new a(t, e, s, u, o), l = [
-      { frame: 0, value: r },
-      { frame: i, value: n }
-    ];
-    return f.setKeys(l), c !== void 0 && f.setEasingFunction(c), f;
-  }
-  /**
-   * Sets up an animation
-   * @param property The property to animate
-   * @param animationType The animation type to apply
-   * @param framePerSecond The frames per second of the animation
-   * @param easingFunction The easing function used in the animation
-   * @returns The created animation
-   */
-  static CreateAnimation(t, e, s, i) {
-    const r = new a(t + "Animation", t, s, e, a.ANIMATIONLOOPMODE_CONSTANT);
-    return r.setEasingFunction(i), r;
-  }
-  /**
-   * Create and start an animation on a node
-   * @param name defines the name of the global animation that will be run on all nodes
-   * @param target defines the target where the animation will take place
-   * @param targetProperty defines property to animate
-   * @param framePerSecond defines the number of frame per second yo use
-   * @param totalFrame defines the number of frames in total
-   * @param from defines the initial value
-   * @param to defines the final value
-   * @param loopMode defines which loop mode you want to use (off by default)
-   * @param easingFunction defines the easing function to use (linear by default)
-   * @param onAnimationEnd defines the callback to call when animation end
-   * @param scene defines the hosting scene
-   * @returns the animatable created for this animation
-   */
-  static CreateAndStartAnimation(t, e, s, i, r, n, o, c, u, f, l) {
-    const O = a._PrepareAnimation(t, s, i, r, n, o, c, u);
-    return !O || (e.getScene && (l = e.getScene()), !l) ? null : l.beginDirectAnimation(e, [O], 0, r, O.loopMode === 1, 1, f);
-  }
-  /**
-   * Create and start an animation on a node and its descendants
-   * @param name defines the name of the global animation that will be run on all nodes
-   * @param node defines the root node where the animation will take place
-   * @param directDescendantsOnly if true only direct descendants will be used, if false direct and also indirect (children of children, an so on in a recursive manner) descendants will be used
-   * @param targetProperty defines property to animate
-   * @param framePerSecond defines the number of frame per second to use
-   * @param totalFrame defines the number of frames in total
-   * @param from defines the initial value
-   * @param to defines the final value
-   * @param loopMode defines which loop mode you want to use (off by default)
-   * @param easingFunction defines the easing function to use (linear by default)
-   * @param onAnimationEnd defines the callback to call when an animation ends (will be called once per node)
-   * @returns the list of animatables created for all nodes
-   * @example https://www.babylonjs-playground.com/#MH0VLI
-   */
-  static CreateAndStartHierarchyAnimation(t, e, s, i, r, n, o, c, u, f, l) {
-    const O = a._PrepareAnimation(t, i, r, n, o, c, u, f);
-    return O ? e.getScene().beginDirectHierarchyAnimation(e, s, [O], 0, n, O.loopMode === 1, 1, l) : null;
-  }
-  /**
-   * Creates a new animation, merges it with the existing animations and starts it
-   * @param name Name of the animation
-   * @param node Node which contains the scene that begins the animations
-   * @param targetProperty Specifies which property to animate
-   * @param framePerSecond The frames per second of the animation
-   * @param totalFrame The total number of frames
-   * @param from The frame at the beginning of the animation
-   * @param to The frame at the end of the animation
-   * @param loopMode Specifies the loop mode of the animation
-   * @param easingFunction (Optional) The easing function of the animation, which allow custom mathematical formulas for animations
-   * @param onAnimationEnd Callback to run once the animation is complete
-   * @returns Nullable animation
-   */
-  static CreateMergeAndStartAnimation(t, e, s, i, r, n, o, c, u, f) {
-    const l = a._PrepareAnimation(t, s, i, r, n, o, c, u);
-    return l ? (e.animations.push(l), e.getScene().beginAnimation(e, 0, r, l.loopMode === 1, 1, f)) : null;
-  }
-  /**
-   * Convert the keyframes for all animations belonging to the group to be relative to a given reference frame.
-   * @param sourceAnimation defines the Animation containing keyframes to convert
-   * @param referenceFrame defines the frame that keyframes in the range will be relative to
-   * @param range defines the name of the AnimationRange belonging to the Animation to convert
-   * @param cloneOriginal defines whether or not to clone the animation and convert the clone or convert the original animation (default is false)
-   * @param clonedName defines the name of the resulting cloned Animation if cloneOriginal is true
-   * @returns a new Animation if cloneOriginal is true or the original Animation if cloneOriginal is false
-   */
-  static MakeAnimationAdditive(t, e = 0, s, i = !1, r) {
-    let n = t;
-    if (i && (n = t.clone(), n.name = r || n.name), !n._keys.length)
-      return n;
-    e = e >= 0 ? e : 0;
-    let o = 0;
-    const c = n._keys[0];
-    let u = n._keys.length - 1;
-    const f = n._keys[u], l = {
-      referenceValue: c.value,
-      referencePosition: E.Vector3[0],
-      referenceQuaternion: E.Quaternion[0],
-      referenceScaling: E.Vector3[1],
-      keyPosition: E.Vector3[2],
-      keyQuaternion: E.Quaternion[1],
-      keyScaling: E.Vector3[3]
-    };
-    let O = !1, p = c.frame, I = f.frame;
-    if (s) {
-      const T = n.getRange(s);
-      T && (p = T.from, I = T.to);
-    }
-    let L = c.frame === p, k = f.frame === I;
-    if (n._keys.length === 1) {
-      const T = n._getKeyValue(n._keys[0]);
-      l.referenceValue = T.clone ? T.clone() : T, O = !0;
-    } else if (e <= c.frame) {
-      const T = n._getKeyValue(c.value);
-      l.referenceValue = T.clone ? T.clone() : T, O = !0;
-    } else if (e >= f.frame) {
-      const T = n._getKeyValue(f.value);
-      l.referenceValue = T.clone ? T.clone() : T, O = !0;
-    }
-    let N = 0;
-    for (; !O || !L || !k && N < n._keys.length - 1; ) {
-      const T = n._keys[N], d = n._keys[N + 1];
-      if (!O && e >= T.frame && e <= d.frame) {
-        let h;
-        if (e === T.frame)
-          h = n._getKeyValue(T.value);
-        else if (e === d.frame)
-          h = n._getKeyValue(d.value);
-        else {
-          const A = {
-            key: N,
-            repeatCount: 0,
-            loopMode: this.ANIMATIONLOOPMODE_CONSTANT
-          };
-          h = n._interpolate(e, A);
-        }
-        l.referenceValue = h.clone ? h.clone() : h, O = !0;
-      }
-      if (!L && p >= T.frame && p <= d.frame) {
-        if (p === T.frame)
-          o = N;
-        else if (p === d.frame)
-          o = N + 1;
-        else {
-          const h = {
-            key: N,
-            repeatCount: 0,
-            loopMode: this.ANIMATIONLOOPMODE_CONSTANT
-          }, A = n._interpolate(p, h), _ = {
-            frame: p,
-            value: A.clone ? A.clone() : A
-          };
-          n._keys.splice(N + 1, 0, _), o = N + 1;
-        }
-        L = !0;
-      }
-      if (!k && I >= T.frame && I <= d.frame) {
-        if (I === T.frame)
-          u = N;
-        else if (I === d.frame)
-          u = N + 1;
-        else {
-          const h = {
-            key: N,
-            repeatCount: 0,
-            loopMode: this.ANIMATIONLOOPMODE_CONSTANT
-          }, A = n._interpolate(I, h), _ = {
-            frame: I,
-            value: A.clone ? A.clone() : A
-          };
-          n._keys.splice(N + 1, 0, _), u = N + 1;
-        }
-        k = !0;
-      }
-      N++;
-    }
-    for (n.dataType === a.ANIMATIONTYPE_QUATERNION ? l.referenceValue.normalize().conjugateInPlace() : n.dataType === a.ANIMATIONTYPE_MATRIX && (l.referenceValue.decompose(l.referenceScaling, l.referenceQuaternion, l.referencePosition), l.referenceQuaternion.normalize().conjugateInPlace()), N = o; N <= u; N++) {
-      const T = n._keys[N];
-      if (!(N && n.dataType !== a.ANIMATIONTYPE_FLOAT && T.value === c.value))
-        switch (n.dataType) {
-          case a.ANIMATIONTYPE_MATRIX:
-            T.value.decompose(l.keyScaling, l.keyQuaternion, l.keyPosition), l.keyPosition.subtractInPlace(l.referencePosition), l.keyScaling.divideInPlace(l.referenceScaling), l.referenceQuaternion.multiplyToRef(l.keyQuaternion, l.keyQuaternion), P.ComposeToRef(l.keyScaling, l.keyQuaternion, l.keyPosition, T.value);
-            break;
-          case a.ANIMATIONTYPE_QUATERNION:
-            l.referenceValue.multiplyToRef(T.value, T.value);
-            break;
-          case a.ANIMATIONTYPE_VECTOR2:
-          case a.ANIMATIONTYPE_VECTOR3:
-          case a.ANIMATIONTYPE_COLOR3:
-          case a.ANIMATIONTYPE_COLOR4:
-            T.value.subtractToRef(l.referenceValue, T.value);
-            break;
-          case a.ANIMATIONTYPE_SIZE:
-            T.value.width -= l.referenceValue.width, T.value.height -= l.referenceValue.height;
-            break;
-          default:
-            T.value -= l.referenceValue;
-        }
-    }
-    return n;
-  }
-  /**
-   * Transition property of an host to the target Value
-   * @param property The property to transition
-   * @param targetValue The target Value of the property
-   * @param host The object where the property to animate belongs
-   * @param scene Scene used to run the animation
-   * @param frameRate Framerate (in frame/s) to use
-   * @param transition The transition type we want to use
-   * @param duration The duration of the animation, in milliseconds
-   * @param onAnimationEnd Callback trigger at the end of the animation
-   * @returns Nullable animation
-   */
-  static TransitionTo(t, e, s, i, r, n, o, c = null) {
-    if (o <= 0)
-      return s[t] = e, c && c(), null;
-    const u = r * (o / 1e3);
-    n.setKeys([
-      {
-        frame: 0,
-        value: s[t].clone ? s[t].clone() : s[t]
-      },
-      {
-        frame: u,
-        value: e
-      }
-    ]), s.animations || (s.animations = []), s.animations.push(n);
-    const f = i.beginAnimation(s, 0, u, !1);
-    return f.onAnimationEnd = c, f;
-  }
-  /**
-   * Return the array of runtime animations currently using this animation
-   */
-  get runtimeAnimations() {
-    return this._runtimeAnimations;
-  }
-  /**
-   * Specifies if any of the runtime animations are currently running
-   */
-  get hasRunningRuntimeAnimations() {
-    for (const t of this._runtimeAnimations)
-      if (!t.isStopped())
-        return !0;
-    return !1;
-  }
-  /**
-   * Initializes the animation
-   * @param name Name of the animation
-   * @param targetProperty Property to animate
-   * @param framePerSecond The frames per second of the animation
-   * @param dataType The data type of the animation
-   * @param loopMode The loop mode of the animation
-   * @param enableBlending Specifies if blending should be enabled
-   */
-  constructor(t, e, s, i, r, n) {
-    this.name = t, this.targetProperty = e, this.framePerSecond = s, this.dataType = i, this.loopMode = r, this.enableBlending = n, this._easingFunction = null, this._runtimeAnimations = new Array(), this._events = new Array(), this.blendingSpeed = 0.01, this._ranges = {}, this.targetPropertyPath = e.split("."), this.dataType = i, this.loopMode = r === void 0 ? a.ANIMATIONLOOPMODE_CYCLE : r, this.uniqueId = a._UniqueIdGenerator++;
-  }
-  // Methods
-  /**
-   * Converts the animation to a string
-   * @param fullDetails support for multiple levels of logging within scene loading
-   * @returns String form of the animation
-   */
-  toString(t) {
-    let e = "Name: " + this.name + ", property: " + this.targetProperty;
-    if (e += ", datatype: " + ["Float", "Vector3", "Quaternion", "Matrix", "Color3", "Vector2"][this.dataType], e += ", nKeys: " + (this._keys ? this._keys.length : "none"), e += ", nRanges: " + (this._ranges ? Object.keys(this._ranges).length : "none"), t) {
-      e += ", Ranges: {";
-      let s = !0;
-      for (const i in this._ranges)
-        s && (e += ", ", s = !1), e += i;
-      e += "}";
-    }
-    return e;
-  }
-  /**
-   * Add an event to this animation
-   * @param event Event to add
-   */
-  addEvent(t) {
-    this._events.push(t), this._events.sort((e, s) => e.frame - s.frame);
-  }
-  /**
-   * Remove all events found at the given frame
-   * @param frame The frame to remove events from
-   */
-  removeEvents(t) {
-    for (let e = 0; e < this._events.length; e++)
-      this._events[e].frame === t && (this._events.splice(e, 1), e--);
-  }
-  /**
-   * Retrieves all the events from the animation
-   * @returns Events from the animation
-   */
-  getEvents() {
-    return this._events;
-  }
-  /**
-   * Creates an animation range
-   * @param name Name of the animation range
-   * @param from Starting frame of the animation range
-   * @param to Ending frame of the animation
-   */
-  createRange(t, e, s) {
-    this._ranges[t] || (this._ranges[t] = new R(t, e, s));
-  }
-  /**
-   * Deletes an animation range by name
-   * @param name Name of the animation range to delete
-   * @param deleteFrames Specifies if the key frames for the range should also be deleted (true) or not (false)
-   */
-  deleteRange(t, e = !0) {
-    const s = this._ranges[t];
-    if (s) {
-      if (e) {
-        const i = s.from, r = s.to;
-        for (let n = this._keys.length - 1; n >= 0; n--)
-          this._keys[n].frame >= i && this._keys[n].frame <= r && this._keys.splice(n, 1);
-      }
-      this._ranges[t] = null;
-    }
-  }
-  /**
-   * Gets the animation range by name, or null if not defined
-   * @param name Name of the animation range
-   * @returns Nullable animation range
-   */
-  getRange(t) {
-    return this._ranges[t];
-  }
-  /**
-   * Gets the key frames from the animation
-   * @returns The key frames of the animation
-   */
-  getKeys() {
-    return this._keys;
-  }
-  /**
-   * Gets the highest frame rate of the animation
-   * @returns Highest frame rate of the animation
-   */
-  getHighestFrame() {
-    let t = 0;
-    for (let e = 0, s = this._keys.length; e < s; e++)
-      t < this._keys[e].frame && (t = this._keys[e].frame);
-    return t;
-  }
-  /**
-   * Gets the easing function of the animation
-   * @returns Easing function of the animation
-   */
-  getEasingFunction() {
-    return this._easingFunction;
-  }
-  /**
-   * Sets the easing function of the animation
-   * @param easingFunction A custom mathematical formula for animation
-   */
-  setEasingFunction(t) {
-    this._easingFunction = t;
-  }
-  /**
-   * Interpolates a scalar linearly
-   * @param startValue Start value of the animation curve
-   * @param endValue End value of the animation curve
-   * @param gradient Scalar amount to interpolate
-   * @returns Interpolated scalar value
-   */
-  floatInterpolateFunction(t, e, s) {
-    return Y.Lerp(t, e, s);
-  }
-  /**
-   * Interpolates a scalar cubically
-   * @param startValue Start value of the animation curve
-   * @param outTangent End tangent of the animation
-   * @param endValue End value of the animation curve
-   * @param inTangent Start tangent of the animation curve
-   * @param gradient Scalar amount to interpolate
-   * @returns Interpolated scalar value
-   */
-  floatInterpolateFunctionWithTangents(t, e, s, i, r) {
-    return Y.Hermite(t, e, s, i, r);
-  }
-  /**
-   * Interpolates a quaternion using a spherical linear interpolation
-   * @param startValue Start value of the animation curve
-   * @param endValue End value of the animation curve
-   * @param gradient Scalar amount to interpolate
-   * @returns Interpolated quaternion value
-   */
-  quaternionInterpolateFunction(t, e, s) {
-    return g.Slerp(t, e, s);
-  }
-  /**
-   * Interpolates a quaternion cubically
-   * @param startValue Start value of the animation curve
-   * @param outTangent End tangent of the animation curve
-   * @param endValue End value of the animation curve
-   * @param inTangent Start tangent of the animation curve
-   * @param gradient Scalar amount to interpolate
-   * @returns Interpolated quaternion value
-   */
-  quaternionInterpolateFunctionWithTangents(t, e, s, i, r) {
-    return g.Hermite(t, e, s, i, r).normalize();
-  }
-  /**
-   * Interpolates a Vector3 linearly
-   * @param startValue Start value of the animation curve
-   * @param endValue End value of the animation curve
-   * @param gradient Scalar amount to interpolate (value between 0 and 1)
-   * @returns Interpolated scalar value
-   */
-  vector3InterpolateFunction(t, e, s) {
-    return y.Lerp(t, e, s);
-  }
-  /**
-   * Interpolates a Vector3 cubically
-   * @param startValue Start value of the animation curve
-   * @param outTangent End tangent of the animation
-   * @param endValue End value of the animation curve
-   * @param inTangent Start tangent of the animation curve
-   * @param gradient Scalar amount to interpolate (value between 0 and 1)
-   * @returns InterpolatedVector3 value
-   */
-  vector3InterpolateFunctionWithTangents(t, e, s, i, r) {
-    return y.Hermite(t, e, s, i, r);
-  }
-  /**
-   * Interpolates a Vector2 linearly
-   * @param startValue Start value of the animation curve
-   * @param endValue End value of the animation curve
-   * @param gradient Scalar amount to interpolate (value between 0 and 1)
-   * @returns Interpolated Vector2 value
-   */
-  vector2InterpolateFunction(t, e, s) {
-    return C.Lerp(t, e, s);
-  }
-  /**
-   * Interpolates a Vector2 cubically
-   * @param startValue Start value of the animation curve
-   * @param outTangent End tangent of the animation
-   * @param endValue End value of the animation curve
-   * @param inTangent Start tangent of the animation curve
-   * @param gradient Scalar amount to interpolate (value between 0 and 1)
-   * @returns Interpolated Vector2 value
-   */
-  vector2InterpolateFunctionWithTangents(t, e, s, i, r) {
-    return C.Hermite(t, e, s, i, r);
-  }
-  /**
-   * Interpolates a size linearly
-   * @param startValue Start value of the animation curve
-   * @param endValue End value of the animation curve
-   * @param gradient Scalar amount to interpolate
-   * @returns Interpolated Size value
-   */
-  sizeInterpolateFunction(t, e, s) {
-    return S.Lerp(t, e, s);
-  }
-  /**
-   * Interpolates a Color3 linearly
-   * @param startValue Start value of the animation curve
-   * @param endValue End value of the animation curve
-   * @param gradient Scalar amount to interpolate
-   * @returns Interpolated Color3 value
-   */
-  color3InterpolateFunction(t, e, s) {
-    return v.Lerp(t, e, s);
-  }
-  /**
-   * Interpolates a Color3 cubically
-   * @param startValue Start value of the animation curve
-   * @param outTangent End tangent of the animation
-   * @param endValue End value of the animation curve
-   * @param inTangent Start tangent of the animation curve
-   * @param gradient Scalar amount to interpolate
-   * @returns interpolated value
-   */
-  color3InterpolateFunctionWithTangents(t, e, s, i, r) {
-    return v.Hermite(t, e, s, i, r);
-  }
-  /**
-   * Interpolates a Color4 linearly
-   * @param startValue Start value of the animation curve
-   * @param endValue End value of the animation curve
-   * @param gradient Scalar amount to interpolate
-   * @returns Interpolated Color3 value
-   */
-  color4InterpolateFunction(t, e, s) {
-    return M.Lerp(t, e, s);
-  }
-  /**
-   * Interpolates a Color4 cubically
-   * @param startValue Start value of the animation curve
-   * @param outTangent End tangent of the animation
-   * @param endValue End value of the animation curve
-   * @param inTangent Start tangent of the animation curve
-   * @param gradient Scalar amount to interpolate
-   * @returns interpolated value
-   */
-  color4InterpolateFunctionWithTangents(t, e, s, i, r) {
-    return M.Hermite(t, e, s, i, r);
-  }
-  /**
-   * @internal Internal use only
-   */
-  _getKeyValue(t) {
-    return typeof t == "function" ? t() : t;
-  }
-  /**
-   * Evaluate the animation value at a given frame
-   * @param currentFrame defines the frame where we want to evaluate the animation
-   * @returns the animation value
-   */
-  evaluate(t) {
-    return this._interpolate(t, {
-      key: 0,
-      repeatCount: 0,
-      loopMode: a.ANIMATIONLOOPMODE_CONSTANT
-    });
-  }
-  /**
-   * @internal Internal use only
-   */
-  _interpolate(t, e) {
-    if (e.loopMode === a.ANIMATIONLOOPMODE_CONSTANT && e.repeatCount > 0)
-      return e.highLimitValue.clone ? e.highLimitValue.clone() : e.highLimitValue;
-    const s = this._keys, i = s.length;
-    let r = e.key;
-    for (; r >= 0 && t < s[r].frame; )
-      --r;
-    for (; r + 1 <= i - 1 && t >= s[r + 1].frame; )
-      ++r;
-    if (e.key = r, r < 0)
-      return this._getKeyValue(s[0].value);
-    if (r + 1 > i - 1)
-      return this._getKeyValue(s[i - 1].value);
-    const n = s[r], o = s[r + 1], c = this._getKeyValue(n.value), u = this._getKeyValue(o.value);
-    if (n.interpolation === D.STEP)
-      return o.frame > t ? c : u;
-    const f = n.outTangent !== void 0 && o.inTangent !== void 0, l = o.frame - n.frame;
-    let O = (t - n.frame) / l;
-    const p = this.getEasingFunction();
-    switch (p !== null && (O = p.ease(O)), this.dataType) {
-      case a.ANIMATIONTYPE_FLOAT: {
-        const I = f ? this.floatInterpolateFunctionWithTangents(c, n.outTangent * l, u, o.inTangent * l, O) : this.floatInterpolateFunction(c, u, O);
-        switch (e.loopMode) {
-          case a.ANIMATIONLOOPMODE_CYCLE:
-          case a.ANIMATIONLOOPMODE_CONSTANT:
-          case a.ANIMATIONLOOPMODE_YOYO:
-            return I;
-          case a.ANIMATIONLOOPMODE_RELATIVE:
-            return e.offsetValue * e.repeatCount + I;
-        }
-        break;
-      }
-      case a.ANIMATIONTYPE_QUATERNION: {
-        const I = f ? this.quaternionInterpolateFunctionWithTangents(c, n.outTangent.scale(l), u, o.inTangent.scale(l), O) : this.quaternionInterpolateFunction(c, u, O);
-        switch (e.loopMode) {
-          case a.ANIMATIONLOOPMODE_CYCLE:
-          case a.ANIMATIONLOOPMODE_CONSTANT:
-          case a.ANIMATIONLOOPMODE_YOYO:
-            return I;
-          case a.ANIMATIONLOOPMODE_RELATIVE:
-            return I.addInPlace(e.offsetValue.scale(e.repeatCount));
-        }
-        return I;
-      }
-      case a.ANIMATIONTYPE_VECTOR3: {
-        const I = f ? this.vector3InterpolateFunctionWithTangents(c, n.outTangent.scale(l), u, o.inTangent.scale(l), O) : this.vector3InterpolateFunction(c, u, O);
-        switch (e.loopMode) {
-          case a.ANIMATIONLOOPMODE_CYCLE:
-          case a.ANIMATIONLOOPMODE_CONSTANT:
-          case a.ANIMATIONLOOPMODE_YOYO:
-            return I;
-          case a.ANIMATIONLOOPMODE_RELATIVE:
-            return I.add(e.offsetValue.scale(e.repeatCount));
-        }
-        break;
-      }
-      case a.ANIMATIONTYPE_VECTOR2: {
-        const I = f ? this.vector2InterpolateFunctionWithTangents(c, n.outTangent.scale(l), u, o.inTangent.scale(l), O) : this.vector2InterpolateFunction(c, u, O);
-        switch (e.loopMode) {
-          case a.ANIMATIONLOOPMODE_CYCLE:
-          case a.ANIMATIONLOOPMODE_CONSTANT:
-          case a.ANIMATIONLOOPMODE_YOYO:
-            return I;
-          case a.ANIMATIONLOOPMODE_RELATIVE:
-            return I.add(e.offsetValue.scale(e.repeatCount));
-        }
-        break;
-      }
-      case a.ANIMATIONTYPE_SIZE: {
-        switch (e.loopMode) {
-          case a.ANIMATIONLOOPMODE_CYCLE:
-          case a.ANIMATIONLOOPMODE_CONSTANT:
-          case a.ANIMATIONLOOPMODE_YOYO:
-            return this.sizeInterpolateFunction(c, u, O);
-          case a.ANIMATIONLOOPMODE_RELATIVE:
-            return this.sizeInterpolateFunction(c, u, O).add(e.offsetValue.scale(e.repeatCount));
-        }
-        break;
-      }
-      case a.ANIMATIONTYPE_COLOR3: {
-        const I = f ? this.color3InterpolateFunctionWithTangents(c, n.outTangent.scale(l), u, o.inTangent.scale(l), O) : this.color3InterpolateFunction(c, u, O);
-        switch (e.loopMode) {
-          case a.ANIMATIONLOOPMODE_CYCLE:
-          case a.ANIMATIONLOOPMODE_CONSTANT:
-          case a.ANIMATIONLOOPMODE_YOYO:
-            return I;
-          case a.ANIMATIONLOOPMODE_RELATIVE:
-            return I.add(e.offsetValue.scale(e.repeatCount));
-        }
-        break;
-      }
-      case a.ANIMATIONTYPE_COLOR4: {
-        const I = f ? this.color4InterpolateFunctionWithTangents(c, n.outTangent.scale(l), u, o.inTangent.scale(l), O) : this.color4InterpolateFunction(c, u, O);
-        switch (e.loopMode) {
-          case a.ANIMATIONLOOPMODE_CYCLE:
-          case a.ANIMATIONLOOPMODE_CONSTANT:
-          case a.ANIMATIONLOOPMODE_YOYO:
-            return I;
-          case a.ANIMATIONLOOPMODE_RELATIVE:
-            return I.add(e.offsetValue.scale(e.repeatCount));
-        }
-        break;
-      }
-      case a.ANIMATIONTYPE_MATRIX: {
-        switch (e.loopMode) {
-          case a.ANIMATIONLOOPMODE_CYCLE:
-          case a.ANIMATIONLOOPMODE_CONSTANT:
-          case a.ANIMATIONLOOPMODE_YOYO:
-            return a.AllowMatricesInterpolation ? this.matrixInterpolateFunction(c, u, O, e.workValue) : c;
-          case a.ANIMATIONLOOPMODE_RELATIVE:
-            return c;
-        }
-        break;
-      }
-    }
-    return 0;
-  }
-  /**
-   * Defines the function to use to interpolate matrices
-   * @param startValue defines the start matrix
-   * @param endValue defines the end matrix
-   * @param gradient defines the gradient between both matrices
-   * @param result defines an optional target matrix where to store the interpolation
-   * @returns the interpolated matrix
-   */
-  matrixInterpolateFunction(t, e, s, i) {
-    return a.AllowMatrixDecomposeForInterpolation ? i ? (P.DecomposeLerpToRef(t, e, s, i), i) : P.DecomposeLerp(t, e, s) : i ? (P.LerpToRef(t, e, s, i), i) : P.Lerp(t, e, s);
-  }
-  /**
-   * Makes a copy of the animation
-   * @returns Cloned animation
-   */
-  clone() {
-    const t = new a(this.name, this.targetPropertyPath.join("."), this.framePerSecond, this.dataType, this.loopMode);
-    if (t.enableBlending = this.enableBlending, t.blendingSpeed = this.blendingSpeed, this._keys && t.setKeys(this._keys), this._ranges) {
-      t._ranges = {};
-      for (const e in this._ranges) {
-        const s = this._ranges[e];
-        s && (t._ranges[e] = s.clone());
-      }
-    }
-    return t;
-  }
-  /**
-   * Sets the key frames of the animation
-   * @param values The animation key frames to set
-   */
-  setKeys(t) {
-    this._keys = t.slice(0);
-  }
-  /**
-   * Serializes the animation to an object
-   * @returns Serialized object
-   */
-  serialize() {
-    const t = {};
-    t.name = this.name, t.property = this.targetProperty, t.framePerSecond = this.framePerSecond, t.dataType = this.dataType, t.loopBehavior = this.loopMode, t.enableBlending = this.enableBlending, t.blendingSpeed = this.blendingSpeed;
-    const e = this.dataType;
-    t.keys = [];
-    const s = this.getKeys();
-    for (let i = 0; i < s.length; i++) {
-      const r = s[i], n = {};
-      switch (n.frame = r.frame, e) {
-        case a.ANIMATIONTYPE_FLOAT:
-          n.values = [r.value], r.inTangent !== void 0 && n.values.push(r.inTangent), r.outTangent !== void 0 && (r.inTangent === void 0 && n.values.push(void 0), n.values.push(r.outTangent)), r.interpolation !== void 0 && (r.inTangent === void 0 && n.values.push(void 0), r.outTangent === void 0 && n.values.push(void 0), n.values.push(r.interpolation));
-          break;
-        case a.ANIMATIONTYPE_QUATERNION:
-        case a.ANIMATIONTYPE_MATRIX:
-        case a.ANIMATIONTYPE_VECTOR3:
-        case a.ANIMATIONTYPE_COLOR3:
-        case a.ANIMATIONTYPE_COLOR4:
-          n.values = r.value.asArray(), r.inTangent != null && n.values.push(r.inTangent.asArray()), r.outTangent != null && (r.inTangent === void 0 && n.values.push(void 0), n.values.push(r.outTangent.asArray())), r.interpolation !== void 0 && (r.inTangent === void 0 && n.values.push(void 0), r.outTangent === void 0 && n.values.push(void 0), n.values.push(r.interpolation));
-          break;
-      }
-      t.keys.push(n);
-    }
-    t.ranges = [];
-    for (const i in this._ranges) {
-      const r = this._ranges[i];
-      if (!r)
-        continue;
-      const n = {};
-      n.name = i, n.from = r.from, n.to = r.to, t.ranges.push(n);
-    }
-    return t;
-  }
-  /**
-   * @internal
-   */
-  static _UniversalLerp(t, e, s) {
-    const i = t.constructor;
-    return i.Lerp ? i.Lerp(t, e, s) : i.Slerp ? i.Slerp(t, e, s) : t.toFixed ? t * (1 - s) + s * e : e;
-  }
-  /**
-   * Parses an animation object and creates an animation
-   * @param parsedAnimation Parsed animation object
-   * @returns Animation object
-   */
-  static Parse(t) {
-    const e = new a(t.name, t.property, t.framePerSecond, t.dataType, t.loopBehavior), s = t.dataType, i = [];
-    let r, n;
-    for (t.enableBlending && (e.enableBlending = t.enableBlending), t.blendingSpeed && (e.blendingSpeed = t.blendingSpeed), n = 0; n < t.keys.length; n++) {
-      const o = t.keys[n];
-      let c, u, f;
-      switch (s) {
-        case a.ANIMATIONTYPE_FLOAT:
-          r = o.values[0], o.values.length >= 2 && (c = o.values[1]), o.values.length >= 3 && (u = o.values[2]), o.values.length >= 4 && (f = o.values[3]);
-          break;
-        case a.ANIMATIONTYPE_QUATERNION:
-          if (r = g.FromArray(o.values), o.values.length >= 8) {
-            const O = g.FromArray(o.values.slice(4, 8));
-            O.equals(g.Zero()) || (c = O);
-          }
-          if (o.values.length >= 12) {
-            const O = g.FromArray(o.values.slice(8, 12));
-            O.equals(g.Zero()) || (u = O);
-          }
-          o.values.length >= 13 && (f = o.values[12]);
-          break;
-        case a.ANIMATIONTYPE_MATRIX:
-          r = P.FromArray(o.values), o.values.length >= 17 && (f = o.values[16]);
-          break;
-        case a.ANIMATIONTYPE_COLOR3:
-          r = v.FromArray(o.values), o.values[3] && (c = v.FromArray(o.values[3])), o.values[4] && (u = v.FromArray(o.values[4])), o.values[5] && (f = o.values[5]);
-          break;
-        case a.ANIMATIONTYPE_COLOR4:
-          r = M.FromArray(o.values), o.values[4] && (c = M.FromArray(o.values[4])), o.values[5] && (u = M.FromArray(o.values[5])), o.values[6] && (f = M.FromArray(o.values[6]));
-          break;
-        case a.ANIMATIONTYPE_VECTOR3:
-        default:
-          r = y.FromArray(o.values), o.values[3] && (c = y.FromArray(o.values[3])), o.values[4] && (u = y.FromArray(o.values[4])), o.values[5] && (f = o.values[5]);
-          break;
-      }
-      const l = {};
-      l.frame = o.frame, l.value = r, c != null && (l.inTangent = c), u != null && (l.outTangent = u), f != null && (l.interpolation = f), i.push(l);
-    }
-    if (e.setKeys(i), t.ranges)
-      for (n = 0; n < t.ranges.length; n++)
-        r = t.ranges[n], e.createRange(r.name, r.from, r.to);
-    return e;
-  }
-  /**
-   * Appends the serialized animations from the source animations
-   * @param source Source containing the animations
-   * @param destination Target to store the animations
-   */
-  static AppendSerializedAnimations(t, e) {
-    F.AppendSerializedAnimations(t, e);
-  }
-  /**
-   * Creates a new animation or an array of animations from a snippet saved in a remote file
-   * @param name defines the name of the animation to create (can be null or empty to use the one from the json data)
-   * @param url defines the url to load from
-   * @returns a promise that will resolve to the new animation or an array of animations
-   */
-  static ParseFromFileAsync(t, e) {
-    return new Promise((s, i) => {
-      const r = new m();
-      r.addEventListener("readystatechange", () => {
-        if (r.readyState == 4)
-          if (r.status == 200) {
-            let n = JSON.parse(r.responseText);
-            if (n.animations && (n = n.animations), n.length) {
-              const o = new Array();
-              for (const c of n)
-                o.push(this.Parse(c));
-              s(o);
-            } else {
-              const o = this.Parse(n);
-              t && (o.name = t), s(o);
-            }
-          } else
-            i("Unable to load the animation");
-      }), r.open("GET", e), r.send();
-    });
-  }
-  /**
-   * Creates an animation or an array of animations from a snippet saved by the Inspector
-   * @param snippetId defines the snippet to load
-   * @returns a promise that will resolve to the new animation or a new array of animations
-   */
-  static ParseFromSnippetAsync(t) {
-    return new Promise((e, s) => {
-      const i = new m();
-      i.addEventListener("readystatechange", () => {
-        if (i.readyState == 4)
-          if (i.status == 200) {
-            const r = JSON.parse(JSON.parse(i.responseText).jsonPayload);
-            if (r.animations) {
-              const n = JSON.parse(r.animations), o = new Array();
-              for (const c of n.animations) {
-                const u = this.Parse(c);
-                u.snippetId = t, o.push(u);
-              }
-              e(o);
-            } else {
-              const n = JSON.parse(r.animation), o = this.Parse(n);
-              o.snippetId = t, e(o);
-            }
-          } else
-            s("Unable to load the snippet " + t);
-      }), i.open("GET", this.SnippetUrl + "/" + t.replace(/#/g, "/")), i.send();
-    });
-  }
-}
-a._UniqueIdGenerator = 0;
-a.AllowMatricesInterpolation = !1;
-a.AllowMatrixDecomposeForInterpolation = !0;
-a.SnippetUrl = "https://snippet.babylonjs.com";
-a.ANIMATIONTYPE_FLOAT = 0;
-a.ANIMATIONTYPE_VECTOR3 = 1;
-a.ANIMATIONTYPE_QUATERNION = 2;
-a.ANIMATIONTYPE_MATRIX = 3;
-a.ANIMATIONTYPE_COLOR3 = 4;
-a.ANIMATIONTYPE_COLOR4 = 7;
-a.ANIMATIONTYPE_VECTOR2 = 5;
-a.ANIMATIONTYPE_SIZE = 6;
-a.ANIMATIONLOOPMODE_RELATIVE = 0;
-a.ANIMATIONLOOPMODE_CYCLE = 1;
-a.ANIMATIONLOOPMODE_CONSTANT = 2;
-a.ANIMATIONLOOPMODE_YOYO = 4;
-a.CreateFromSnippetAsync = a.ParseFromSnippetAsync;
-b("BABYLON.Animation", a);
-w._AnimationRangeFactory = (V, t, e) => new R(V, t, e);
-export {
-  a as Animation
-};