@vived/component-abb-6700 1.0.0

package/dist/animationGroup-BhNThqQe.js

@@ -0,0 +1,1454 @@
+import { i as A, ad as F, bt as x, bs as E, bv as R, bw as M, bx as N, bu as B, am as C, ai as P, b8 as T, aJ as S, bf as k, w as D, aY as W, K, b3 as w, bb as U } from "./index-CS3Icp_r.js";
+class Y {
+  /**
+   * Gets the current frame of the runtime animation
+   */
+  get currentFrame() {
+    return this._currentFrame;
+  }
+  /**
+   * Gets the weight of the runtime animation
+   */
+  get weight() {
+    return this._weight;
+  }
+  /**
+   * Gets the current value of the runtime animation
+   */
+  get currentValue() {
+    return this._currentValue;
+  }
+  /**
+   * Gets or sets the target path of the runtime animation
+   */
+  get targetPath() {
+    return this._targetPath;
+  }
+  /**
+   * Gets the actual target of the runtime animation
+   */
+  get target() {
+    return this._currentActiveTarget;
+  }
+  /**
+   * Gets the additive state of the runtime animation
+   */
+  get isAdditive() {
+    return this._host && this._host.isAdditive;
+  }
+  /**
+   * Create a new RuntimeAnimation object
+   * @param target defines the target of the animation
+   * @param animation defines the source animation object
+   * @param scene defines the hosting scene
+   * @param host defines the initiating Animatable
+   */
+  constructor(t, e, i, n) {
+    if (this._events = new Array(), this._currentFrame = 0, this._originalValue = new Array(), this._originalBlendValue = null, this._offsetsCache = {}, this._highLimitsCache = {}, this._stopped = !1, this._blendingFactor = 0, this._currentValue = null, this._currentActiveTarget = null, this._directTarget = null, this._targetPath = "", this._weight = 1, this._absoluteFrameOffset = 0, this._previousElapsedTime = 0, this._yoyoDirection = 1, this._previousAbsoluteFrame = 0, this._targetIsArray = !1, this._coreRuntimeAnimation = null, this._animation = e, this._target = t, this._scene = i, this._host = n, this._activeTargets = [], e._runtimeAnimations.push(this), this._animationState = {
+      key: 0,
+      repeatCount: 0,
+      loopMode: this._getCorrectLoopMode()
+    }, this._animation.dataType === A.ANIMATIONTYPE_MATRIX && (this._animationState.workValue = F.Zero()), this._keys = this._animation.getKeys(), this._minFrame = this._keys[0].frame, this._maxFrame = this._keys[this._keys.length - 1].frame, this._minFrame !== 0) {
+      const a = { frame: 0, value: this._keys[0].value };
+      this._keys.splice(0, 0, a);
+    }
+    if (this._target instanceof Array) {
+      let a = 0;
+      for (const r of this._target)
+        this._preparePath(r, a), this._getOriginalValues(a), a++;
+      this._targetIsArray = !0;
+    } else
+      this._preparePath(this._target), this._getOriginalValues(), this._targetIsArray = !1, this._directTarget = this._activeTargets[0];
+    const s = e.getEvents();
+    if (s && s.length > 0)
+      for (const a of s)
+        this._events.push(a._clone());
+    this._enableBlending = t && t.animationPropertiesOverride ? t.animationPropertiesOverride.enableBlending : this._animation.enableBlending;
+  }
+  _preparePath(t, e = 0) {
+    const i = this._animation.targetPropertyPath;
+    if (i.length > 1) {
+      let n = t;
+      for (let s = 0; s < i.length - 1; s++) {
+        const a = i[s];
+        if (n = n[a], n === void 0)
+          throw new Error(`Invalid property (${a}) in property path (${i.join(".")})`);
+      }
+      this._targetPath = i[i.length - 1], this._activeTargets[e] = n;
+    } else
+      this._targetPath = i[0], this._activeTargets[e] = t;
+    if (this._activeTargets[e][this._targetPath] === void 0)
+      throw new Error(`Invalid property (${this._targetPath}) in property path (${i.join(".")})`);
+  }
+  /**
+   * Gets the animation from the runtime animation
+   */
+  get animation() {
+    return this._animation;
+  }
+  /**
+   * Resets the runtime animation to the beginning
+   * @param restoreOriginal defines whether to restore the target property to the original value
+   */
+  reset(t = !1) {
+    if (t)
+      if (this._target instanceof Array) {
+        let e = 0;
+        for (const i of this._target)
+          this._originalValue[e] !== void 0 && this._setValue(i, this._activeTargets[e], this._originalValue[e], -1, e), e++;
+      } else
+        this._originalValue[0] !== void 0 && this._setValue(this._target, this._directTarget, this._originalValue[0], -1, 0);
+    this._offsetsCache = {}, this._highLimitsCache = {}, this._currentFrame = 0, this._blendingFactor = 0;
+    for (let e = 0; e < this._events.length; e++)
+      this._events[e].isDone = !1;
+  }
+  /**
+   * Specifies if the runtime animation is stopped
+   * @returns Boolean specifying if the runtime animation is stopped
+   */
+  isStopped() {
+    return this._stopped;
+  }
+  /**
+   * Disposes of the runtime animation
+   */
+  dispose() {
+    const t = this._animation.runtimeAnimations.indexOf(this);
+    t > -1 && this._animation.runtimeAnimations.splice(t, 1);
+  }
+  /**
+   * Apply the interpolated value to the target
+   * @param currentValue defines the value computed by the animation
+   * @param weight defines the weight to apply to this value (Defaults to 1.0)
+   */
+  setValue(t, e) {
+    if (this._targetIsArray) {
+      for (let i = 0; i < this._target.length; i++) {
+        const n = this._target[i];
+        this._setValue(n, this._activeTargets[i], t, e, i);
+      }
+      return;
+    }
+    this._setValue(this._target, this._directTarget, t, e, 0);
+  }
+  _getOriginalValues(t = 0) {
+    let e;
+    const i = this._activeTargets[t];
+    if (A.InheritOriginalValueFromActiveAnimations) {
+      const n = this._scene._activeAnimatables;
+      for (let s = 0; s < n.length; s++) {
+        const a = n[s]._runtimeAnimations;
+        for (let r = 0; r < a.length; r++) {
+          const o = a[r];
+          if (o !== this && o._targetPath === this._targetPath) {
+            for (let l = 0; l < o._activeTargets.length; l++)
+              if (o._activeTargets[l] === i && o._originalValue[l] !== void 0) {
+                o._originalValue[l] && o._originalValue[l].clone ? this._originalValue[t] = o._originalValue[l].clone() : this._originalValue[t] = o._originalValue[l];
+                return;
+              }
+          }
+        }
+      }
+    }
+    i.getLocalMatrix && this._targetPath === "_matrix" ? e = i.getLocalMatrix() : e = i[this._targetPath], e && e.clone ? this._originalValue[t] = e.clone() : this._originalValue[t] = e;
+  }
+  _registerTargetForLateAnimationBinding(t, e) {
+    const i = t.target;
+    this._scene._registeredForLateAnimationBindings.pushNoDuplicate(i), i._lateAnimationHolders || (i._lateAnimationHolders = {}), i._lateAnimationHolders[t.targetPath] || (i._lateAnimationHolders[t.targetPath] = {
+      totalWeight: 0,
+      totalAdditiveWeight: 0,
+      animations: [],
+      additiveAnimations: [],
+      originalValue: e
+    }), t.isAdditive ? (i._lateAnimationHolders[t.targetPath].additiveAnimations.push(t), i._lateAnimationHolders[t.targetPath].totalAdditiveWeight += t.weight) : (i._lateAnimationHolders[t.targetPath].animations.push(t), i._lateAnimationHolders[t.targetPath].totalWeight += t.weight);
+  }
+  _setValue(t, e, i, n, s) {
+    if (this._currentActiveTarget = e, this._weight = n, this._enableBlending && this._blendingFactor <= 1) {
+      if (!this._originalBlendValue) {
+        const r = e[this._targetPath];
+        r.clone ? this._originalBlendValue = r.clone() : this._originalBlendValue = r;
+      }
+      this._originalBlendValue.m ? A.AllowMatrixDecomposeForInterpolation ? this._currentValue ? F.DecomposeLerpToRef(this._originalBlendValue, i, this._blendingFactor, this._currentValue) : this._currentValue = F.DecomposeLerp(this._originalBlendValue, i, this._blendingFactor) : this._currentValue ? F.LerpToRef(this._originalBlendValue, i, this._blendingFactor, this._currentValue) : this._currentValue = F.Lerp(this._originalBlendValue, i, this._blendingFactor) : this._currentValue = A._UniversalLerp(this._originalBlendValue, i, this._blendingFactor);
+      const a = t && t.animationPropertiesOverride ? t.animationPropertiesOverride.blendingSpeed : this._animation.blendingSpeed;
+      this._blendingFactor += a;
+    } else
+      this._currentValue ? this._currentValue.copyFrom ? this._currentValue.copyFrom(i) : this._currentValue = i : i?.clone ? this._currentValue = i.clone() : this._currentValue = i;
+    n !== -1 ? this._registerTargetForLateAnimationBinding(this, this._originalValue[s]) : this._animationState.loopMode === A.ANIMATIONLOOPMODE_RELATIVE_FROM_CURRENT ? this._currentValue.addToRef ? this._currentValue.addToRef(this._originalValue[s], e[this._targetPath]) : e[this._targetPath] = this._originalValue[s] + this._currentValue : e[this._targetPath] = this._currentValue, t.markAsDirty && t.markAsDirty(this._animation.targetProperty);
+  }
+  /**
+   * Gets the loop pmode of the runtime animation
+   * @returns Loop Mode
+   */
+  _getCorrectLoopMode() {
+    return this._target && this._target.animationPropertiesOverride ? this._target.animationPropertiesOverride.loopMode : this._animation.loopMode;
+  }
+  /**
+   * Move the current animation to a given frame
+   * @param frame defines the frame to move to
+   * @param weight defines the weight to apply to the animation (-1.0 by default)
+   */
+  goToFrame(t, e = -1) {
+    const i = this._animation.getKeys();
+    t < i[0].frame ? t = i[0].frame : t > i[i.length - 1].frame && (t = i[i.length - 1].frame);
+    const n = this._events;
+    if (n.length)
+      for (let a = 0; a < n.length; a++)
+        n[a].onlyOnce || (n[a].isDone = n[a].frame < t);
+    this._currentFrame = t;
+    const s = this._animation._interpolate(t, this._animationState);
+    this.setValue(s, e);
+  }
+  /**
+   * @internal Internal use only
+   */
+  _prepareForSpeedRatioChange(t) {
+    const e = this._previousElapsedTime * (this._animation.framePerSecond * t) / 1e3;
+    this._absoluteFrameOffset = this._previousAbsoluteFrame - e;
+  }
+  /**
+   * Execute the current animation
+   * @param elapsedTimeSinceAnimationStart defines the elapsed time (in milliseconds) since the animation was started
+   * @param from defines the lower frame of the animation range
+   * @param to defines the upper frame of the animation range
+   * @param loop defines if the current animation must loop
+   * @param speedRatio defines the current speed ratio
+   * @param weight defines the weight of the animation (default is -1 so no weight)
+   * @returns a boolean indicating if the animation is running
+   */
+  animate(t, e, i, n, s, a = -1) {
+    const r = this._animation, o = r.targetPropertyPath;
+    if (!o || o.length < 1)
+      return this._stopped = !0, !1;
+    let l = !0, u;
+    const c = this._events;
+    let g;
+    if (this._coreRuntimeAnimation)
+      g = i - e, u = this._coreRuntimeAnimation.currentFrame, this._currentFrame = u, this._animationState.repeatCount = this._coreRuntimeAnimation._animationState.repeatCount, this._animationState.highLimitValue = this._coreRuntimeAnimation._animationState.highLimitValue, this._animationState.offsetValue = this._coreRuntimeAnimation._animationState.offsetValue;
+    else {
+      (e < this._minFrame || e > this._maxFrame) && (e = this._minFrame), (i < this._minFrame || i > this._maxFrame) && (i = this._maxFrame), g = i - e;
+      let _, m = t * (r.framePerSecond * s) / 1e3 + this._absoluteFrameOffset, b = 0, O = !1;
+      const v = n && this._animationState.loopMode === A.ANIMATIONLOOPMODE_YOYO;
+      if (v) {
+        const f = (m - e) / g, p = Math.sin(f * Math.PI);
+        m = Math.abs(p) * g + e;
+        const L = p >= 0 ? 1 : -1;
+        this._yoyoDirection !== L && (O = !0), this._yoyoDirection = L;
+      }
+      if (this._previousElapsedTime = t, this._previousAbsoluteFrame = m, !n && i >= e && (m >= g && s > 0 || m <= 0 && s < 0))
+        l = !1, b = r.evaluate(i);
+      else if (!n && e >= i && (m <= g && s < 0 || m >= 0 && s > 0))
+        l = !1, b = r.evaluate(e);
+      else if (this._animationState.loopMode !== A.ANIMATIONLOOPMODE_CYCLE) {
+        const f = i.toString() + e.toString();
+        if (!this._offsetsCache[f]) {
+          this._animationState.repeatCount = 0, this._animationState.loopMode = A.ANIMATIONLOOPMODE_CYCLE;
+          const p = r._interpolate(e, this._animationState), y = r._interpolate(i, this._animationState);
+          switch (this._animationState.loopMode = this._getCorrectLoopMode(), r.dataType) {
+            // Float
+            case A.ANIMATIONTYPE_FLOAT:
+              this._offsetsCache[f] = y - p;
+              break;
+            // Quaternion
+            case A.ANIMATIONTYPE_QUATERNION:
+              this._offsetsCache[f] = y.subtract(p);
+              break;
+            // Vector3
+            case A.ANIMATIONTYPE_VECTOR3:
+              this._offsetsCache[f] = y.subtract(p);
+              break;
+            // Vector2
+            case A.ANIMATIONTYPE_VECTOR2:
+              this._offsetsCache[f] = y.subtract(p);
+              break;
+            // Size
+            case A.ANIMATIONTYPE_SIZE:
+              this._offsetsCache[f] = y.subtract(p);
+              break;
+            // Color3
+            case A.ANIMATIONTYPE_COLOR3:
+              this._offsetsCache[f] = y.subtract(p);
+              break;
+          }
+          this._highLimitsCache[f] = y;
+        }
+        b = this._highLimitsCache[f], _ = this._offsetsCache[f];
+      }
+      if (_ === void 0)
+        switch (r.dataType) {
+          // Float
+          case A.ANIMATIONTYPE_FLOAT:
+            _ = 0;
+            break;
+          // Quaternion
+          case A.ANIMATIONTYPE_QUATERNION:
+            _ = B;
+            break;
+          // Vector3
+          case A.ANIMATIONTYPE_VECTOR3:
+            _ = N;
+            break;
+          // Vector2
+          case A.ANIMATIONTYPE_VECTOR2:
+            _ = M;
+            break;
+          // Size
+          case A.ANIMATIONTYPE_SIZE:
+            _ = R;
+            break;
+          // Color3
+          case A.ANIMATIONTYPE_COLOR3:
+            _ = E;
+            break;
+          case A.ANIMATIONTYPE_COLOR4:
+            _ = x;
+            break;
+        }
+      if (this._host && this._host.syncRoot) {
+        const f = this._host.syncRoot, p = (f.masterFrame - f.fromFrame) / (f.toFrame - f.fromFrame);
+        u = e + g * p;
+      } else
+        m > 0 && e > i || m < 0 && e < i ? u = l && g !== 0 ? i + m % g : e : u = l && g !== 0 ? e + m % g : i;
+      if (!v && (s > 0 && this.currentFrame > u || s < 0 && this.currentFrame < u) || v && O) {
+        this._onLoop();
+        for (let f = 0; f < c.length; f++)
+          c[f].onlyOnce || (c[f].isDone = !1);
+        this._animationState.key = s > 0 ? 0 : r.getKeys().length - 1;
+      }
+      this._currentFrame = u, this._animationState.repeatCount = g === 0 ? 0 : m / g >> 0, this._animationState.highLimitValue = b, this._animationState.offsetValue = _;
+    }
+    const d = r._interpolate(u, this._animationState);
+    if (this.setValue(d, a), c.length) {
+      for (let _ = 0; _ < c.length; _++)
+        if (g >= 0 && u >= c[_].frame && c[_].frame >= e || g < 0 && u <= c[_].frame && c[_].frame <= e) {
+          const m = c[_];
+          m.isDone || (m.onlyOnce && (c.splice(_, 1), _--), m.isDone = !0, m.action(u));
+        }
+    }
+    return l || (this._stopped = !0), l;
+  }
+}
+class I {
+  /**
+   * Gets the root Animatable used to synchronize and normalize animations
+   */
+  get syncRoot() {
+    return this._syncRoot;
+  }
+  /**
+   * Gets the current frame of the first RuntimeAnimation
+   * Used to synchronize Animatables
+   */
+  get masterFrame() {
+    return this._runtimeAnimations.length === 0 ? 0 : this._runtimeAnimations[0].currentFrame;
+  }
+  /**
+   * Gets or sets the animatable weight (-1.0 by default meaning not weighted)
+   */
+  get weight() {
+    return this._weight;
+  }
+  set weight(t) {
+    if (t === -1) {
+      this._weight = -1;
+      return;
+    }
+    this._weight = Math.min(Math.max(t, 0), 1);
+  }
+  /**
+   * Gets or sets the speed ratio to apply to the animatable (1.0 by default)
+   */
+  get speedRatio() {
+    return this._speedRatio;
+  }
+  set speedRatio(t) {
+    for (let e = 0; e < this._runtimeAnimations.length; e++)
+      this._runtimeAnimations[e]._prepareForSpeedRatioChange(t);
+    this._speedRatio = t, this._goToFrame !== null && this.goToFrame(this._goToFrame);
+  }
+  /**
+   * Gets the elapsed time since the animatable started in milliseconds
+   */
+  get elapsedTime() {
+    return this._localDelayOffset === null ? 0 : this._scene._animationTime - this._localDelayOffset;
+  }
+  /**
+   * Creates a new Animatable
+   * @param scene defines the hosting scene
+   * @param target defines the target object
+   * @param fromFrame defines the starting frame number (default is 0)
+   * @param toFrame defines the ending frame number (default is 100)
+   * @param loopAnimation defines if the animation must loop (default is false)
+   * @param speedRatio defines the factor to apply to animation speed (default is 1)
+   * @param onAnimationEnd defines a callback to call when animation ends if it is not looping
+   * @param animations defines a group of animation to add to the new Animatable
+   * @param onAnimationLoop defines a callback to call when animation loops
+   * @param isAdditive defines whether the animation should be evaluated additively
+   * @param playOrder defines the order in which this animatable should be processed in the list of active animatables (default: 0)
+   */
+  constructor(t, e, i = 0, n = 100, s = !1, a = 1, r, o, l, u = !1, c = 0) {
+    this.target = e, this.fromFrame = i, this.toFrame = n, this.loopAnimation = s, this.onAnimationEnd = r, this.onAnimationLoop = l, this.isAdditive = u, this.playOrder = c, this._localDelayOffset = null, this._pausedDelay = null, this._manualJumpDelay = null, this._runtimeAnimations = new Array(), this._paused = !1, this._speedRatio = 1, this._weight = -1, this._previousWeight = -1, this._syncRoot = null, this._frameToSyncFromJump = null, this._goToFrame = null, this.disposeOnEnd = !0, this.animationStarted = !1, this.onAnimationEndObservable = new P(), this.onAnimationLoopObservable = new P(), this._scene = t, o && this.appendAnimations(e, o), this._speedRatio = a, t._activeAnimatables.push(this);
+  }
+  // Methods
+  /**
+   * Synchronize and normalize current Animatable with a source Animatable
+   * This is useful when using animation weights and when animations are not of the same length
+   * @param root defines the root Animatable to synchronize with (null to stop synchronizing)
+   * @returns the current Animatable
+   */
+  syncWith(t) {
+    if (this._syncRoot = t, t) {
+      const e = this._scene._activeAnimatables.indexOf(this);
+      e > -1 && (this._scene._activeAnimatables.splice(e, 1), this._scene._activeAnimatables.push(this));
+    }
+    return this;
+  }
+  /**
+   * Gets the list of runtime animations
+   * @returns an array of RuntimeAnimation
+   */
+  getAnimations() {
+    return this._runtimeAnimations;
+  }
+  /**
+   * Adds more animations to the current animatable
+   * @param target defines the target of the animations
+   * @param animations defines the new animations to add
+   */
+  appendAnimations(t, e) {
+    for (let i = 0; i < e.length; i++) {
+      const n = e[i], s = new Y(t, n, this._scene, this);
+      s._onLoop = () => {
+        this.onAnimationLoopObservable.notifyObservers(this), this.onAnimationLoop && this.onAnimationLoop();
+      }, this._runtimeAnimations.push(s);
+    }
+  }
+  /**
+   * Gets the source animation for a specific property
+   * @param property defines the property to look for
+   * @returns null or the source animation for the given property
+   */
+  getAnimationByTargetProperty(t) {
+    const e = this._runtimeAnimations;
+    for (let i = 0; i < e.length; i++)
+      if (e[i].animation.targetProperty === t)
+        return e[i].animation;
+    return null;
+  }
+  /**
+   * Gets the runtime animation for a specific property
+   * @param property defines the property to look for
+   * @returns null or the runtime animation for the given property
+   */
+  getRuntimeAnimationByTargetProperty(t) {
+    const e = this._runtimeAnimations;
+    for (let i = 0; i < e.length; i++)
+      if (e[i].animation.targetProperty === t)
+        return e[i];
+    return null;
+  }
+  /**
+   * Resets the animatable to its original state
+   */
+  reset() {
+    const t = this._runtimeAnimations;
+    for (let e = 0; e < t.length; e++)
+      t[e].reset(!0);
+    this._localDelayOffset = null, this._pausedDelay = null;
+  }
+  /**
+   * Allows the animatable to blend with current running animations
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#animation-blending
+   * @param blendingSpeed defines the blending speed to use
+   */
+  enableBlending(t) {
+    const e = this._runtimeAnimations;
+    for (let i = 0; i < e.length; i++)
+      e[i].animation.enableBlending = !0, e[i].animation.blendingSpeed = t;
+  }
+  /**
+   * Disable animation blending
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#animation-blending
+   */
+  disableBlending() {
+    const t = this._runtimeAnimations;
+    for (let e = 0; e < t.length; e++)
+      t[e].animation.enableBlending = !1;
+  }
+  /**
+   * Jump directly to a given frame
+   * @param frame defines the frame to jump to
+   * @param useWeight defines whether the animation weight should be applied to the image to be jumped to (false by default)
+   */
+  goToFrame(t, e = !1) {
+    const i = this._runtimeAnimations;
+    if (i[0]) {
+      const n = i[0].animation.framePerSecond;
+      this._frameToSyncFromJump = this._frameToSyncFromJump ?? i[0].currentFrame;
+      const s = this.speedRatio === 0 ? 0 : (t - this._frameToSyncFromJump) / n * 1e3 / this.speedRatio;
+      this._manualJumpDelay = -s;
+    }
+    for (let n = 0; n < i.length; n++)
+      i[n].goToFrame(t, e ? this._weight : -1);
+    this._goToFrame = t;
+  }
+  /**
+   * Returns true if the animations for this animatable are paused
+   */
+  get paused() {
+    return this._paused;
+  }
+  /**
+   * Pause the animation
+   */
+  pause() {
+    this._paused || (this._paused = !0);
+  }
+  /**
+   * Restart the animation
+   */
+  restart() {
+    this._paused = !1;
+  }
+  _raiseOnAnimationEnd() {
+    this.onAnimationEnd && this.onAnimationEnd(), this.onAnimationEndObservable.notifyObservers(this);
+  }
+  /**
+   * Stop and delete the current animation
+   * @param animationName defines a string used to only stop some of the runtime animations instead of all
+   * @param targetMask a function that determines if the animation should be stopped based on its target (all animations will be stopped if both this and animationName are empty)
+   * @param useGlobalSplice if true, the animatables will be removed by the caller of this function (false by default)
+   * @param skipOnAnimationEnd defines if the system should not raise onAnimationEnd. Default is false
+   */
+  stop(t, e, i = !1, n = !1) {
+    if (t || e) {
+      const s = this._scene._activeAnimatables.indexOf(this);
+      if (s > -1) {
+        const a = this._runtimeAnimations;
+        for (let r = a.length - 1; r >= 0; r--) {
+          const o = a[r];
+          t && o.animation.name != t || e && !e(o.target) || (o.dispose(), a.splice(r, 1));
+        }
+        a.length == 0 && (i || this._scene._activeAnimatables.splice(s, 1), n || this._raiseOnAnimationEnd());
+      }
+    } else {
+      const s = this._scene._activeAnimatables.indexOf(this);
+      if (s > -1) {
+        i || this._scene._activeAnimatables.splice(s, 1);
+        const a = this._runtimeAnimations;
+        for (let r = 0; r < a.length; r++)
+          a[r].dispose();
+        this._runtimeAnimations.length = 0, n || this._raiseOnAnimationEnd();
+      }
+    }
+  }
+  /**
+   * Wait asynchronously for the animation to end
+   * @returns a promise which will be fulfilled when the animation ends
+   */
+  async waitAsync() {
+    return await new Promise((t) => {
+      this.onAnimationEndObservable.add(() => {
+        t(this);
+      }, void 0, void 0, this, !0);
+    });
+  }
+  /**
+   * @internal
+   */
+  _animate(t) {
+    if (this._paused)
+      return this.animationStarted = !1, this._pausedDelay === null && (this._pausedDelay = t), !0;
+    if (this._localDelayOffset === null ? (this._localDelayOffset = t, this._pausedDelay = null) : this._pausedDelay !== null && (this._localDelayOffset += t - this._pausedDelay, this._pausedDelay = null), this._manualJumpDelay !== null && (this._localDelayOffset += this.speedRatio < 0 ? -this._manualJumpDelay : this._manualJumpDelay, this._manualJumpDelay = null, this._frameToSyncFromJump = null), this._goToFrame = null, !I.ProcessPausedAnimatables && this._weight === 0 && this._previousWeight === 0)
+      return !0;
+    this._previousWeight = this._weight;
+    let e = !1;
+    const i = this._runtimeAnimations;
+    let n;
+    for (n = 0; n < i.length; n++) {
+      const a = i[n].animate(t - this._localDelayOffset, this.fromFrame, this.toFrame, this.loopAnimation, this._speedRatio, this._weight);
+      e = e || a;
+    }
+    if (this.animationStarted = e, !e) {
+      if (this.disposeOnEnd)
+        for (n = this._scene._activeAnimatables.indexOf(this), this._scene._activeAnimatables.splice(n, 1), n = 0; n < i.length; n++)
+          i[n].dispose();
+      this._raiseOnAnimationEnd(), this.disposeOnEnd && (this.onAnimationEnd = null, this.onAnimationLoop = null, this.onAnimationLoopObservable.clear(), this.onAnimationEndObservable.clear());
+    }
+    return e;
+  }
+}
+I.ProcessPausedAnimatables = !1;
+function z(h) {
+  if (h.totalWeight === 0 && h.totalAdditiveWeight === 0)
+    return h.originalValue;
+  let t = 1;
+  const e = T.Vector3[0], i = T.Vector3[1], n = T.Quaternion[0];
+  let s = 0;
+  const a = h.animations[0], r = h.originalValue;
+  let o, l = !1;
+  if (h.totalWeight < 1)
+    o = 1 - h.totalWeight, r.decompose(i, n, e);
+  else {
+    if (s = 1, t = h.totalWeight, o = a.weight / t, o == 1)
+      if (h.totalAdditiveWeight)
+        l = !0;
+      else
+        return a.currentValue;
+    a.currentValue.decompose(i, n, e);
+  }
+  if (!l) {
+    i.scaleInPlace(o), e.scaleInPlace(o), n.scaleInPlace(o);
+    for (let c = s; c < h.animations.length; c++) {
+      const g = h.animations[c];
+      if (g.weight === 0)
+        continue;
+      o = g.weight / t;
+      const d = T.Vector3[2], _ = T.Vector3[3], m = T.Quaternion[1];
+      g.currentValue.decompose(_, m, d), _.scaleAndAddToRef(o, i), m.scaleAndAddToRef(S.Dot(n, m) > 0 ? o : -o, n), d.scaleAndAddToRef(o, e);
+    }
+    n.normalize();
+  }
+  for (let c = 0; c < h.additiveAnimations.length; c++) {
+    const g = h.additiveAnimations[c];
+    if (g.weight === 0)
+      continue;
+    const d = T.Vector3[2], _ = T.Vector3[3], m = T.Quaternion[1];
+    g.currentValue.decompose(_, m, d), _.multiplyToRef(i, _), k.LerpToRef(i, _, g.weight, i), n.multiplyToRef(m, m), S.SlerpToRef(n, m, g.weight, n), d.scaleAndAddToRef(g.weight, e);
+  }
+  const u = a ? a._animationState.workValue : T.Matrix[0].clone();
+  return F.ComposeToRef(i, n, e, u), u;
+}
+function H(h, t) {
+  if (h.totalWeight === 0 && h.totalAdditiveWeight === 0)
+    return t;
+  const e = h.animations[0], i = h.originalValue;
+  let n = t;
+  if (h.totalWeight === 0 && h.totalAdditiveWeight > 0)
+    n.copyFrom(i);
+  else if (h.animations.length === 1) {
+    if (S.SlerpToRef(i, e.currentValue, Math.min(1, h.totalWeight), n), h.totalAdditiveWeight === 0)
+      return n;
+  } else if (h.animations.length > 1) {
+    let s = 1, a, r;
+    if (h.totalWeight < 1) {
+      const l = 1 - h.totalWeight;
+      a = [], r = [], a.push(i), r.push(l);
+    } else {
+      if (h.animations.length === 2 && (S.SlerpToRef(h.animations[0].currentValue, h.animations[1].currentValue, h.animations[1].weight / h.totalWeight, t), h.totalAdditiveWeight === 0))
+        return t;
+      a = [], r = [], s = h.totalWeight;
+    }
+    for (let l = 0; l < h.animations.length; l++) {
+      const u = h.animations[l];
+      a.push(u.currentValue), r.push(u.weight / s);
+    }
+    let o = 0;
+    for (let l = 0; l < a.length; ) {
+      if (!l) {
+        S.SlerpToRef(a[l], a[l + 1], r[l + 1] / (r[l] + r[l + 1]), t), n = t, o = r[l] + r[l + 1], l += 2;
+        continue;
+      }
+      o += r[l], S.SlerpToRef(n, a[l], r[l] / o, n), l++;
+    }
+  }
+  for (let s = 0; s < h.additiveAnimations.length; s++) {
+    const a = h.additiveAnimations[s];
+    a.weight !== 0 && (n.multiplyToRef(a.currentValue, T.Quaternion[0]), S.SlerpToRef(n, T.Quaternion[0], a.weight, n));
+  }
+  return n;
+}
+function J(h) {
+  if (h._registeredForLateAnimationBindings.length) {
+    for (let t = 0; t < h._registeredForLateAnimationBindings.length; t++) {
+      const e = h._registeredForLateAnimationBindings.data[t];
+      for (const i in e._lateAnimationHolders) {
+        const n = e._lateAnimationHolders[i], s = n.animations[0], a = n.originalValue;
+        if (a == null)
+          continue;
+        const r = A.AllowMatrixDecomposeForInterpolation && a.m;
+        let o = e[i];
+        if (r)
+          o = z(n);
+        else if (a.w !== void 0)
+          o = H(n, o || S.Identity());
+        else {
+          let u = 0, c = 1;
+          const g = s && s._animationState.loopMode === A.ANIMATIONLOOPMODE_RELATIVE_FROM_CURRENT;
+          if (n.totalWeight < 1)
+            g ? o = a.clone ? a.clone() : a : s && a.scale ? o = a.scale(1 - n.totalWeight) : s ? o = a * (1 - n.totalWeight) : a.clone ? o = a.clone() : o = a;
+          else if (s) {
+            c = n.totalWeight;
+            const d = s.weight / c;
+            d !== 1 ? s.currentValue.scale ? o = s.currentValue.scale(d) : o = s.currentValue * d : o = s.currentValue, g && (o.addToRef ? o.addToRef(a, o) : o += a), u = 1;
+          }
+          for (let d = u; d < n.animations.length; d++) {
+            const _ = n.animations[d], m = _.weight / c;
+            if (m)
+              _.currentValue.scaleAndAddToRef ? _.currentValue.scaleAndAddToRef(m, o) : o += _.currentValue * m;
+            else continue;
+          }
+          for (let d = 0; d < n.additiveAnimations.length; d++) {
+            const _ = n.additiveAnimations[d], m = _.weight;
+            if (m)
+              _.currentValue.scaleAndAddToRef ? _.currentValue.scaleAndAddToRef(m, o) : o += _.currentValue * m;
+            else continue;
+          }
+        }
+        e[i] = o;
+      }
+      e._lateAnimationHolders = {};
+    }
+    h._registeredForLateAnimationBindings.reset();
+  }
+}
+function X(h, t) {
+  t && (t.prototype.copyAnimationRange = function(e, i, n, s = !1, a = null) {
+    this.animations.length === 0 && (this.animations.push(new A(this.name, "_matrix", e.animations[0].framePerSecond, A.ANIMATIONTYPE_MATRIX, 0)), this.animations[0].setKeys([]));
+    const r = e.animations[0].getRange(i);
+    if (!r)
+      return !1;
+    const o = r.from, l = r.to, u = e.animations[0].getKeys(), c = e.length, g = e.getParent(), d = this.getParent(), _ = s && g && c && this.length && c !== this.length, m = _ && d && g ? d.length / g.length : 1, b = s && !d && a && (a.x !== 1 || a.y !== 1 || a.z !== 1), O = this.animations[0].getKeys();
+    let v, f, p;
+    for (let y = 0, L = u.length; y < L; y++)
+      v = u[y], v.frame >= o && v.frame <= l && (s ? (p = v.value.clone(), _ ? (f = p.getTranslation(), p.setTranslation(f.scaleInPlace(m))) : b && a ? (f = p.getTranslation(), p.setTranslation(f.multiplyInPlace(a))) : p = v.value) : p = v.value, O.push({ frame: v.frame + n, value: p }));
+    return this.animations[0].createRange(i, o + n, l + n), !0;
+  }), h && (h.prototype._animate = function(e) {
+    if (!this.animationsEnabled)
+      return;
+    const i = C.Now;
+    if (!this._animationTimeLast) {
+      if (this._pendingData.length > 0)
+        return;
+      this._animationTimeLast = i;
+    }
+    this.deltaTime = e !== void 0 ? e : this.useConstantAnimationDeltaTime ? 16 : (i - this._animationTimeLast) * this.animationTimeScale, this._animationTimeLast = i;
+    const n = this._activeAnimatables;
+    if (n.length === 0)
+      return;
+    this._animationTime += this.deltaTime;
+    const s = this._animationTime;
+    for (let a = 0; a < n.length; a++) {
+      const r = n[a];
+      !r._animate(s) && r.disposeOnEnd && a--;
+    }
+    J(this);
+  }, h.prototype.sortActiveAnimatables = function() {
+    this._activeAnimatables.sort((e, i) => e.playOrder - i.playOrder);
+  }, h.prototype.beginWeightedAnimation = function(e, i, n, s = 1, a, r = 1, o, l, u, c, g = !1) {
+    const d = this.beginAnimation(e, i, n, a, r, o, l, !1, u, c, g);
+    return d.weight = s, d;
+  }, h.prototype.beginAnimation = function(e, i, n, s, a = 1, r, o, l = !0, u, c, g = !1) {
+    if (a < 0) {
+      const _ = i;
+      i = n, n = _, a = -a;
+    }
+    i > n && (a = -a), l && this.stopAnimation(e, void 0, u), o || (o = new I(this, e, i, n, s, a, r, void 0, c, g));
+    const d = u ? u(e) : !0;
+    if (e.animations && d && o.appendAnimations(e, e.animations), e.getAnimatables) {
+      const _ = e.getAnimatables();
+      for (let m = 0; m < _.length; m++)
+        this.beginAnimation(_[m], i, n, s, a, r, o, l, u, c);
+    }
+    return o.reset(), o;
+  }, h.prototype.beginHierarchyAnimation = function(e, i, n, s, a, r = 1, o, l, u = !0, c, g, d = !1) {
+    const _ = e.getDescendants(i), m = [];
+    m.push(this.beginAnimation(e, n, s, a, r, o, l, u, c, void 0, d));
+    for (const b of _)
+      m.push(this.beginAnimation(b, n, s, a, r, o, l, u, c, void 0, d));
+    return m;
+  }, h.prototype.beginDirectAnimation = function(e, i, n, s, a, r = 1, o, l, u = !1) {
+    if (r < 0) {
+      const g = n;
+      n = s, s = g, r = -r;
+    }
+    return n > s && (r = -r), new I(this, e, n, s, a, r, o, i, l, u);
+  }, h.prototype.beginDirectHierarchyAnimation = function(e, i, n, s, a, r, o, l, u, c = !1) {
+    const g = e.getDescendants(i), d = [];
+    d.push(this.beginDirectAnimation(e, n, s, a, r, o, l, u, c));
+    for (const _ of g)
+      d.push(this.beginDirectAnimation(_, n, s, a, r, o, l, u, c));
+    return d;
+  }, h.prototype.getAnimatableByTarget = function(e) {
+    for (let i = 0; i < this._activeAnimatables.length; i++)
+      if (this._activeAnimatables[i].target === e)
+        return this._activeAnimatables[i];
+    return null;
+  }, h.prototype.getAllAnimatablesByTarget = function(e) {
+    const i = [];
+    for (let n = 0; n < this._activeAnimatables.length; n++)
+      this._activeAnimatables[n].target === e && i.push(this._activeAnimatables[n]);
+    return i;
+  }, h.prototype.stopAnimation = function(e, i, n) {
+    const s = this.getAllAnimatablesByTarget(e);
+    for (const a of s)
+      a.stop(i, n);
+  }, h.prototype.stopAllAnimations = function() {
+    if (this._activeAnimatables) {
+      for (let e = 0; e < this._activeAnimatables.length; e++)
+        this._activeAnimatables[e].stop(void 0, void 0, !0);
+      this._activeAnimatables.length = 0;
+    }
+    for (const e of this.animationGroups)
+      e.stop();
+  });
+}
+X(W, D);
+class q {
+  /**
+   * Returns the string "TargetedAnimation"
+   * @returns "TargetedAnimation"
+   */
+  getClassName() {
+    return "TargetedAnimation";
+  }
+  /**
+   * Creates a new targeted animation
+   * @param parent The animation group to which the animation belongs
+   */
+  constructor(t) {
+    this.parent = t, this.uniqueId = U.UniqueId;
+  }
+  /**
+   * Serialize the object
+   * @returns the JSON object representing the current entity
+   */
+  serialize() {
+    const t = {};
+    return t.animation = this.animation.serialize(), t.targetId = this.target.id, t.targetUniqueId = this.target.uniqueId, t;
+  }
+}
+class V {
+  /**
+   * Gets or sets the mask associated with this animation group. This mask is used to filter which objects should be animated.
+   */
+  get mask() {
+    return this._mask;
+  }
+  set mask(t) {
+    this._mask !== t && (this._mask = t, this.syncWithMask(!0));
+  }
+  /**
+   * Makes sure that the animations are either played or stopped according to the animation group mask.
+   * Note however that the call won't have any effect if the animation group has not been started yet.
+   * @param forceUpdate If true, forces to loop over the animatables even if no mask is defined (used internally, you shouldn't need to use it). Default: false.
+   */
+  syncWithMask(t = !1) {
+    if (!this.mask && !t) {
+      this._numActiveAnimatables = this._targetedAnimations.length;
+      return;
+    }
+    this._numActiveAnimatables = 0;
+    for (let e = 0; e < this._animatables.length; ++e) {
+      const i = this._animatables[e];
+      !this.mask || this.mask.disabled || this.mask.retainsTarget(i.target.name) ? (this._numActiveAnimatables++, i.paused && i.restart()) : i.paused || i.pause();
+    }
+  }
+  /**
+   * Removes all animations for the targets not retained by the animation group mask.
+   * Use this function if you know you won't need those animations anymore and if you want to free memory.
+   */
+  removeUnmaskedAnimations() {
+    if (!(!this.mask || this.mask.disabled)) {
+      for (let t = 0; t < this._animatables.length; ++t) {
+        const e = this._animatables[t];
+        this.mask.retainsTarget(e.target.name) || (e.stop(), this._animatables.splice(t, 1), --t);
+      }
+      for (let t = 0; t < this._targetedAnimations.length; t++) {
+        const e = this._targetedAnimations[t];
+        this.mask.retainsTarget(e.target.name) || (this._targetedAnimations.splice(t, 1), --t);
+      }
+    }
+  }
+  /**
+   * Gets or sets the first frame
+   */
+  get from() {
+    return this._from;
+  }
+  set from(t) {
+    if (this._from !== t) {
+      this._from = t;
+      for (let e = 0; e < this._animatables.length; e++) {
+        const i = this._animatables[e];
+        i.fromFrame = this._from;
+      }
+    }
+  }
+  /**
+   * Gets or sets the last frame
+   */
+  get to() {
+    return this._to;
+  }
+  set to(t) {
+    if (this._to !== t) {
+      this._to = t;
+      for (let e = 0; e < this._animatables.length; e++) {
+        const i = this._animatables[e];
+        i.toFrame = this._to;
+      }
+    }
+  }
+  /**
+   * Define if the animations are started
+   */
+  get isStarted() {
+    return this._isStarted;
+  }
+  /**
+   * Gets a value indicating that the current group is playing
+   */
+  get isPlaying() {
+    return this._isStarted && !this._isPaused;
+  }
+  /**
+   * Gets or sets the speed ratio to use for all animations
+   */
+  get speedRatio() {
+    return this._speedRatio;
+  }
+  /**
+   * Gets or sets the speed ratio to use for all animations
+   */
+  set speedRatio(t) {
+    if (this._speedRatio !== t) {
+      this._speedRatio = t;
+      for (let e = 0; e < this._animatables.length; e++) {
+        const i = this._animatables[e];
+        i.speedRatio = this._speedRatio;
+      }
+    }
+  }
+  /**
+   * Gets or sets if all animations should loop or not
+   */
+  get loopAnimation() {
+    return this._loopAnimation;
+  }
+  set loopAnimation(t) {
+    if (this._loopAnimation !== t) {
+      this._loopAnimation = t;
+      for (let e = 0; e < this._animatables.length; e++) {
+        const i = this._animatables[e];
+        i.loopAnimation = this._loopAnimation;
+      }
+    }
+  }
+  /**
+   * Gets or sets if all animations should be evaluated additively
+   */
+  get isAdditive() {
+    return this._isAdditive;
+  }
+  set isAdditive(t) {
+    if (this._isAdditive !== t) {
+      this._isAdditive = t;
+      for (let e = 0; e < this._animatables.length; e++) {
+        const i = this._animatables[e];
+        i.isAdditive = this._isAdditive;
+      }
+    }
+  }
+  /**
+   * Gets or sets the weight to apply to all animations of the group
+   */
+  get weight() {
+    return this._weight;
+  }
+  set weight(t) {
+    this._weight !== t && (this._weight = t, this.setWeightForAllAnimatables(this._weight));
+  }
+  /**
+   * Gets the targeted animations for this animation group
+   */
+  get targetedAnimations() {
+    return this._targetedAnimations;
+  }
+  /**
+   * returning the list of animatables controlled by this animation group.
+   */
+  get animatables() {
+    return this._animatables;
+  }
+  /**
+   * Gets the list of target animations
+   */
+  get children() {
+    return this._targetedAnimations;
+  }
+  /**
+   * Gets or sets the order of play of the animation group (default: 0)
+   */
+  get playOrder() {
+    return this._playOrder;
+  }
+  set playOrder(t) {
+    if (this._playOrder !== t && (this._playOrder = t, this._animatables.length > 0)) {
+      for (let e = 0; e < this._animatables.length; e++)
+        this._animatables[e].playOrder = this._playOrder;
+      this._scene.sortActiveAnimatables();
+    }
+  }
+  /**
+   * Allows the animations of the animation group to blend with current running animations
+   * Note that a null value means that each animation will use their own existing blending configuration (Animation.enableBlending)
+   */
+  get enableBlending() {
+    return this._enableBlending;
+  }
+  set enableBlending(t) {
+    if (this._enableBlending !== t && (this._enableBlending = t, t !== null))
+      for (let e = 0; e < this._targetedAnimations.length; ++e)
+        this._targetedAnimations[e].animation.enableBlending = t;
+  }
+  /**
+   * Gets or sets the animation blending speed
+   * Note that a null value means that each animation will use their own existing blending configuration (Animation.blendingSpeed)
+   */
+  get blendingSpeed() {
+    return this._blendingSpeed;
+  }
+  set blendingSpeed(t) {
+    if (this._blendingSpeed !== t && (this._blendingSpeed = t, t !== null))
+      for (let e = 0; e < this._targetedAnimations.length; ++e)
+        this._targetedAnimations[e].animation.blendingSpeed = t;
+  }
+  /**
+   * Gets the length (in seconds) of the animation group
+   * This function assumes that all animations are played at the same framePerSecond speed!
+   * Note: you can only call this method after you've added at least one targeted animation!
+   * @param from Starting frame range (default is AnimationGroup.from)
+   * @param to Ending frame range (default is AnimationGroup.to)
+   * @returns The length in seconds
+   */
+  getLength(t, e) {
+    t = t ?? this._from, e = e ?? this._to;
+    const i = this.targetedAnimations[0].animation.framePerSecond * this._speedRatio;
+    return (e - t) / i;
+  }
+  /**
+   * Merge the array of animation groups into a new animation group
+   * @param animationGroups List of animation groups to merge
+   * @param disposeSource If true, animation groups will be disposed after being merged (default: true)
+   * @param normalize If true, animation groups will be normalized before being merged, so that all animations have the same "from" and "to" frame (default: false)
+   * @param weight Weight for the new animation group. If not provided, it will inherit the weight from the first animation group of the array
+   * @returns The new animation group or null if no animation groups were passed
+   */
+  static MergeAnimationGroups(t, e = !0, i = !1, n) {
+    if (t.length === 0)
+      return null;
+    n = n ?? t[0].weight;
+    let s = Number.MAX_VALUE, a = -Number.MAX_VALUE;
+    if (i)
+      for (const o of t)
+        o.from < s && (s = o.from), o.to > a && (a = o.to);
+    const r = new V(t[0].name + "_merged", t[0]._scene, n);
+    for (const o of t) {
+      i && o.normalize(s, a);
+      for (const l of o.targetedAnimations)
+        r.addTargetedAnimation(l.animation, l.target);
+      e && o.dispose();
+    }
+    return r;
+  }
+  /**
+   * Gets the scene the animation group belongs to
+   * @returns The scene the animation group belongs to
+   */
+  getScene() {
+    return this._scene;
+  }
+  /**
+   * Instantiates a new Animation Group.
+   * This helps managing several animations at once.
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/groupAnimations
+   * @param name Defines the name of the group
+   * @param scene Defines the scene the group belongs to
+   * @param weight Defines the weight to use for animations in the group (-1.0 by default, meaning "no weight")
+   * @param playOrder Defines the order of play of the animation group (default is 0)
+   */
+  constructor(t, e = null, i = -1, n = 0) {
+    this.name = t, this._targetedAnimations = new Array(), this._animatables = new Array(), this._from = Number.MAX_VALUE, this._to = -Number.MAX_VALUE, this._speedRatio = 1, this._loopAnimation = !1, this._isAdditive = !1, this._weight = -1, this._playOrder = 0, this._enableBlending = null, this._blendingSpeed = null, this._numActiveAnimatables = 0, this._shouldStart = !0, this._parentContainer = null, this.onAnimationEndObservable = new P(), this.onAnimationLoopObservable = new P(), this.onAnimationGroupLoopObservable = new P(), this.onAnimationGroupEndObservable = new P(), this.onAnimationGroupPauseObservable = new P(), this.onAnimationGroupPlayObservable = new P(), this.metadata = null, this._mask = null, this._animationLoopFlags = [], this._scene = e || K.LastCreatedScene, this._weight = i, this._playOrder = n, this.uniqueId = this._scene.getUniqueId(), this._scene.addAnimationGroup(this);
+  }
+  /**
+   * Add an animation (with its target) in the group
+   * @param animation defines the animation we want to add
+   * @param target defines the target of the animation
+   * @returns the TargetedAnimation object
+   */
+  addTargetedAnimation(t, e) {
+    const i = new q(this);
+    i.animation = t, i.target = e;
+    const n = t.getKeys();
+    return this._from > n[0].frame && (this._from = n[0].frame), this._to < n[n.length - 1].frame && (this._to = n[n.length - 1].frame), this._enableBlending !== null && (t.enableBlending = this._enableBlending), this._blendingSpeed !== null && (t.blendingSpeed = this._blendingSpeed), this._targetedAnimations.push(i), this._shouldStart = !0, i;
+  }
+  /**
+   * Remove an animation from the group
+   * @param animation defines the animation we want to remove
+   */
+  removeTargetedAnimation(t) {
+    for (let e = this._targetedAnimations.length - 1; e > -1; e--)
+      this._targetedAnimations[e].animation === t && this._targetedAnimations.splice(e, 1);
+  }
+  /**
+   * This function will normalize every animation in the group to make sure they all go from beginFrame to endFrame
+   * It can add constant keys at begin or end
+   * @param beginFrame defines the new begin frame for all animations or the smallest begin frame of all animations if null (defaults to null)
+   * @param endFrame defines the new end frame for all animations or the largest end frame of all animations if null (defaults to null)
+   * @returns the animation group
+   */
+  normalize(t = null, e = null) {
+    t == null && (t = this._from), e == null && (e = this._to);
+    for (let i = 0; i < this._targetedAnimations.length; i++) {
+      const s = this._targetedAnimations[i].animation.getKeys(), a = s[0], r = s[s.length - 1];
+      if (a.frame > t) {
+        const o = {
+          frame: t,
+          value: a.value,
+          inTangent: a.inTangent,
+          outTangent: a.outTangent,
+          interpolation: a.interpolation
+        };
+        s.splice(0, 0, o);
+      }
+      if (r.frame < e) {
+        const o = {
+          frame: e,
+          value: r.value,
+          inTangent: r.inTangent,
+          outTangent: r.outTangent,
+          interpolation: r.interpolation
+        };
+        s.push(o);
+      }
+    }
+    return this._from = t, this._to = e, this;
+  }
+  _processLoop(t, e, i) {
+    t.onAnimationLoop = () => {
+      this.onAnimationLoopObservable.notifyObservers(e), !this._animationLoopFlags[i] && (this._animationLoopFlags[i] = !0, this._animationLoopCount++, this._animationLoopCount === this._numActiveAnimatables && (this.onAnimationGroupLoopObservable.notifyObservers(this), this._animationLoopCount = 0, this._animationLoopFlags.length = 0));
+    };
+  }
+  /**
+   * Start all animations on given targets
+   * @param loop defines if animations must loop
+   * @param speedRatio defines the ratio to apply to animation speed (1 by default)
+   * @param from defines the from key (optional)
+   * @param to defines the to key (optional)
+   * @param isAdditive defines the additive state for the resulting animatables (optional)
+   * @returns the current animation group
+   */
+  start(t = !1, e = 1, i, n, s) {
+    if (this._isStarted || this._targetedAnimations.length === 0)
+      return this;
+    this._loopAnimation = t, this._shouldStart = !1, this._animationLoopCount = 0, this._animationLoopFlags.length = 0;
+    for (let a = 0; a < this._targetedAnimations.length; a++) {
+      const r = this._targetedAnimations[a], o = this._scene.beginDirectAnimation(r.target, [r.animation], i !== void 0 ? i : this._from, n !== void 0 ? n : this._to, t, e, void 0, void 0, s !== void 0 ? s : this._isAdditive);
+      o.weight = this._weight, o.playOrder = this._playOrder, o.onAnimationEnd = () => {
+        this.onAnimationEndObservable.notifyObservers(r), this._checkAnimationGroupEnded(o);
+      }, this._processLoop(o, r, a), this._animatables.push(o);
+    }
+    return this.syncWithMask(), this._scene.sortActiveAnimatables(), this._speedRatio = e, this._isStarted = !0, this._isPaused = !1, this.onAnimationGroupPlayObservable.notifyObservers(this), this;
+  }
+  /**
+   * Pause all animations
+   * @returns the animation group
+   */
+  pause() {
+    if (!this._isStarted)
+      return this;
+    this._isPaused = !0;
+    for (let t = 0; t < this._animatables.length; t++)
+      this._animatables[t].pause();
+    return this.onAnimationGroupPauseObservable.notifyObservers(this), this;
+  }
+  /**
+   * Play all animations to initial state
+   * This function will start() the animations if they were not started or will restart() them if they were paused
+   * @param loop defines if animations must loop
+   * @returns the animation group
+   */
+  play(t) {
+    return this.isStarted && this._animatables.length && !this._shouldStart ? (t !== void 0 && (this.loopAnimation = t), this.restart()) : (this.stop(), this.start(t, this._speedRatio)), this;
+  }
+  /**
+   * Reset all animations to initial state
+   * @returns the animation group
+   */
+  reset() {
+    if (!this._isStarted)
+      return this.play(), this.goToFrame(0), this.stop(!0), this;
+    for (let t = 0; t < this._animatables.length; t++)
+      this._animatables[t].reset();
+    return this;
+  }
+  /**
+   * Restart animations from after pausing it
+   * @returns the animation group
+   */
+  restart() {
+    if (!this._isStarted)
+      return this;
+    for (let t = 0; t < this._animatables.length; t++)
+      this._animatables[t].restart();
+    return this.syncWithMask(), this._isPaused = !1, this.onAnimationGroupPlayObservable.notifyObservers(this), this;
+  }
+  /**
+   * Stop all animations
+   * @param skipOnAnimationEnd defines if the system should not raise onAnimationEnd. Default is false
+   * @returns the animation group
+   */
+  stop(t = !1) {
+    if (!this._isStarted)
+      return this;
+    const e = this._animatables.slice();
+    for (let n = 0; n < e.length; n++)
+      e[n].stop(void 0, void 0, !0, t);
+    let i = 0;
+    for (let n = 0; n < this._scene._activeAnimatables.length; n++) {
+      const s = this._scene._activeAnimatables[n];
+      s._runtimeAnimations.length > 0 ? this._scene._activeAnimatables[i++] = s : t && this._checkAnimationGroupEnded(s, t);
+    }
+    return this._scene._activeAnimatables.length = i, this._isStarted = !1, this;
+  }
+  /**
+   * Set animation weight for all animatables
+   *
+   * @since 6.12.4
+   *  You can pass the weight to the AnimationGroup constructor, or use the weight property to set it after the group has been created,
+   *  making it easier to define the overall animation weight than calling setWeightForAllAnimatables() after the animation group has been started
+   * @param weight defines the weight to use
+   * @returns the animationGroup
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#animation-weights
+   */
+  setWeightForAllAnimatables(t) {
+    for (let e = 0; e < this._animatables.length; e++) {
+      const i = this._animatables[e];
+      i.weight = t;
+    }
+    return this;
+  }
+  /**
+   * Synchronize and normalize all animatables with a source animatable
+   * @param root defines the root animatable to synchronize with (null to stop synchronizing)
+   * @returns the animationGroup
+   * @see https://doc.babylonjs.com/features/featuresDeepDive/animation/advanced_animations#animation-weights
+   */
+  syncAllAnimationsWith(t) {
+    for (let e = 0; e < this._animatables.length; e++)
+      this._animatables[e].syncWith(t);
+    return this;
+  }
+  /**
+   * Goes to a specific frame in this animation group. Note that the animation group must be in playing or paused status
+   * @param frame the frame number to go to
+   * @param useWeight defines whether the animation weight should be applied to the image to be jumped to (false by default)
+   * @returns the animationGroup
+   */
+  goToFrame(t, e = !1) {
+    if (!this._isStarted)
+      return this;
+    for (let i = 0; i < this._animatables.length; i++)
+      this._animatables[i].goToFrame(t, e);
+    return this;
+  }
+  /**
+   * Helper to get the current frame. This will return 0 if the AnimationGroup is not running, and it might return wrong results if multiple animations are running in different frames.
+   * @returns current animation frame.
+   */
+  getCurrentFrame() {
+    return this.animatables[0]?.masterFrame || 0;
+  }
+  /**
+   * Dispose all associated resources
+   */
+  dispose() {
+    if (this.isStarted && this.stop(), this._targetedAnimations.length = 0, this._animatables.length = 0, this._scene.removeAnimationGroup(this), this._parentContainer) {
+      const t = this._parentContainer.animationGroups.indexOf(this);
+      t > -1 && this._parentContainer.animationGroups.splice(t, 1), this._parentContainer = null;
+    }
+    this.onAnimationEndObservable.clear(), this.onAnimationGroupEndObservable.clear(), this.onAnimationGroupPauseObservable.clear(), this.onAnimationGroupPlayObservable.clear(), this.onAnimationLoopObservable.clear(), this.onAnimationGroupLoopObservable.clear();
+  }
+  _checkAnimationGroupEnded(t, e = !1) {
+    const i = this._animatables.indexOf(t);
+    i > -1 && this._animatables.splice(i, 1), this._animatables.length === this._targetedAnimations.length - this._numActiveAnimatables && (this._isStarted = !1, e || this.onAnimationGroupEndObservable.notifyObservers(this), this._animatables.length = 0);
+  }
+  /**
+   * Clone the current animation group and returns a copy
+   * @param newName defines the name of the new group
+   * @param targetConverter defines an optional function used to convert current animation targets to new ones
+   * @param cloneAnimations defines if the animations should be cloned or referenced
+   * @param cloneAnimationKeys defines if the animation keys should be cloned when cloning animations (false by default). No effect if cloneAnimations is false
+   * @returns the new animation group
+   */
+  clone(t, e, i = !1, n = !1) {
+    const s = new V(t || this.name, this._scene, this._weight, this._playOrder);
+    s._from = this.from, s._to = this.to, s._speedRatio = this.speedRatio, s._loopAnimation = this.loopAnimation, s._isAdditive = this.isAdditive, s._enableBlending = this.enableBlending, s._blendingSpeed = this.blendingSpeed, s.metadata = this.metadata, s.mask = this.mask;
+    for (const a of this._targetedAnimations)
+      s.addTargetedAnimation(i ? a.animation.clone(n) : a.animation, e ? e(a.target) : a.target);
+    return s;
+  }
+  /**
+   * Serializes the animationGroup to an object
+   * @returns Serialized object
+   */
+  serialize() {
+    const t = {};
+    t.name = this.name, t.from = this.from, t.to = this.to, t.speedRatio = this.speedRatio, t.loopAnimation = this.loopAnimation, t.isAdditive = this.isAdditive, t.weight = this.weight, t.playOrder = this.playOrder, t.enableBlending = this.enableBlending, t.blendingSpeed = this.blendingSpeed, t.targetedAnimations = [];
+    for (let e = 0; e < this.targetedAnimations.length; e++) {
+      const i = this.targetedAnimations[e];
+      t.targetedAnimations[e] = i.serialize();
+    }
+    return w && w.HasTags(this) && (t.tags = w.GetTags(this)), this.metadata && (t.metadata = this.metadata), t;
+  }
+  // Statics
+  /**
+   * Returns a new AnimationGroup object parsed from the source provided.
+   * @param parsedAnimationGroup defines the source
+   * @param scene defines the scene that will receive the animationGroup
+   * @param targetLookup a callback that will be used instead of the default lookup
+   * @returns a new AnimationGroup
+   */
+  static Parse(t, e, i) {
+    const n = new V(t.name, e, t.weight, t.playOrder);
+    for (let s = 0; s < t.targetedAnimations.length; s++) {
+      const a = t.targetedAnimations[s], r = A.Parse(a.animation), o = i ? i(a) : a.animation.property === "influence" ? e.getMorphTargetById(a.targetId) : e.getNodeById(a.targetId);
+      o && n.addTargetedAnimation(r, o);
+    }
+    return w && w.AddTagsTo(n, t.tags), t.from !== null && t.to !== null && n.normalize(t.from, t.to), t.speedRatio !== void 0 && (n._speedRatio = t.speedRatio), t.loopAnimation !== void 0 && (n._loopAnimation = t.loopAnimation), t.isAdditive !== void 0 && (n._isAdditive = t.isAdditive), t.weight !== void 0 && (n._weight = t.weight), t.playOrder !== void 0 && (n._playOrder = t.playOrder), t.enableBlending !== void 0 && (n._enableBlending = t.enableBlending), t.blendingSpeed !== void 0 && (n._blendingSpeed = t.blendingSpeed), t.metadata !== void 0 && (n.metadata = t.metadata), n;
+  }
+  /** @internal */
+  static MakeAnimationAdditive(t, e, i, n = !1, s) {
+    let a;
+    typeof e == "object" ? a = e : a = {
+      referenceFrame: e,
+      range: i,
+      cloneOriginalAnimationGroup: n,
+      clonedAnimationName: s
+    };
+    let r = t;
+    a.cloneOriginalAnimationGroup && (r = t.clone(a.clonedAnimationGroupName || r.name));
+    const o = r.targetedAnimations;
+    for (let l = 0; l < o.length; l++) {
+      const u = o[l];
+      u.animation = A.MakeAnimationAdditive(u.animation, a);
+    }
+    if (r.isAdditive = !0, a.clipKeys) {
+      let l = Number.MAX_VALUE, u = -Number.MAX_VALUE;
+      const c = r.targetedAnimations;
+      for (let g = 0; g < c.length; g++) {
+        const m = c[g].animation.getKeys();
+        l > m[0].frame && (l = m[0].frame), u < m[m.length - 1].frame && (u = m[m.length - 1].frame);
+      }
+      r._from = l, r._to = u;
+    }
+    return r;
+  }
+  /**
+   * Creates a new animation, keeping only the keys that are inside a given key range
+   * @param sourceAnimationGroup defines the animation group on which to operate
+   * @param fromKey defines the lower bound of the range
+   * @param toKey defines the upper bound of the range
+   * @param name defines the name of the new animation group. If not provided, use the same name as animationGroup
+   * @param dontCloneAnimations defines whether or not the animations should be cloned before clipping the keys. Default is false, so animations will be cloned
+   * @returns a new animation group stripped from all the keys outside the given range
+   */
+  static ClipKeys(t, e, i, n, s) {
+    const a = t.clone(n || t.name);
+    return V.ClipKeysInPlace(a, e, i, s);
+  }
+  /**
+   * Updates an existing animation, keeping only the keys that are inside a given key range
+   * @param animationGroup defines the animation group on which to operate
+   * @param fromKey defines the lower bound of the range
+   * @param toKey defines the upper bound of the range
+   * @param dontCloneAnimations defines whether or not the animations should be cloned before clipping the keys. Default is false, so animations will be cloned
+   * @returns the animationGroup stripped from all the keys outside the given range
+   */
+  static ClipKeysInPlace(t, e, i, n) {
+    return V.ClipInPlace(t, e, i, n, !1);
+  }
+  /**
+   * Creates a new animation, keeping only the frames that are inside a given frame range
+   * @param sourceAnimationGroup defines the animation group on which to operate
+   * @param fromFrame defines the lower bound of the range
+   * @param toFrame defines the upper bound of the range
+   * @param name defines the name of the new animation group. If not provided, use the same name as animationGroup
+   * @param dontCloneAnimations defines whether or not the animations should be cloned before clipping the frames. Default is false, so animations will be cloned
+   * @returns a new animation group stripped from all the frames outside the given range
+   */
+  static ClipFrames(t, e, i, n, s) {
+    const a = t.clone(n || t.name);
+    return V.ClipFramesInPlace(a, e, i, s);
+  }
+  /**
+   * Updates an existing animation, keeping only the frames that are inside a given frame range
+   * @param animationGroup defines the animation group on which to operate
+   * @param fromFrame defines the lower bound of the range
+   * @param toFrame defines the upper bound of the range
+   * @param dontCloneAnimations defines whether or not the animations should be cloned before clipping the frames. Default is false, so animations will be cloned
+   * @returns the animationGroup stripped from all the frames outside the given range
+   */
+  static ClipFramesInPlace(t, e, i, n) {
+    return V.ClipInPlace(t, e, i, n, !0);
+  }
+  /**
+   * Updates an existing animation, keeping only the keys that are inside a given key or frame range
+   * @param animationGroup defines the animation group on which to operate
+   * @param start defines the lower bound of the range
+   * @param end defines the upper bound of the range
+   * @param dontCloneAnimations defines whether or not the animations should be cloned before clipping the keys. Default is false, so animations will be cloned
+   * @param useFrame defines if the range is defined by frame numbers or key indices (default is false which means use key indices)
+   * @returns the animationGroup stripped from all the keys outside the given range
+   */
+  static ClipInPlace(t, e, i, n, s = !1) {
+    let a = Number.MAX_VALUE, r = -Number.MAX_VALUE;
+    const o = t.targetedAnimations;
+    for (let l = 0; l < o.length; l++) {
+      const u = o[l], c = n ? u.animation : u.animation.clone();
+      s && (c.createKeyForFrame(e), c.createKeyForFrame(i));
+      const g = c.getKeys(), d = [];
+      let _ = Number.MAX_VALUE;
+      for (let m = 0; m < g.length; m++) {
+        const b = g[m];
+        if (!s && m >= e && m <= i || s && b.frame >= e && b.frame <= i) {
+          const O = {
+            frame: b.frame,
+            value: b.value.clone ? b.value.clone() : b.value,
+            inTangent: b.inTangent,
+            outTangent: b.outTangent,
+            interpolation: b.interpolation,
+            lockedTangent: b.lockedTangent
+          };
+          _ === Number.MAX_VALUE && (_ = O.frame), O.frame -= _, d.push(O);
+        }
+      }
+      if (d.length === 0) {
+        o.splice(l, 1), l--;
+        continue;
+      }
+      a > d[0].frame && (a = d[0].frame), r < d[d.length - 1].frame && (r = d[d.length - 1].frame), c.setKeys(d, !0), u.animation = c;
+    }
+    return t._from = a, t._to = r, t;
+  }
+  /**
+   * Returns the string "AnimationGroup"
+   * @returns "AnimationGroup"
+   */
+  getClassName() {
+    return "AnimationGroup";
+  }
+  /**
+   * Creates a detailed string about the object
+   * @param fullDetails defines if the output string will support multiple levels of logging within scene loading
+   * @returns a string representing the object
+   */
+  toString(t) {
+    let e = "Name: " + this.name;
+    return e += ", type: " + this.getClassName(), t && (e += ", from: " + this._from, e += ", to: " + this._to, e += ", isStarted: " + this._isStarted, e += ", speedRatio: " + this._speedRatio, e += ", targetedAnimations length: " + this._targetedAnimations.length, e += ", animatables length: " + this._animatables.length), e;
+  }
+}
+export {
+  V as AnimationGroup,
+  q as TargetedAnimation
+};