@esotericsoftware/spine-webgl 4.3.4 → 4.3.6

package/dist/esm/spine-webgl.mjs

@@ -1303,17 +1303,14 @@ var Animation = class {
    * @param loop True if `time` beyond the {@link duration} repeats the animation, else the last frame is used.
    * @param events If any events are fired, they are added to this list. Pass null to ignore fired events or if no timelines fire
    *           events.
-   * @param alpha 0 applies setup or current values (depending on `fromSetup`), 1 uses timeline values, and
-   *           intermediate values interpolate between them. Adjusting `alpha` over time can mix an animation in or
-   *           out.
-   * @param fromSetup If true, `alpha` transitions between setup and timeline values, setup values are used before the
-   *           first frame (current values are not used). If false, `alpha` transitions between current and timeline
-   *           values, no change is made before the first frame.
+   * @param alpha 0 applies setup or current values (depending on `from`), 1 uses timeline values, and intermediate
+   *           values interpolate between them. Adjusting `alpha` over time can mix an animation in or out.
+   * @param from Controls how `alpha` and `add` mix from current or setup pose values to timeline values.
    * @param add If true, for timelines that support it, their values are added to the setup or current values (depending on
-   *           `fromSetup`).
+   *           `from`).
    * @param out True when the animation is mixing out, else it is mixing in. Used by timelines that perform instant transitions.
    * @param appliedPose True to modify {@link Posed.appliedPose}, else {@link Posed.pose} is modified. */
-  apply(skeleton, lastTime, time, loop, events, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, loop, events, alpha, from, add, out, appliedPose) {
     if (!skeleton) throw new Error("skeleton cannot be null.");
     if (loop && this.duration !== 0) {
       time %= this.duration;
@@ -1321,9 +1318,15 @@ var Animation = class {
     }
     const timelines = this.timelines;
     for (let i = 0, n = timelines.length; i < n; i++)
-      timelines[i].apply(skeleton, lastTime, time, events, alpha, fromSetup, add, out, appliedPose);
+      timelines[i].apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose);
   }
 };
+var MixFrom = /* @__PURE__ */ ((MixFrom2) => {
+  MixFrom2[MixFrom2["current"] = 0] = "current";
+  MixFrom2[MixFrom2["setup"] = 1] = "setup";
+  MixFrom2[MixFrom2["first"] = 2] = "first";
+  return MixFrom2;
+})(MixFrom || {});
 var Property = /* @__PURE__ */ ((Property2) => {
   Property2[Property2["rotate"] = 0] = "rotate";
   Property2[Property2["x"] = 1] = "x";
@@ -1340,28 +1343,31 @@ var Property = /* @__PURE__ */ ((Property2) => {
   Property2[Property2["deform"] = 12] = "deform";
   Property2[Property2["event"] = 13] = "event";
   Property2[Property2["drawOrder"] = 14] = "drawOrder";
-  Property2[Property2["ikConstraint"] = 15] = "ikConstraint";
-  Property2[Property2["transformConstraint"] = 16] = "transformConstraint";
-  Property2[Property2["pathConstraintPosition"] = 17] = "pathConstraintPosition";
-  Property2[Property2["pathConstraintSpacing"] = 18] = "pathConstraintSpacing";
-  Property2[Property2["pathConstraintMix"] = 19] = "pathConstraintMix";
-  Property2[Property2["physicsConstraintInertia"] = 20] = "physicsConstraintInertia";
-  Property2[Property2["physicsConstraintStrength"] = 21] = "physicsConstraintStrength";
-  Property2[Property2["physicsConstraintDamping"] = 22] = "physicsConstraintDamping";
-  Property2[Property2["physicsConstraintMass"] = 23] = "physicsConstraintMass";
-  Property2[Property2["physicsConstraintWind"] = 24] = "physicsConstraintWind";
-  Property2[Property2["physicsConstraintGravity"] = 25] = "physicsConstraintGravity";
-  Property2[Property2["physicsConstraintMix"] = 26] = "physicsConstraintMix";
-  Property2[Property2["physicsConstraintReset"] = 27] = "physicsConstraintReset";
-  Property2[Property2["sequence"] = 28] = "sequence";
-  Property2[Property2["sliderTime"] = 29] = "sliderTime";
-  Property2[Property2["sliderMix"] = 30] = "sliderMix";
+  Property2[Property2["drawOrderFolder"] = 15] = "drawOrderFolder";
+  Property2[Property2["ikConstraint"] = 16] = "ikConstraint";
+  Property2[Property2["transformConstraint"] = 17] = "transformConstraint";
+  Property2[Property2["pathConstraintPosition"] = 18] = "pathConstraintPosition";
+  Property2[Property2["pathConstraintSpacing"] = 19] = "pathConstraintSpacing";
+  Property2[Property2["pathConstraintMix"] = 20] = "pathConstraintMix";
+  Property2[Property2["physicsConstraintInertia"] = 21] = "physicsConstraintInertia";
+  Property2[Property2["physicsConstraintStrength"] = 22] = "physicsConstraintStrength";
+  Property2[Property2["physicsConstraintDamping"] = 23] = "physicsConstraintDamping";
+  Property2[Property2["physicsConstraintMass"] = 24] = "physicsConstraintMass";
+  Property2[Property2["physicsConstraintWind"] = 25] = "physicsConstraintWind";
+  Property2[Property2["physicsConstraintGravity"] = 26] = "physicsConstraintGravity";
+  Property2[Property2["physicsConstraintMix"] = 27] = "physicsConstraintMix";
+  Property2[Property2["physicsConstraintReset"] = 28] = "physicsConstraintReset";
+  Property2[Property2["sequence"] = 29] = "sequence";
+  Property2[Property2["sliderTime"] = 30] = "sliderTime";
+  Property2[Property2["sliderMix"] = 31] = "sliderMix";
   return Property2;
 })(Property || {});
 var Timeline = class {
   propertyIds;
   frames;
-  /** True if this timeline supports additive blending. */
+  /** True if this timeline supports being applied additively.
+   *
+   * See the `add` parameter in {@link Timeline.apply}. */
   additive = false;
   /** True if this timeline sets values instantaneously and does not support interpolation between frames. */
   instant = false;
@@ -1482,7 +1488,7 @@ var CurveTimeline = class extends Timeline {
     return y + (time - x) / (this.frames[frameIndex] - x) * (this.frames[frameIndex + valueOffset] - y);
   }
 };
-var CurveTimeline1 = class extends CurveTimeline {
+var CurveTimeline1 = class _CurveTimeline1 extends CurveTimeline {
   constructor(frameCount, bezierCount, propertyId) {
     super(frameCount, bezierCount, propertyId);
   }
@@ -1545,41 +1551,51 @@ var CurveTimeline1 = class extends CurveTimeline {
    * See {@link Timeline.apply}.
    * @param current The current value for the property.
    * @param setup The setup value for the property. */
-  getRelativeValue(time, alpha, fromSetup, add, current, setup) {
-    if (time < this.frames[0]) return fromSetup ? setup : current;
+  getRelativeValue(time, alpha, from, add, current, setup) {
+    if (time < this.frames[0]) return _CurveTimeline1.beforeFirstKey(from, alpha, current, setup);
     const value = this.getCurveValue(time);
-    return fromSetup ? setup + value * alpha : current + (add ? value : value + setup - current) * alpha;
+    return from === 1 /* setup */ ? setup + value * alpha : current + (add ? value : value + setup - current) * alpha;
   }
-  getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value) {
+  getAbsoluteValue(time, alpha, from, add, current, setup, value) {
     if (value === void 0)
-      return this.getAbsoluteValue1(time, alpha, fromSetup, add, current, setup);
+      return this.getAbsoluteValue1(time, alpha, from, add, current, setup);
     else
-      return this.getAbsoluteValue2(time, alpha, fromSetup, add, current, setup, value);
+      return this.getAbsoluteValue2(time, alpha, from, add, current, setup, value);
   }
-  getAbsoluteValue1(time, alpha, fromSetup, add, current, setup) {
-    if (time < this.frames[0]) return fromSetup ? setup : current;
+  getAbsoluteValue1(time, alpha, from, add, current, setup) {
+    if (time < this.frames[0]) return _CurveTimeline1.beforeFirstKey(from, alpha, current, setup);
     const value = this.getCurveValue(time);
-    return fromSetup ? setup + (add ? value : value - setup) * alpha : current + (add ? value : value - current) * alpha;
+    return from === 1 /* setup */ ? setup + (add ? value : value - setup) * alpha : current + (add ? value : value - current) * alpha;
   }
-  getAbsoluteValue2(time, alpha, fromSetup, add, current, setup, value) {
-    if (time < this.frames[0]) return fromSetup ? setup : current;
-    return fromSetup ? setup + (add ? value : value - setup) * alpha : current + (add ? value : value - current) * alpha;
+  getAbsoluteValue2(time, alpha, from, add, current, setup, value) {
+    if (time < this.frames[0]) return _CurveTimeline1.beforeFirstKey(from, alpha, current, setup);
+    return from === 1 /* setup */ ? setup + (add ? value : value - setup) * alpha : current + (add ? value : value - current) * alpha;
   }
   /** Returns the interpolated value for scale properties. The timeline and setup values are multiplied and sign adjusted.
    *
    * See {@link Timeline.apply}.
    * @param current The current value for the property.
    * @param setup The setup value for the property. */
-  getScaleValue(time, alpha, fromSetup, add, out, current, setup) {
-    if (time < this.frames[0]) return fromSetup ? setup : current;
+  getScaleValue(time, alpha, from, add, out, current, setup) {
+    if (time < this.frames[0]) return _CurveTimeline1.beforeFirstKey(from, alpha, current, setup);
     const value = this.getCurveValue(time) * setup;
     if (alpha === 1 && !add) return value;
-    let base = fromSetup ? setup : current;
+    let base = from === 1 /* setup */ ? setup : current;
     if (add) return base + (value - setup) * alpha;
     if (out) return base + (Math.abs(value) * Math.sign(base) - base) * alpha;
     base = Math.abs(base) * Math.sign(value);
     return base + (value - base) * alpha;
   }
+  static beforeFirstKey(from, alpha, current, setup) {
+    switch (from) {
+      case 1 /* setup */:
+        return setup;
+      case 2 /* first */:
+        return current + (setup - current) * alpha;
+      case 0 /* current */:
+        return current;
+    }
+  }
 };
 function isBoneTimeline(obj) {
   return typeof obj === "object" && obj !== null && typeof obj.boneIndex === "number";
@@ -1591,10 +1607,10 @@ var BoneTimeline1 = class extends CurveTimeline1 {
     this.boneIndex = boneIndex;
     this.additive = true;
   }
-  apply(skeleton, lastTime, time, events, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) {
     const bone = skeleton.bones[this.boneIndex];
     if (bone.active)
-      this.apply1(appliedPose ? bone.appliedPose : bone.pose, bone.data.setupPose, time, alpha, fromSetup, add, out);
+      this.apply1(appliedPose ? bone.appliedPose : bone.pose, bone.data.setupPose, time, alpha, from, add, out);
   }
 };
 var BoneTimeline2 = class extends CurveTimeline {
@@ -1624,30 +1640,36 @@ var BoneTimeline2 = class extends CurveTimeline {
       /*VALUE2*/
     ] = value2;
   }
-  apply(skeleton, lastTime, time, events, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) {
     const bone = skeleton.bones[this.boneIndex];
     if (bone.active)
-      this.apply1(appliedPose ? bone.appliedPose : bone.pose, bone.data.setupPose, time, alpha, fromSetup, add, out);
+      this.apply1(appliedPose ? bone.appliedPose : bone.pose, bone.data.setupPose, time, alpha, from, add, out);
   }
 };
 var RotateTimeline = class extends BoneTimeline1 {
   constructor(frameCount, bezierCount, boneIndex) {
     super(frameCount, bezierCount, boneIndex, 0 /* rotate */);
   }
-  apply1(pose, setup, time, alpha, fromSetup, add, out) {
-    pose.rotation = this.getRelativeValue(time, alpha, fromSetup, add, pose.rotation, setup.rotation);
+  apply1(pose, setup, time, alpha, from, add, out) {
+    pose.rotation = this.getRelativeValue(time, alpha, from, add, pose.rotation, setup.rotation);
   }
 };
 var TranslateTimeline = class extends BoneTimeline2 {
   constructor(frameCount, bezierCount, boneIndex) {
     super(frameCount, bezierCount, boneIndex, 1 /* x */, 2 /* y */);
   }
-  apply1(pose, setup, time, alpha, fromSetup, add, out) {
+  apply1(pose, setup, time, alpha, from, add, out) {
     const frames = this.frames;
     if (time < frames[0]) {
-      if (fromSetup) {
-        pose.x = setup.x;
-        pose.y = setup.y;
+      switch (from) {
+        case 1 /* setup */:
+          pose.x = setup.x;
+          pose.y = setup.y;
+          break;
+        case 2 /* first */:
+          pose.x += (setup.x - pose.x) * alpha;
+          pose.y += (setup.y - pose.y) * alpha;
+          break;
       }
       return;
     }
@@ -1713,7 +1735,7 @@ var TranslateTimeline = class extends BoneTimeline2 {
           /*BEZIER*/
         );
     }
-    if (fromSetup) {
+    if (from === 1 /* setup */) {
       pose.x = setup.x + x * alpha;
       pose.y = setup.y + y * alpha;
     } else if (add) {
@@ -1729,28 +1751,34 @@ var TranslateXTimeline = class extends BoneTimeline1 {
   constructor(frameCount, bezierCount, boneIndex) {
     super(frameCount, bezierCount, boneIndex, 1 /* x */);
   }
-  apply1(pose, setup, time, alpha, fromSetup, add, out) {
-    pose.x = this.getRelativeValue(time, alpha, fromSetup, add, pose.x, setup.x);
+  apply1(pose, setup, time, alpha, from, add, out) {
+    pose.x = this.getRelativeValue(time, alpha, from, add, pose.x, setup.x);
   }
 };
 var TranslateYTimeline = class extends BoneTimeline1 {
   constructor(frameCount, bezierCount, boneIndex) {
     super(frameCount, bezierCount, boneIndex, 2 /* y */);
   }
-  apply1(pose, setup, time, alpha, fromSetup, add, out) {
-    pose.y = this.getRelativeValue(time, alpha, fromSetup, add, pose.y, setup.y);
+  apply1(pose, setup, time, alpha, from, add, out) {
+    pose.y = this.getRelativeValue(time, alpha, from, add, pose.y, setup.y);
   }
 };
 var ScaleTimeline = class extends BoneTimeline2 {
   constructor(frameCount, bezierCount, boneIndex) {
     super(frameCount, bezierCount, boneIndex, 3 /* scaleX */, 4 /* scaleY */);
   }
-  apply1(pose, setup, time, alpha, fromSetup, add, out) {
+  apply1(pose, setup, time, alpha, from, add, out) {
     const frames = this.frames;
     if (time < frames[0]) {
-      if (fromSetup) {
-        pose.scaleX = setup.scaleX;
-        pose.scaleY = setup.scaleY;
+      switch (from) {
+        case 1 /* setup */:
+          pose.scaleX = setup.scaleX;
+          pose.scaleY = setup.scaleY;
+          break;
+        case 2 /* first */:
+          pose.scaleX += (setup.scaleX - pose.scaleX) * alpha;
+          pose.scaleY += (setup.scaleY - pose.scaleY) * alpha;
+          break;
       }
       return;
     }
@@ -1823,7 +1851,7 @@ var ScaleTimeline = class extends BoneTimeline2 {
       pose.scaleY = y;
     } else {
       let bx = 0, by = 0;
-      if (fromSetup) {
+      if (from === 1 /* setup */) {
         bx = setup.scaleX;
         by = setup.scaleY;
       } else {
@@ -1849,28 +1877,34 @@ var ScaleXTimeline = class extends BoneTimeline1 {
   constructor(frameCount, bezierCount, boneIndex) {
     super(frameCount, bezierCount, boneIndex, 3 /* scaleX */);
   }
-  apply1(pose, setup, time, alpha, fromSetup, add, out) {
-    pose.scaleX = this.getScaleValue(time, alpha, fromSetup, add, out, pose.scaleX, setup.scaleX);
+  apply1(pose, setup, time, alpha, from, add, out) {
+    pose.scaleX = this.getScaleValue(time, alpha, from, add, out, pose.scaleX, setup.scaleX);
   }
 };
 var ScaleYTimeline = class extends BoneTimeline1 {
   constructor(frameCount, bezierCount, boneIndex) {
     super(frameCount, bezierCount, boneIndex, 4 /* scaleY */);
   }
-  apply1(pose, setup, time, alpha, fromSetup, add, out) {
-    pose.scaleY = this.getScaleValue(time, alpha, fromSetup, add, out, pose.scaleY, setup.scaleY);
+  apply1(pose, setup, time, alpha, from, add, out) {
+    pose.scaleY = this.getScaleValue(time, alpha, from, add, out, pose.scaleY, setup.scaleY);
   }
 };
 var ShearTimeline = class extends BoneTimeline2 {
   constructor(frameCount, bezierCount, boneIndex) {
     super(frameCount, bezierCount, boneIndex, 5 /* shearX */, 6 /* shearY */);
   }
-  apply1(pose, setup, time, alpha, fromSetup, add, out) {
+  apply1(pose, setup, time, alpha, from, add, out) {
     const frames = this.frames;
     if (time < frames[0]) {
-      if (fromSetup) {
-        pose.shearX = setup.shearX;
-        pose.shearY = setup.shearY;
+      switch (from) {
+        case 1 /* setup */:
+          pose.shearX = setup.shearX;
+          pose.shearY = setup.shearY;
+          break;
+        case 2 /* first */:
+          pose.shearX += (setup.shearX - pose.shearX) * alpha;
+          pose.shearY += (setup.shearY - pose.shearY) * alpha;
+          break;
       }
       return;
     }
@@ -1936,7 +1970,7 @@ var ShearTimeline = class extends BoneTimeline2 {
           /*BEZIER*/
         );
     }
-    if (fromSetup) {
+    if (from === 1 /* setup */) {
       pose.shearX = setup.shearX + x * alpha;
       pose.shearY = setup.shearY + y * alpha;
     } else if (add) {
@@ -1952,16 +1986,16 @@ var ShearXTimeline = class extends BoneTimeline1 {
   constructor(frameCount, bezierCount, boneIndex) {
     super(frameCount, bezierCount, boneIndex, 5 /* shearX */);
   }
-  apply1(pose, setup, time, alpha, fromSetup, add, out) {
-    pose.shearX = this.getRelativeValue(time, alpha, fromSetup, add, pose.shearX, setup.shearX);
+  apply1(pose, setup, time, alpha, from, add, out) {
+    pose.shearX = this.getRelativeValue(time, alpha, from, add, pose.shearX, setup.shearX);
   }
 };
 var ShearYTimeline = class extends BoneTimeline1 {
   constructor(frameCount, bezierCount, boneIndex) {
     super(frameCount, bezierCount, boneIndex, 6 /* shearY */);
   }
-  apply1(pose, setup, time, alpha, fromSetup, add, out) {
-    pose.shearY = this.getRelativeValue(time, alpha, fromSetup, add, pose.shearY, setup.shearY);
+  apply1(pose, setup, time, alpha, from, add, out) {
+    pose.shearY = this.getRelativeValue(time, alpha, from, add, pose.shearY, setup.shearY);
   }
 };
 var InheritTimeline = class extends Timeline {
@@ -1985,16 +2019,16 @@ var InheritTimeline = class extends Timeline {
       /*INHERIT*/
     ] = inherit;
   }
-  apply(skeleton, lastTime, time, events, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) {
     const bone = skeleton.bones[this.boneIndex];
     if (!bone.active) return;
     const pose = appliedPose ? bone.appliedPose : bone.pose;
     if (out) {
-      if (fromSetup) pose.inherit = bone.data.setupPose.inherit;
+      if (from !== 0 /* current */) pose.inherit = bone.data.setupPose.inherit;
     } else {
       const frames = this.frames;
       if (time < frames[0]) {
-        if (fromSetup) pose.inherit = bone.data.setupPose.inherit;
+        if (from !== 0 /* current */) pose.inherit = bone.data.setupPose.inherit;
       } else
         pose.inherit = this.frames[
           Timeline.search(
@@ -2014,9 +2048,9 @@ var SlotCurveTimeline = class extends CurveTimeline {
     super(frameCount, bezierCount, ...propertyIds);
     this.slotIndex = slotIndex;
   }
-  apply(skeleton, lastTime, time, events, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) {
     const slot = skeleton.slots[this.slotIndex];
-    if (slot.bone.active) this.apply1(slot, appliedPose ? slot.appliedPose : slot.pose, time, alpha, fromSetup, add);
+    if (slot.bone.active) this.apply1(slot, appliedPose ? slot.appliedPose : slot.pose, time, alpha, from, add);
   }
 };
 var RGBATimeline = class extends SlotCurveTimeline {
@@ -2055,11 +2089,24 @@ var RGBATimeline = class extends SlotCurveTimeline {
       /*A*/
     ] = a;
   }
-  apply1(slot, pose, time, alpha, fromSetup, add) {
+  apply1(slot, pose, time, alpha, from, add) {
     const color = pose.color;
     const frames = this.frames;
     if (time < frames[0]) {
-      if (fromSetup) color.setFromColor(slot.data.setupPose.color);
+      const setup = slot.data.setupPose.color;
+      switch (from) {
+        case 1 /* setup */:
+          color.setFromColor(setup);
+          break;
+        case 2 /* first */:
+          color.add(
+            (setup.r - color.r) * alpha,
+            (setup.g - color.g) * alpha,
+            (setup.b - color.b) * alpha,
+            (setup.a - color.a) * alpha
+          );
+          break;
+      }
       return;
     }
     let r = 0, g = 0, b = 0, a = 0;
@@ -2165,7 +2212,7 @@ var RGBATimeline = class extends SlotCurveTimeline {
     if (alpha === 1)
       color.set(r, g, b, a);
     else {
-      if (fromSetup) {
+      if (from === 1 /* setup */) {
         const setup = slot.data.setupPose.color;
         color.set(
           setup.r + (r - setup.r) * alpha,
@@ -2202,16 +2249,25 @@ var RGBTimeline = class extends SlotCurveTimeline {
       /*B*/
     ] = b;
   }
-  apply1(slot, pose, time, alpha, fromSetup, add) {
+  apply1(slot, pose, time, alpha, from, add) {
     const color = pose.color;
     let r = 0, g = 0, b = 0;
     const frames = this.frames;
     if (time < frames[0]) {
-      if (fromSetup) {
-        const setup = slot.data.setupPose.color;
-        color.r = setup.r;
-        color.g = setup.g;
-        color.b = setup.b;
+      const setup = slot.data.setupPose.color;
+      switch (from) {
+        case 1 /* setup */: {
+          color.r = setup.r;
+          color.g = setup.g;
+          color.b = setup.b;
+          break;
+        }
+        case 2 /* first */: {
+          color.r += (setup.r - color.r) * alpha;
+          color.g += (setup.g - color.g) * alpha;
+          color.b += (setup.b - color.b) * alpha;
+          break;
+        }
       }
       return;
     }
@@ -2293,7 +2349,7 @@ var RGBTimeline = class extends SlotCurveTimeline {
         );
     }
     if (alpha !== 1) {
-      if (fromSetup) {
+      if (from === 1 /* setup */) {
         const setup = slot.data.setupPose.color;
         r = setup.r + (r - setup.r) * alpha;
         g = setup.g + (g - setup.g) * alpha;
@@ -2315,19 +2371,27 @@ var AlphaTimeline = class extends CurveTimeline1 {
     super(frameCount, bezierCount, `${9 /* alpha */}|${slotIndex}`);
     this.slotIndex = slotIndex;
   }
-  apply(skeleton, lastTime, time, events, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) {
     const slot = skeleton.slots[this.slotIndex];
     if (!slot.bone.active) return;
     const color = (appliedPose ? slot.appliedPose : slot.pose).color;
     let a = 0;
     const frames = this.frames;
     if (time < frames[0]) {
-      if (fromSetup) color.a = slot.data.setupPose.color.a;
+      const setup = slot.data.setupPose.color.a;
+      switch (from) {
+        case 1 /* setup */:
+          color.a = setup;
+          break;
+        case 2 /* first */:
+          color.a += (setup - color.a) * alpha;
+          break;
+      }
       return;
     }
     a = this.getCurveValue(time);
     if (alpha !== 1) {
-      if (fromSetup) {
+      if (from === 1 /* setup */) {
         const setup = slot.data.setupPose.color;
         a = setup.a + (a - setup.a) * alpha;
       } else
@@ -2386,18 +2450,33 @@ var RGBA2Timeline = class extends SlotCurveTimeline {
       /*B2*/
     ] = b2;
   }
-  apply1(slot, pose, time, alpha, fromSetup, add) {
+  apply1(slot, pose, time, alpha, from, add) {
     const light = pose.color, dark = pose.darkColor;
     let r2 = 0, g2 = 0, b2 = 0;
     const frames = this.frames;
     if (time < frames[0]) {
-      if (fromSetup) {
-        const setup = slot.data.setupPose;
-        light.setFromColor(setup.color);
-        const setupDark = setup.darkColor;
-        dark.r = setupDark.r;
-        dark.g = setupDark.g;
-        dark.b = setupDark.b;
+      const setup = slot.data.setupPose;
+      const setupLight = setup.color, setupDark = setup.darkColor;
+      switch (from) {
+        case 1 /* setup */: {
+          light.setFromColor(setupLight);
+          dark.r = setupDark.r;
+          dark.g = setupDark.g;
+          dark.b = setupDark.b;
+          break;
+        }
+        case 2 /* first */: {
+          light.add(
+            (setupLight.r - light.r) * alpha,
+            (setupLight.g - light.g) * alpha,
+            (setupLight.b - light.b) * alpha,
+            (setupLight.a - light.a) * alpha
+          );
+          dark.r += (setupDark.r - dark.r) * alpha;
+          dark.g += (setupDark.g - dark.g) * alpha;
+          dark.b += (setupDark.b - dark.b) * alpha;
+          break;
+        }
       }
       return;
     }
@@ -2557,7 +2636,7 @@ var RGBA2Timeline = class extends SlotCurveTimeline {
     }
     if (alpha === 1)
       light.set(r, g, b, a);
-    else if (fromSetup) {
+    else if (from === 1 /* setup */) {
       const setupPose = slot.data.setupPose;
       let setup = setupPose.color;
       light.set(
@@ -2625,20 +2704,30 @@ var RGB2Timeline = class extends SlotCurveTimeline {
       /*B2*/
     ] = b2;
   }
-  apply1(slot, pose, time, alpha, fromSetup, add) {
+  apply1(slot, pose, time, alpha, from, add) {
     const light = pose.color, dark = pose.darkColor;
     let r = 0, g = 0, b = 0, r2 = 0, g2 = 0, b2 = 0;
     const frames = this.frames;
     if (time < frames[0]) {
-      if (fromSetup) {
-        const setup = slot.data.setupPose;
-        const setupLight = setup.color, setupDark = setup.darkColor;
-        light.r = setupLight.r;
-        light.g = setupLight.g;
-        light.b = setupLight.b;
-        dark.r = setupDark.r;
-        dark.g = setupDark.g;
-        dark.b = setupDark.b;
+      const setup = slot.data.setupPose;
+      const setupLight = setup.color, setupDark = setup.darkColor;
+      switch (from) {
+        case 1 /* setup */:
+          light.r = setupLight.r;
+          light.g = setupLight.g;
+          light.b = setupLight.b;
+          dark.r = setupDark.r;
+          dark.g = setupDark.g;
+          dark.b = setupDark.b;
+          break;
+        case 2 /* first */:
+          light.r += (setupLight.r - light.r) * alpha;
+          light.g += (setupLight.g - light.g) * alpha;
+          light.b += (setupLight.b - light.b) * alpha;
+          dark.r += (setupDark.r - dark.r) * alpha;
+          dark.g += (setupDark.g - dark.g) * alpha;
+          dark.b += (setupDark.b - dark.b) * alpha;
+          break;
       }
       return;
     }
@@ -2780,7 +2869,7 @@ var RGB2Timeline = class extends SlotCurveTimeline {
         );
     }
     if (alpha !== 1) {
-      if (fromSetup) {
+      if (from === 1 /* setup */) {
         const setupPose = slot.data.setupPose;
         let setup = setupPose.color;
         r = setup.r + (r - setup.r) * alpha;
@@ -2825,12 +2914,12 @@ var AttachmentTimeline = class extends Timeline {
     this.frames[frame] = time;
     this.attachmentNames[frame] = attachmentName;
   }
-  apply(skeleton, lastTime, time, events, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) {
     const slot = skeleton.slots[this.slotIndex];
     if (!slot.bone.active) return;
     const pose = appliedPose ? slot.appliedPose : slot.pose;
     if (out || time < this.frames[0]) {
-      if (fromSetup) this.setAttachment(skeleton, pose, slot.data.attachmentName);
+      if (from !== 0 /* current */) this.setAttachment(skeleton, pose, slot.data.attachmentName);
     } else
       this.setAttachment(skeleton, pose, this.attachmentNames[Timeline.search(this.frames, time)]);
   }
@@ -2912,15 +3001,15 @@ var DeformTimeline = class extends CurveTimeline {
     const x = curves[n - 2], y = curves[n - 1];
     return y + (1 - y) * (time - x) / (this.frames[frame + this.getFrameEntries()] - x);
   }
-  apply(skeleton, lastTime, time, events, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) {
     const slots = skeleton.slots;
     if (!this.attachment.isTimelineActive(slots, this.slotIndex, appliedPose)) return;
     const timelineSlots = this.attachment.timelineSlots;
     const frames = this.frames;
     if (time < frames[0]) {
-      this.applyBeforeFirst(slots[this.slotIndex], appliedPose, fromSetup);
+      this.applyBeforeFirst(slots[this.slotIndex], appliedPose, alpha, from);
       for (const slotIndex of timelineSlots)
-        this.applyBeforeFirst(slots[slotIndex], appliedPose, fromSetup);
+        this.applyBeforeFirst(slots[slotIndex], appliedPose, alpha, from);
       return;
     }
     let v1, v2;
@@ -2936,17 +3025,49 @@ var DeformTimeline = class extends CurveTimeline {
       v2 = this.vertices[frame + 1];
     }
     const vertexCount = this.vertices[0].length;
-    this.applyToSlot(slots[this.slotIndex], appliedPose, v1, v2, percent, vertexCount, alpha, fromSetup, add);
+    this.applyToSlot(slots[this.slotIndex], appliedPose, v1, v2, percent, vertexCount, alpha, from, add);
     for (const slotIndex of timelineSlots)
-      this.applyToSlot(slots[slotIndex], appliedPose, v1, v2, percent, vertexCount, alpha, fromSetup, add);
+      this.applyToSlot(slots[slotIndex], appliedPose, v1, v2, percent, vertexCount, alpha, from, add);
+  }
+  applyBeforeFirst(slot, appliedPose, alpha, from) {
+    if (!slot.bone.active) return;
+    const pose = appliedPose ? slot.appliedPose : slot.pose;
+    if (pose.attachment == null || pose.attachment.timelineAttachment !== this.attachment) return;
+    const deformArray = pose.deform;
+    if (deformArray.length === 0) from = 1 /* setup */;
+    switch (from) {
+      case 1 /* setup */:
+        deformArray.length = 0;
+        break;
+      case 2 /* first */: {
+        if (alpha === 1) {
+          deformArray.length = 0;
+          return;
+        }
+        const vertexCount = this.vertices[0].length;
+        deformArray.length = vertexCount;
+        const deform = deformArray;
+        const vertexAttachment = pose.attachment;
+        if (vertexAttachment.bones === null) {
+          const setupVertices = vertexAttachment.vertices;
+          for (let i = 0; i < vertexCount; i++)
+            deform[i] += (setupVertices[i] - deform[i]) * alpha;
+        } else {
+          alpha = 1 - alpha;
+          for (let i = 0; i < vertexCount; i++)
+            deform[i] *= alpha;
+        }
+      }
+    }
   }
-  applyToSlot(slot, appliedPose, v1, v2, percent, vertexCount, alpha, fromSetup, add) {
+  applyToSlot(slot, appliedPose, v1, v2, percent, vertexCount, alpha, from, add) {
     if (!slot.bone.active) return;
     const pose = appliedPose ? slot.appliedPose : slot.pose;
     if (pose.attachment === null || pose.attachment.timelineAttachment !== this.attachment) return;
     const vertexAttachment = pose.attachment;
     const deform = pose.deform;
-    if (deform.length === 0) fromSetup = true;
+    if (deform.length === 0) from = 1 /* setup */;
+    const fromSetup = from === 1 /* setup */;
     deform.length = vertexCount;
     if (v2 === null) {
       if (alpha === 1) {
@@ -3042,13 +3163,6 @@ var DeformTimeline = class extends CurveTimeline {
       }
     }
   }
-  applyBeforeFirst(slot, appliedPose, fromSetup) {
-    if (!slot.bone.active) return;
-    const pose = appliedPose ? slot.appliedPose : slot.pose;
-    if (pose.attachment == null || pose.attachment.timelineAttachment !== this.attachment) return;
-    if (pose.deform.length === 0) fromSetup = true;
-    if (fromSetup) pose.deform.length = 0;
-  }
 };
 var SequenceTimeline = class _SequenceTimeline extends Timeline {
   static ENTRIES = 3;
@@ -3057,7 +3171,7 @@ var SequenceTimeline = class _SequenceTimeline extends Timeline {
   slotIndex;
   attachment;
   constructor(frameCount, slotIndex, attachment) {
-    super(frameCount, `${28 /* sequence */}|${slotIndex}|${attachment.sequence.id}`);
+    super(frameCount, `${29 /* sequence */}|${slotIndex}|${attachment.sequence.id}`);
     this.slotIndex = slotIndex;
     this.attachment = attachment;
     this.instant = true;
@@ -3084,13 +3198,13 @@ var SequenceTimeline = class _SequenceTimeline extends Timeline {
     frames[frame + _SequenceTimeline.MODE] = mode | index << 4;
     frames[frame + _SequenceTimeline.DELAY] = delay;
   }
-  apply(skeleton, lastTime, time, events, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) {
     const slots = skeleton.slots;
     if (!this.attachment.isTimelineActive(slots, this.slotIndex, appliedPose)) return;
     const timelineSlots = this.attachment.timelineSlots;
     const frames = this.frames;
     if (out || time < frames[0]) {
-      if (fromSetup) {
+      if (from !== 0 /* current */) {
         this.setupPose(slots[this.slotIndex], appliedPose);
         for (const slotIndex of timelineSlots)
           this.setupPose(slots[slotIndex], appliedPose);
@@ -3166,12 +3280,12 @@ var EventTimeline = class _EventTimeline extends Timeline {
     this.events[frame] = event;
   }
   /** Fires events for frames > `lastTime` and <= `time`. */
-  apply(skeleton, lastTime, time, firedEvents, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) {
     if (!firedEvents) return;
     const frames = this.frames;
     const frameCount = this.frames.length;
     if (lastTime > time) {
-      this.apply(null, lastTime, Number.MAX_VALUE, firedEvents, 0, false, false, false, false);
+      this.apply(null, lastTime, Number.MAX_VALUE, firedEvents, 0, from, false, false, false);
       lastTime = -1;
     } else if (lastTime >= frames[frameCount - 1])
       return;
@@ -3211,11 +3325,11 @@ var DrawOrderTimeline = class _DrawOrderTimeline extends Timeline {
     this.frames[frame] = time;
     this.drawOrders[frame] = drawOrder;
   }
-  apply(skeleton, lastTime, time, firedEvents, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) {
     const pose = appliedPose ? skeleton.drawOrder.appliedPose : skeleton.drawOrder.pose;
     const setup = skeleton.slots;
     if (out || time < this.frames[0]) {
-      if (fromSetup) Utils.arrayCopy(setup, 0, pose, 0, skeleton.slots.length);
+      if (from !== 0 /* current */) Utils.arrayCopy(setup, 0, pose, 0, skeleton.slots.length);
       return;
     }
     const order = this.drawOrders[Timeline.search(this.frames, time)];
@@ -3228,6 +3342,7 @@ var DrawOrderTimeline = class _DrawOrderTimeline extends Timeline {
   }
 };
 var DrawOrderFolderTimeline = class _DrawOrderFolderTimeline extends Timeline {
+  static propertyID = `${15 /* drawOrderFolder */}`;
   slots;
   inFolder;
   drawOrders;
@@ -3246,7 +3361,7 @@ var DrawOrderFolderTimeline = class _DrawOrderFolderTimeline extends Timeline {
     const n = slots.length;
     const ids = new Array(n);
     for (let i = 0; i < n; i++)
-      ids[i] = `d${slots[i]}`;
+      ids[i] = `${_DrawOrderFolderTimeline.propertyID}|${slots[i]}`;
     return ids;
   }
   getFrameCount() {
@@ -3268,11 +3383,11 @@ var DrawOrderFolderTimeline = class _DrawOrderFolderTimeline extends Timeline {
     this.frames[frame] = time;
     this.drawOrders[frame] = drawOrder;
   }
-  apply(skeleton, lastTime, time, events, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, events, alpha, from, add, out, appliedPose) {
     const pose = appliedPose ? skeleton.drawOrder.appliedPose : skeleton.drawOrder.pose;
     const setup = skeleton.slots;
     if (out || time < this.frames[0]) {
-      if (fromSetup) this.setup(pose, setup);
+      if (from !== 0 /* current */) this.setup(pose, setup);
     } else {
       const order = this.drawOrders[Timeline.search(this.frames, time)];
       if (!order)
@@ -3305,7 +3420,7 @@ function isConstraintTimeline(obj) {
 var IkConstraintTimeline = class extends CurveTimeline {
   constraintIndex = 0;
   constructor(frameCount, bezierCount, constraintIndex) {
-    super(frameCount, bezierCount, `${15 /* ikConstraint */}|${constraintIndex}`);
+    super(frameCount, bezierCount, `${16 /* ikConstraint */}|${constraintIndex}`);
     this.constraintIndex = constraintIndex;
   }
   getFrameEntries() {
@@ -3339,19 +3454,30 @@ var IkConstraintTimeline = class extends CurveTimeline {
       /*STRETCH*/
     ] = stretch ? 1 : 0;
   }
-  apply(skeleton, lastTime, time, firedEvents, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) {
     const constraint = skeleton.constraints[this.constraintIndex];
     if (!constraint.active) return;
     const pose = appliedPose ? constraint.appliedPose : constraint.pose;
     const frames = this.frames;
     if (time < frames[0]) {
-      if (fromSetup) {
-        const setup = constraint.data.setupPose;
-        pose.mix = setup.mix;
-        pose.softness = setup.softness;
-        pose.bendDirection = setup.bendDirection;
-        pose.compress = setup.compress;
-        pose.stretch = setup.stretch;
+      const setup = constraint.data.setupPose;
+      switch (from) {
+        case 1 /* setup */: {
+          pose.mix = setup.mix;
+          pose.softness = setup.softness;
+          pose.bendDirection = setup.bendDirection;
+          pose.compress = setup.compress;
+          pose.stretch = setup.stretch;
+          break;
+        }
+        case 2 /* first */: {
+          pose.mix += (setup.mix - pose.mix) * alpha;
+          pose.softness += (setup.softness - pose.softness) * alpha;
+          pose.bendDirection = setup.bendDirection;
+          pose.compress = setup.compress;
+          pose.stretch = setup.stretch;
+          break;
+        }
       }
       return;
     }
@@ -3417,11 +3543,11 @@ var IkConstraintTimeline = class extends CurveTimeline {
           /*BEZIER*/
         );
     }
-    const base = fromSetup ? constraint.data.setupPose : pose;
+    const base = from === 1 /* setup */ ? constraint.data.setupPose : pose;
     pose.mix = base.mix + (mix - base.mix) * alpha;
     pose.softness = base.softness + (softness - base.softness) * alpha;
     if (out) {
-      if (fromSetup) {
+      if (from === 1 /* setup */) {
         pose.bendDirection = base.bendDirection;
         pose.compress = base.compress;
         pose.stretch = base.stretch;
@@ -3446,7 +3572,7 @@ var TransformConstraintTimeline = class extends CurveTimeline {
   /** The index of the transform constraint slot in {@link Skeleton.transformConstraints} that will be changed. */
   constraintIndex = 0;
   constructor(frameCount, bezierCount, constraintIndex) {
-    super(frameCount, bezierCount, `${16 /* transformConstraint */}|${constraintIndex}`);
+    super(frameCount, bezierCount, `${17 /* transformConstraint */}|${constraintIndex}`);
     this.constraintIndex = constraintIndex;
     this.additive = true;
   }
@@ -3485,20 +3611,32 @@ var TransformConstraintTimeline = class extends CurveTimeline {
       /*SHEARY*/
     ] = mixShearY;
   }
-  apply(skeleton, lastTime, time, firedEvents, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) {
     const constraint = skeleton.constraints[this.constraintIndex];
     if (!constraint.active) return;
     const pose = appliedPose ? constraint.appliedPose : constraint.pose;
     const frames = this.frames;
     if (time < frames[0]) {
-      if (fromSetup) {
-        const setup = constraint.data.setupPose;
-        pose.mixRotate = setup.mixRotate;
-        pose.mixX = setup.mixX;
-        pose.mixY = setup.mixY;
-        pose.mixScaleX = setup.mixScaleX;
-        pose.mixScaleY = setup.mixScaleY;
-        pose.mixShearY = setup.mixShearY;
+      const setup = constraint.data.setupPose;
+      switch (from) {
+        case 1 /* setup */: {
+          pose.mixRotate = setup.mixRotate;
+          pose.mixX = setup.mixX;
+          pose.mixY = setup.mixY;
+          pose.mixScaleX = setup.mixScaleX;
+          pose.mixScaleY = setup.mixScaleY;
+          pose.mixShearY = setup.mixShearY;
+          break;
+        }
+        case 2 /* first */: {
+          pose.mixRotate += (setup.mixRotate - pose.mixRotate) * alpha;
+          pose.mixX += (setup.mixX - pose.mixX) * alpha;
+          pose.mixY += (setup.mixY - pose.mixY) * alpha;
+          pose.mixScaleX += (setup.mixScaleX - pose.mixScaleX) * alpha;
+          pose.mixScaleY += (setup.mixScaleY - pose.mixScaleY) * alpha;
+          pose.mixShearY += (setup.mixShearY - pose.mixShearY) * alpha;
+          break;
+        }
       }
       return;
     }
@@ -3640,7 +3778,7 @@ var TransformConstraintTimeline = class extends CurveTimeline {
           /*BEZIER*/
         );
     }
-    const base = fromSetup ? constraint.data.setupPose : pose;
+    const base = from === 1 /* setup */ ? constraint.data.setupPose : pose;
     if (add) {
       pose.mixRotate = base.mixRotate + rotate * alpha;
       pose.mixX = base.mixX + x * alpha;
@@ -3667,29 +3805,29 @@ var ConstraintTimeline1 = class extends CurveTimeline1 {
 };
 var PathConstraintPositionTimeline = class extends ConstraintTimeline1 {
   constructor(frameCount, bezierCount, constraintIndex) {
-    super(frameCount, bezierCount, constraintIndex, 17 /* pathConstraintPosition */);
+    super(frameCount, bezierCount, constraintIndex, 18 /* pathConstraintPosition */);
     this.additive = true;
   }
-  apply(skeleton, lastTime, time, firedEvents, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) {
     const constraint = skeleton.constraints[this.constraintIndex];
     if (constraint.active) {
       const pose = appliedPose ? constraint.appliedPose : constraint.pose;
-      pose.position = this.getAbsoluteValue(time, alpha, fromSetup, add, pose.position, constraint.data.setupPose.position);
+      pose.position = this.getAbsoluteValue(time, alpha, from, add, pose.position, constraint.data.setupPose.position);
     }
   }
 };
 var PathConstraintSpacingTimeline = class extends ConstraintTimeline1 {
   constructor(frameCount, bezierCount, constraintIndex) {
-    super(frameCount, bezierCount, constraintIndex, 18 /* pathConstraintSpacing */);
+    super(frameCount, bezierCount, constraintIndex, 19 /* pathConstraintSpacing */);
   }
-  apply(skeleton, lastTime, time, firedEvents, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) {
     const constraint = skeleton.constraints[this.constraintIndex];
     if (constraint.active) {
       const pose = appliedPose ? constraint.appliedPose : constraint.pose;
       pose.spacing = this.getAbsoluteValue(
         time,
         alpha,
-        fromSetup,
+        from,
         false,
         pose.spacing,
         constraint.data.setupPose.spacing
@@ -3700,7 +3838,7 @@ var PathConstraintSpacingTimeline = class extends ConstraintTimeline1 {
 var PathConstraintMixTimeline = class extends CurveTimeline {
   constraintIndex;
   constructor(frameCount, bezierCount, constraintIndex) {
-    super(frameCount, bezierCount, `${19 /* pathConstraintMix */}|${constraintIndex}`);
+    super(frameCount, bezierCount, `${20 /* pathConstraintMix */}|${constraintIndex}`);
     this.constraintIndex = constraintIndex;
   }
   getFrameEntries() {
@@ -3726,17 +3864,26 @@ var PathConstraintMixTimeline = class extends CurveTimeline {
       /*Y*/
     ] = mixY;
   }
-  apply(skeleton, lastTime, time, firedEvents, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) {
     const constraint = skeleton.constraints[this.constraintIndex];
     if (!constraint.active) return;
     const pose = appliedPose ? constraint.appliedPose : constraint.pose;
     const frames = this.frames;
     if (time < frames[0]) {
-      if (fromSetup) {
-        const setup = constraint.data.setupPose;
-        pose.mixRotate = setup.mixRotate;
-        pose.mixX = setup.mixX;
-        pose.mixY = setup.mixY;
+      const setup = constraint.data.setupPose;
+      switch (from) {
+        case 1 /* setup */: {
+          pose.mixRotate = setup.mixRotate;
+          pose.mixX = setup.mixX;
+          pose.mixY = setup.mixY;
+          break;
+        }
+        case 2 /* first */: {
+          pose.mixRotate += (setup.mixRotate - pose.mixRotate) * alpha;
+          pose.mixX += (setup.mixX - pose.mixX) * alpha;
+          pose.mixY += (setup.mixY - pose.mixY) * alpha;
+          break;
+        }
       }
       return;
     }
@@ -3818,7 +3965,7 @@ var PathConstraintMixTimeline = class extends CurveTimeline {
           /*BEZIER*/
         );
     }
-    const base = fromSetup ? constraint.data.setupPose : pose;
+    const base = from === 1 /* setup */ ? constraint.data.setupPose : pose;
     if (add) {
       pose.mixRotate = base.mixRotate + rotate * alpha;
       pose.mixX = base.mixX + x * alpha;
@@ -3835,7 +3982,7 @@ var PhysicsConstraintTimeline = class extends ConstraintTimeline1 {
   constructor(frameCount, bezierCount, constraintIndex, property) {
     super(frameCount, bezierCount, constraintIndex, property);
   }
-  apply(skeleton, lastTime, time, firedEvents, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) {
     if (add && !this.additive) add = false;
     if (this.constraintIndex === -1) {
       const value = time >= this.frames[0] ? this.getCurveValue(time) : 0;
@@ -3843,21 +3990,21 @@ var PhysicsConstraintTimeline = class extends ConstraintTimeline1 {
       for (const constraint of constraints) {
         if (constraint.active && this.global(constraint.data)) {
           const pose = appliedPose ? constraint.appliedPose : constraint.pose;
-          this.set(pose, this.getAbsoluteValue(time, alpha, fromSetup, add, this.get(pose), this.get(constraint.data.setupPose), value));
+          this.set(pose, this.getAbsoluteValue(time, alpha, from, add, this.get(pose), this.get(constraint.data.setupPose), value));
         }
       }
     } else {
       const constraint = skeleton.constraints[this.constraintIndex];
       if (constraint.active) {
         const pose = appliedPose ? constraint.appliedPose : constraint.pose;
-        this.set(pose, this.getAbsoluteValue(time, alpha, fromSetup, add, this.get(pose), this.get(constraint.data.setupPose)));
+        this.set(pose, this.getAbsoluteValue(time, alpha, from, add, this.get(pose), this.get(constraint.data.setupPose)));
       }
     }
   }
 };
 var PhysicsConstraintInertiaTimeline = class extends PhysicsConstraintTimeline {
   constructor(frameCount, bezierCount, constraintIndex) {
-    super(frameCount, bezierCount, constraintIndex, 20 /* physicsConstraintInertia */);
+    super(frameCount, bezierCount, constraintIndex, 21 /* physicsConstraintInertia */);
   }
   get(pose) {
     return pose.inertia;
@@ -3871,7 +4018,7 @@ var PhysicsConstraintInertiaTimeline = class extends PhysicsConstraintTimeline {
 };
 var PhysicsConstraintStrengthTimeline = class extends PhysicsConstraintTimeline {
   constructor(frameCount, bezierCount, constraintIndex) {
-    super(frameCount, bezierCount, constraintIndex, 21 /* physicsConstraintStrength */);
+    super(frameCount, bezierCount, constraintIndex, 22 /* physicsConstraintStrength */);
   }
   get(pose) {
     return pose.strength;
@@ -3885,7 +4032,7 @@ var PhysicsConstraintStrengthTimeline = class extends PhysicsConstraintTimeline
 };
 var PhysicsConstraintDampingTimeline = class extends PhysicsConstraintTimeline {
   constructor(frameCount, bezierCount, constraintIndex) {
-    super(frameCount, bezierCount, constraintIndex, 22 /* physicsConstraintDamping */);
+    super(frameCount, bezierCount, constraintIndex, 23 /* physicsConstraintDamping */);
   }
   get(pose) {
     return pose.damping;
@@ -3899,7 +4046,7 @@ var PhysicsConstraintDampingTimeline = class extends PhysicsConstraintTimeline {
 };
 var PhysicsConstraintMassTimeline = class extends PhysicsConstraintTimeline {
   constructor(frameCount, bezierCount, constraintIndex) {
-    super(frameCount, bezierCount, constraintIndex, 23 /* physicsConstraintMass */);
+    super(frameCount, bezierCount, constraintIndex, 24 /* physicsConstraintMass */);
   }
   get(pose) {
     return 1 / pose.massInverse;
@@ -3913,7 +4060,7 @@ var PhysicsConstraintMassTimeline = class extends PhysicsConstraintTimeline {
 };
 var PhysicsConstraintWindTimeline = class extends PhysicsConstraintTimeline {
   constructor(frameCount, bezierCount, constraintIndex) {
-    super(frameCount, bezierCount, constraintIndex, 24 /* physicsConstraintWind */);
+    super(frameCount, bezierCount, constraintIndex, 25 /* physicsConstraintWind */);
     this.additive = true;
   }
   get(pose) {
@@ -3928,7 +4075,7 @@ var PhysicsConstraintWindTimeline = class extends PhysicsConstraintTimeline {
 };
 var PhysicsConstraintGravityTimeline = class extends PhysicsConstraintTimeline {
   constructor(frameCount, bezierCount, constraintIndex) {
-    super(frameCount, bezierCount, constraintIndex, 25 /* physicsConstraintGravity */);
+    super(frameCount, bezierCount, constraintIndex, 26 /* physicsConstraintGravity */);
     this.additive = true;
   }
   get(pose) {
@@ -3943,7 +4090,7 @@ var PhysicsConstraintGravityTimeline = class extends PhysicsConstraintTimeline {
 };
 var PhysicsConstraintMixTimeline = class extends PhysicsConstraintTimeline {
   constructor(frameCount, bezierCount, constraintIndex) {
-    super(frameCount, bezierCount, constraintIndex, 26 /* physicsConstraintMix */);
+    super(frameCount, bezierCount, constraintIndex, 27 /* physicsConstraintMix */);
   }
   get(pose) {
     return pose.mix;
@@ -3956,7 +4103,7 @@ var PhysicsConstraintMixTimeline = class extends PhysicsConstraintTimeline {
   }
 };
 var PhysicsConstraintResetTimeline = class _PhysicsConstraintResetTimeline extends Timeline {
-  static propertyIds = [27 /* physicsConstraintReset */.toString()];
+  static propertyIds = [28 /* physicsConstraintReset */.toString()];
   /** The index of the physics constraint in {@link Skeleton.contraints} that will be reset when this timeline is
   * applied, or -1 if all physics constraints in the skeleton will be reset. */
   constraintIndex;
@@ -3975,7 +4122,7 @@ var PhysicsConstraintResetTimeline = class _PhysicsConstraintResetTimeline exten
     this.frames[frame] = time;
   }
   /** Resets the physics constraint when frames > `lastTime` and <= `time`. */
-  apply(skeleton, lastTime, time, firedEvents, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) {
     let constraint;
     if (this.constraintIndex !== -1) {
       constraint = skeleton.constraints[this.constraintIndex];
@@ -3983,7 +4130,7 @@ var PhysicsConstraintResetTimeline = class _PhysicsConstraintResetTimeline exten
     }
     const frames = this.frames;
     if (lastTime > time) {
-      this.apply(skeleton, lastTime, Number.MAX_VALUE, [], alpha, false, false, false, false);
+      this.apply(skeleton, lastTime, Number.MAX_VALUE, [], alpha, from, false, false, false);
       lastTime = -1;
     } else if (lastTime >= frames[frames.length - 1])
       return;
@@ -4001,26 +4148,26 @@ var PhysicsConstraintResetTimeline = class _PhysicsConstraintResetTimeline exten
 };
 var SliderTimeline = class extends ConstraintTimeline1 {
   constructor(frameCount, bezierCount, constraintIndex) {
-    super(frameCount, bezierCount, constraintIndex, 29 /* sliderTime */);
+    super(frameCount, bezierCount, constraintIndex, 30 /* sliderTime */);
   }
-  apply(skeleton, lastTime, time, firedEvents, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) {
     const constraint = skeleton.constraints[this.constraintIndex];
     if (constraint.active) {
       const pose = appliedPose ? constraint.appliedPose : constraint.pose;
-      pose.time = this.getAbsoluteValue(time, alpha, fromSetup, add, pose.time, constraint.data.setupPose.time);
+      pose.time = this.getAbsoluteValue(time, alpha, from, add, pose.time, constraint.data.setupPose.time);
     }
   }
 };
 var SliderMixTimeline = class extends ConstraintTimeline1 {
   constructor(frameCount, bezierCount, constraintIndex) {
-    super(frameCount, bezierCount, constraintIndex, 30 /* sliderMix */);
+    super(frameCount, bezierCount, constraintIndex, 31 /* sliderMix */);
     this.additive = true;
   }
-  apply(skeleton, lastTime, time, firedEvents, alpha, fromSetup, add, out, appliedPose) {
+  apply(skeleton, lastTime, time, firedEvents, alpha, from, add, out, appliedPose) {
     const constraint = skeleton.constraints[this.constraintIndex];
     if (constraint.active) {
       const pose = appliedPose ? constraint.appliedPose : constraint.pose;
-      pose.mix = this.getAbsoluteValue(time, alpha, fromSetup, add, pose.mix, constraint.data.setupPose.mix);
+      pose.mix = this.getAbsoluteValue(time, alpha, from, add, pose.mix, constraint.data.setupPose.mix);
     }
   }
 };
@@ -4041,7 +4188,7 @@ var AnimationState = class _AnimationState {
   events = [];
   listeners = [];
   queue = new EventQueue(this);
-  propertyIds = new StringSet();
+  propertyIds = /* @__PURE__ */ new Map();
   animationsChanged = false;
   trackEntryPool = new Pool(() => new TrackEntry());
   constructor(data) {
@@ -4150,9 +4297,9 @@ var AnimationState = class _AnimationState {
           Utils.webkit602BugfixHelper(alpha);
           const timeline = timelines[ii];
           if (timeline instanceof AttachmentTimeline)
-            this.applyAttachmentTimeline(timeline, skeleton, applyTime, true, true);
+            this.applyAttachmentTimeline(timeline, skeleton, applyTime, 1 /* setup */, true);
           else
-            timeline.apply(skeleton, animationLast, applyTime, applyEvents, alpha, true, false, false, false);
+            timeline.apply(skeleton, animationLast, applyTime, applyEvents, alpha, 1 /* setup */, false, false, false);
         }
       } else {
         const timelineMode = current.timelineMode;
@@ -4162,14 +4309,14 @@ var AnimationState = class _AnimationState {
         if (firstFrame) current.timelinesRotation.length = timelineCount << 1;
         for (let ii = 0; ii < timelineCount; ii++) {
           const timeline = timelines[ii];
-          const fromSetup = (timelineMode[ii] & FIRST) !== 0;
+          const from = timelineMode[ii] & MODE;
           if (!shortestRotation && timeline instanceof RotateTimeline) {
-            this.applyRotateTimeline(timeline, skeleton, applyTime, alpha, fromSetup, current.timelinesRotation, ii << 1, firstFrame);
+            this.applyRotateTimeline(timeline, skeleton, applyTime, alpha, from, current.timelinesRotation, ii << 1, firstFrame);
           } else if (timeline instanceof AttachmentTimeline) {
-            this.applyAttachmentTimeline(timeline, skeleton, applyTime, fromSetup, retainAttachments);
+            this.applyAttachmentTimeline(timeline, skeleton, applyTime, from, retainAttachments);
           } else {
             Utils.webkit602BugfixHelper(alpha);
-            timeline.apply(skeleton, animationLast, applyTime, applyEvents, alpha, fromSetup, add, false, false);
+            timeline.apply(skeleton, animationLast, applyTime, applyEvents, alpha, from, add, false, false);
           }
         }
       }
@@ -4179,7 +4326,7 @@ var AnimationState = class _AnimationState {
       current.nextAnimationLast = animationTime;
       current.nextTrackLast = current.trackTime;
     }
-    const setupState = this.unkeyedState + SETUP;
+    const setupState = this.unkeyedState + ATTACH_SETUP;
     const slots = skeleton.slots;
     for (let i = 0, n = skeleton.slots.length; i < n; i++) {
       const slot = slots[i];
@@ -4217,29 +4364,29 @@ var AnimationState = class _AnimationState {
     for (let i = 0; i < timelineCount; i++) {
       const timeline = timelines[i];
       const mode = timelineMode[i];
+      const mixFrom = mode & MODE;
       let alpha = 0;
       if ((mode & HOLD) !== 0) {
         const holdMix = timelineHoldMix[i];
         alpha = holdMix == null ? alphaHold : alphaHold * (1 - holdMix.mix());
       } else {
-        if (!drawOrder && timeline instanceof DrawOrderTimeline) continue;
+        if (!drawOrder && timeline instanceof DrawOrderTimeline && mixFrom === 0 /* current */) continue;
         alpha = alphaMix;
       }
       from.totalAlpha += alpha;
-      const fromSetup = (mode & FIRST) !== 0;
       if (!shortestRotation && timeline instanceof RotateTimeline) {
-        this.applyRotateTimeline(timeline, skeleton, applyTime, alpha, fromSetup, timelinesRotation, i << 1, firstFrame);
+        this.applyRotateTimeline(timeline, skeleton, applyTime, alpha, mixFrom, timelinesRotation, i << 1, firstFrame);
       } else if (timeline instanceof AttachmentTimeline)
         this.applyAttachmentTimeline(
           timeline,
           skeleton,
           applyTime,
-          fromSetup,
+          mixFrom,
           retainAttachments && alpha >= from.alphaAttachmentThreshold
         );
       else {
-        const out = !drawOrder || !(timeline instanceof DrawOrderTimeline) || !fromSetup;
-        timeline.apply(skeleton, animationLast, applyTime, events, alpha, fromSetup, add, out, false);
+        const out = !drawOrder || !(timeline instanceof DrawOrderTimeline) || mixFrom === 0 /* current */;
+        timeline.apply(skeleton, animationLast, applyTime, events, alpha, mixFrom, add, out, false);
       }
     }
     if (from.reverse && mix < from.eventThreshold) this.eventsReverse(from, animationLast, animationTime);
@@ -4251,10 +4398,10 @@ var AnimationState = class _AnimationState {
   }
   /** Applies the attachment timeline and sets {@link Slot.attachmentState}.
    * @param retain True if the attachment remains after apply, false if temporary for deform timelines. */
-  applyAttachmentTimeline(timeline, skeleton, time, fromSetup, retain) {
+  applyAttachmentTimeline(timeline, skeleton, time, from, retain) {
     const slot = skeleton.slots[timeline.slotIndex];
     if (!slot.bone.active) return;
-    if (!retain && slot.attachmentState === this.unkeyedState + RETAIN) return;
+    if (!retain && slot.attachmentState === this.unkeyedState + ATTACH_RETAIN) return;
     let setup = time < timeline.frames[0];
     let name = null;
     if (!setup) {
@@ -4262,33 +4409,44 @@ var AnimationState = class _AnimationState {
       setup = !retain && name == null;
     }
     if (setup) {
-      if (!fromSetup) return;
+      if (from === 0 /* current */) return;
       name = slot.data.attachmentName;
     }
     slot.pose.setAttachment(name == null ? null : skeleton.getAttachment(slot.data.index, name));
     if (retain)
-      slot.attachmentState = this.unkeyedState + RETAIN;
+      slot.attachmentState = this.unkeyedState + ATTACH_RETAIN;
     else if (!setup)
-      slot.attachmentState = this.unkeyedState + SETUP;
+      slot.attachmentState = this.unkeyedState + ATTACH_SETUP;
   }
   /** Applies the rotate timeline, mixing with the current pose while keeping the same rotation direction chosen as the shortest
    * the first time the mixing was applied. */
-  applyRotateTimeline(timeline, skeleton, time, alpha, fromSetup, timelinesRotation, i, firstFrame) {
+  applyRotateTimeline(timeline, skeleton, time, alpha, from, timelinesRotation, i, firstFrame) {
     if (firstFrame) timelinesRotation[i] = 0;
     if (alpha === 1) {
-      timeline.apply(skeleton, 0, time, null, 1, fromSetup, false, false, false);
+      timeline.apply(skeleton, 0, time, null, 1, from, false, false, false);
       return;
     }
     const bone = skeleton.bones[timeline.boneIndex];
     if (!bone.active) return;
     const pose = bone.pose, setup = bone.data.setupPose;
     const frames = timeline.frames;
+    let r1, r2;
     if (time < frames[0]) {
-      if (fromSetup) pose.rotation = setup.rotation;
-      return;
+      switch (from) {
+        case 1 /* setup */: {
+          pose.rotation = setup.rotation;
+          return;
+        }
+        case 0 /* current */: {
+          return;
+        }
+      }
+      r1 = pose.rotation;
+      r2 = setup.rotation;
+    } else {
+      r1 = from === 1 /* setup */ ? setup.rotation : pose.rotation;
+      r2 = setup.rotation + timeline.getCurveValue(time);
     }
-    const r1 = fromSetup ? setup.rotation : pose.rotation;
-    const r2 = setup.rotation + timeline.getCurveValue(time);
     let total = 0, diff = r2 - r1;
     diff -= Math.ceil(diff / 360 - 0.5) * 360;
     if (diff === 0) {
@@ -4603,57 +4761,72 @@ var AnimationState = class _AnimationState {
     this.animationsChanged = false;
     const tracks = this.tracks;
     for (let i = 0, n = tracks.length; i < n; i++) {
-      let entry = tracks[i];
-      if (!entry) continue;
+      const track = tracks[i];
+      if (!track) continue;
+      let entry = track;
       while (entry.mixingFrom)
         entry = entry.mixingFrom;
       do {
-        this.computeHold(entry);
+        this.computeHold(entry, track);
         entry = entry.mixingTo;
       } while (entry);
     }
     this.propertyIds.clear();
   }
-  computeHold(entry) {
+  computeHold(entry, track) {
     const timelines = entry.animation.timelines;
     const timelinesCount = entry.animation.timelines.length;
     const timelineMode = entry.timelineMode;
     timelineMode.length = timelinesCount;
     const timelineHoldMix = entry.timelineHoldMix;
     timelineHoldMix.length = 0;
-    const propertyIds = this.propertyIds;
     const add = entry.additive, keepHold = entry.keepHold;
     const to = entry.mixingTo;
-    outer:
-      for (let i = 0; i < timelinesCount; i++) {
-        const timeline = timelines[i];
-        const ids = timeline.propertyIds;
-        const first = propertyIds.addAll(ids) && !(timeline instanceof DrawOrderFolderTimeline && propertyIds.contains(DrawOrderTimeline.propertyID));
-        if (add && timeline.additive) {
-          timelineMode[i] = first ? FIRST : SUBSEQUENT;
-          continue;
-        }
-        for (let from = entry.mixingFrom; from != null; from = from.mixingFrom) {
-          if (from.animation.hasTimeline(ids)) {
-            timelineMode[i] = SUBSEQUENT;
-            continue outer;
+    for (let i = 0; i < timelinesCount; i++) {
+      const timeline = timelines[i];
+      const ids = timeline.propertyIds;
+      const from = this.from(track, timeline, ids);
+      if (add && timeline.additive) {
+        timelineMode[i] = from;
+        continue;
+      }
+      let mode;
+      if (to === null || timeline.instant || to.additive && timeline.additive || !to.animation?.hasTimeline(ids))
+        mode = from;
+      else {
+        mode = from | HOLD;
+        for (let next = to.mixingTo; next != null; next = next.mixingTo) {
+          if (next.additive && timeline.additive || !next.animation?.hasTimeline(ids)) {
+            if (next.mixDuration > 0) timelineHoldMix[i] = next;
+            break;
           }
         }
-        let mode;
-        if (to === null || timeline.instant || to.additive && timeline.additive || !to.animation?.hasTimeline(ids))
-          mode = first ? FIRST : SUBSEQUENT;
-        else {
-          mode = first ? HOLD_FIRST : HOLD;
-          for (let next = to.mixingTo; next != null; next = next.mixingTo) {
-            if (next.additive && timeline.additive || !next.animation?.hasTimeline(ids)) {
-              if (next.mixDuration > 0) timelineHoldMix[i] = next;
-              break;
-            }
-          }
+      }
+      if (keepHold) mode = mode & ~HOLD | timelineMode[i] & HOLD;
+      timelineMode[i] = mode;
+    }
+  }
+  from(track, timeline, ids) {
+    const propertyIds = this.propertyIds;
+    let from = SETUP;
+    for (let i = 0, n = ids.length; i < n; i++) {
+      const owner = propertyIds.get(ids[i]);
+      if (owner === void 0) {
+        propertyIds.set(ids[i], track);
+      } else {
+        if (owner !== track) {
+          while (++i < n)
+            if (!propertyIds.has(ids[i])) propertyIds.set(ids[i], track);
+          return CURRENT;
         }
-        if (keepHold) mode = mode & ~HOLD | timelineMode[i] & HOLD;
-        timelineMode[i] = mode;
+        from = FIRST;
       }
+    }
+    if (timeline instanceof DrawOrderFolderTimeline) {
+      const first = propertyIds.get(DrawOrderTimeline.propertyID);
+      if (first != null) return first !== track ? CURRENT : FIRST;
+    }
+    return from;
   }
   /** Returns the track entry for the animation currently playing on the track, or null if no animation is currently playing. */
   getTrack(trackIndex) {
@@ -4778,7 +4951,7 @@ var TrackEntry = class {
    * properties keyed by the animation are set to the setup pose and the track is cleared.
    *
    * Usually you want to use {@link AnimationState.addEmptyAnimation} rather than have the animation
-   * abruptly cease being applied. */
+   * abruptly cease being applied, leaving the current pose. */
   trackEnd = 0;
   /** Multiplier for the delta time when this track entry is updated, causing time for this animation to pass slower or
    * faster. Defaults to 1.
@@ -4862,8 +5035,8 @@ var TrackEntry = class {
     return mix;
   }
   /** For each timeline:
-   * - Bit 0, FIRST: 0 = mix from current pose, 1 = mix from setup pose. Timeline is first to set the property.
-   * - Bit 1, HOLD: 0 = mix out using alphaMix, 1 = apply full alpha to prevent dipping. Timeline is first on its track to
+   * - Bits 0-1: MixFrom.
+   * - Bit 2, HOLD: 0 = mix out using alphaMix, 1 = apply full alpha to prevent dipping. Timeline is first on its track to
    * set the property and the next entry (mixingTo) also sets it. When held, timelineHoldMix's mix controls how the hold fades
    * out (for 3+ entry chains where the chain eventually stops setting the property). */
   timelineMode = [];
@@ -5057,12 +5230,13 @@ var AnimationStateAdapter = class {
   event(entry, event) {
   }
 };
-var SUBSEQUENT = 0;
-var FIRST = 1;
-var HOLD = 2;
-var HOLD_FIRST = 3;
+var CURRENT = 0;
 var SETUP = 1;
-var RETAIN = 2;
+var FIRST = 2;
+var MODE = 3;
+var HOLD = 4;
+var ATTACH_SETUP = 1;
+var ATTACH_RETAIN = 2;
 
 // spine-core/src/AnimationStateData.ts
 var AnimationStateData = class {
@@ -8110,7 +8284,7 @@ var PhysicsConstraintData = class extends ConstraintData {
   gravityGlobal = false;
   /** True when this constraint's mix is controlled by global slider timelines. */
   mixGlobal = false;
-  /** Determines how the {@link BonePose.scaleY} changes when {@link PhysicsConstraintData.scaleX} sets
+  /** Determines how the {@link BonePose.scaleY} changes when {@link BonePose.scaleX} sets
    * {@link BonePose.scaleX}. */
   _scaleYMode = 0 /* None */;
   get scaleYMode() {
@@ -8182,7 +8356,7 @@ var Slider = class _Slider extends Constraint {
     const indices = animation.bones;
     for (let i = 0, n = animation.bones.length; i < n; i++)
       bones[indices[i]].appliedPose.modifyLocal(skeleton);
-    animation.apply(skeleton, p.time, p.time, data.loop, null, p.mix, false, data.additive, false, true);
+    animation.apply(skeleton, p.time, p.time, data.loop, null, p.mix, 0 /* current */, data.additive, false, true);
   }
   sort(skeleton) {
     const bone = this.bone;
@@ -8240,6 +8414,9 @@ var SliderData = class extends ConstraintData {
   offset = 0;
   /** When true and a bone is set, the bone's local transform property is read instead of its world transform. */
   local = false;
+  // Nonessential.
+  /** When a bone is set, the maximum slider time for the bone property range, or 0 if nonessential data was not exported. */
+  max = 0;
   constructor(name) {
     super(name, new SliderPose());
   }
@@ -8922,7 +9099,7 @@ var ToShearY = class extends ToProperty {
       if (additive)
         value -= MathUtils.PI / 2;
       else {
-        value -= by - Math.atan2(bone.c / sx, bone.a / sy);
+        value -= by - Math.atan2(bone.c / sy, bone.a / sx);
         if (value > MathUtils.PI)
           value -= MathUtils.PI2;
         else if (value < -MathUtils.PI)
@@ -8930,8 +9107,8 @@ var ToShearY = class extends ToProperty {
       }
       value = by + value * pose.mixShearY;
       const s = Math.sqrt(b * b + d * d);
-      bone.b = Math.cos(value) * s * sy;
-      bone.d = Math.sin(value) * s * sx;
+      bone.b = Math.cos(value) * s * sx;
+      bone.d = Math.sin(value) * s * sy;
     }
   }
 };
@@ -9211,7 +9388,13 @@ var SkeletonBinary = class {
           data.skinRequired = (flags & 1) !== 0;
           data.loop = (flags & 2) !== 0;
           data.additive = (flags & 4) !== 0;
-          if ((flags & 8) !== 0) data.setupPose.time = input.readFloat();
+          if ((flags & 8) !== 0) {
+            const value = input.readFloat();
+            if (nonessential && (flags & 64) !== 0)
+              data.max = value;
+            else
+              data.setupPose.time = value;
+          }
           if ((flags & 16) !== 0) data.setupPose.mix = (flags & 32) !== 0 ? input.readFloat() : 1;
           if ((flags & 64) !== 0) {
             data.local = (flags & 128) !== 0;
@@ -11636,7 +11819,6 @@ var SkeletonJson = class {
             data.skinRequired = skinRequired;
             data.additive = getValue(constraintMap, "additive", false);
             data.loop = getValue(constraintMap, "loop", false);
-            data.setupPose.time = getValue(constraintMap, "time", 0);
             data.setupPose.mix = getValue(constraintMap, "mix", 1);
             const boneName = constraintMap.bone;
             if (boneName) {
@@ -11648,8 +11830,10 @@ var SkeletonJson = class {
               data.property.offset = getValue(constraintMap, "from", 0) * propertyScale;
               data.offset = getValue(constraintMap, "to", 0);
               data.scale = getValue(constraintMap, "scale", 1) / propertyScale;
+              data.max = getValue(constraintMap, "max", 0);
               data.local = getValue(constraintMap, "local", false);
-            }
+            } else
+              data.setupPose.time = getValue(constraintMap, "time", 0);
             skeletonData.constraints.push(data);
             break;
           }
@@ -12226,7 +12410,7 @@ var SkeletonJson = class {
         let mixRotate = getValue(keyMap, "mixRotate", 1);
         let mixX = getValue(keyMap, "mixX", 1), mixY = getValue(keyMap, "mixY", mixX);
         let mixScaleX = getValue(keyMap, "mixScaleX", 1), mixScaleY = getValue(keyMap, "mixScaleY", 1);
-        const mixShearY = getValue(keyMap, "mixShearY", 1);
+        let mixShearY = getValue(keyMap, "mixShearY", 1);
         for (let frame = 0, bezier = 0; ; frame++) {
           timeline.setFrame(frame, time, mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY);
           const nextMap = timelineMap[frame + 1];
@@ -12254,7 +12438,7 @@ var SkeletonJson = class {
           mixY = mixY2;
           mixScaleX = mixScaleX2;
           mixScaleY = mixScaleY2;
-          mixScaleX = mixScaleX2;
+          mixShearY = mixShearY2;
           keyMap = nextMap;
         }
         timelines.push(timeline);
@@ -15567,6 +15751,8 @@ var SpineCanvas = class {
   }
 };
 export {
+  ATTACH_RETAIN,
+  ATTACH_SETUP,
   AlphaTimeline,
   Animation,
   AnimationState,
@@ -15586,6 +15772,7 @@ export {
   BoneTimeline1,
   BoneTimeline2,
   BoundingBoxAttachment,
+  CURRENT,
   CameraController,
   ClippingAttachment,
   Color,
@@ -15618,7 +15805,6 @@ export {
   FromY,
   GLTexture,
   HOLD,
-  HOLD_FIRST,
   IkConstraint,
   IkConstraintData,
   IkConstraintPose,
@@ -15645,11 +15831,13 @@ export {
   M31,
   M32,
   M33,
+  MODE,
   ManagedWebGLRenderingContext,
   MathUtils,
   Matrix4,
   Mesh,
   MeshAttachment,
+  MixFrom,
   OrthoCamera,
   PathAttachment,
   PathConstraint,
@@ -15683,7 +15871,6 @@ export {
   Pow,
   PowOut,
   Property,
-  RETAIN,
   RGB2Timeline,
   RGBA2Timeline,
   RGBATimeline,
@@ -15693,7 +15880,6 @@ export {
   RotateMode,
   RotateTimeline,
   SETUP,
-  SUBSEQUENT,
   ScaleTimeline,
   ScaleXTimeline,
   ScaleYMode,