@esotericsoftware/spine-webgl 4.3.4 → 4.3.6

package/dist/iife/spine-webgl.js

@@ -21,6 +21,8 @@ var spine = (() => {
   // spine-webgl/src/index.ts
   var index_exports = {};
   __export(index_exports, {
+    ATTACH_RETAIN: () => ATTACH_RETAIN,
+    ATTACH_SETUP: () => ATTACH_SETUP,
     AlphaTimeline: () => AlphaTimeline,
     Animation: () => Animation,
     AnimationState: () => AnimationState,
@@ -40,6 +42,7 @@ var spine = (() => {
     BoneTimeline1: () => BoneTimeline1,
     BoneTimeline2: () => BoneTimeline2,
     BoundingBoxAttachment: () => BoundingBoxAttachment,
+    CURRENT: () => CURRENT,
     CameraController: () => CameraController,
     ClippingAttachment: () => ClippingAttachment,
     Color: () => Color,
@@ -72,7 +75,6 @@ var spine = (() => {
     FromY: () => FromY,
     GLTexture: () => GLTexture,
     HOLD: () => HOLD,
-    HOLD_FIRST: () => HOLD_FIRST,
     IkConstraint: () => IkConstraint,
     IkConstraintData: () => IkConstraintData,
     IkConstraintPose: () => IkConstraintPose,
@@ -99,11 +101,13 @@ var spine = (() => {
     M31: () => M31,
     M32: () => M32,
     M33: () => M33,
+    MODE: () => MODE,
     ManagedWebGLRenderingContext: () => ManagedWebGLRenderingContext,
     MathUtils: () => MathUtils,
     Matrix4: () => Matrix4,
     Mesh: () => Mesh,
     MeshAttachment: () => MeshAttachment,
+    MixFrom: () => MixFrom,
     OrthoCamera: () => OrthoCamera,
     PathAttachment: () => PathAttachment,
     PathConstraint: () => PathConstraint,
@@ -137,7 +141,6 @@ var spine = (() => {
     Pow: () => Pow,
     PowOut: () => PowOut,
     Property: () => Property,
-    RETAIN: () => RETAIN,
     RGB2Timeline: () => RGB2Timeline,
     RGBA2Timeline: () => RGBA2Timeline,
     RGBATimeline: () => RGBATimeline,
@@ -147,7 +150,6 @@ var spine = (() => {
     RotateMode: () => RotateMode,
     RotateTimeline: () => RotateTimeline,
     SETUP: () => SETUP,
-    SUBSEQUENT: () => SUBSEQUENT,
     ScaleTimeline: () => ScaleTimeline,
     ScaleXTimeline: () => ScaleXTimeline,
     ScaleYMode: () => ScaleYMode,
@@ -1530,17 +1532,14 @@ var spine = (() => {
      * @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;
@@ -1548,9 +1547,15 @@ var spine = (() => {
       }
       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";
@@ -1567,28 +1572,31 @@ var spine = (() => {
     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;
@@ -1709,7 +1717,7 @@ var spine = (() => {
       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);
     }
@@ -1772,41 +1780,51 @@ var spine = (() => {
      * 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";
@@ -1818,10 +1836,10 @@ var spine = (() => {
       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 {
@@ -1851,30 +1869,36 @@ var spine = (() => {
         /*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;
       }
@@ -1940,7 +1964,7 @@ var spine = (() => {
             /*BEZIER*/
           );
       }
-      if (fromSetup) {
+      if (from === 1 /* setup */) {
         pose.x = setup.x + x * alpha;
         pose.y = setup.y + y * alpha;
       } else if (add) {
@@ -1956,28 +1980,34 @@ var spine = (() => {
     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;
       }
@@ -2050,7 +2080,7 @@ var spine = (() => {
         pose.scaleY = y;
       } else {
         let bx = 0, by = 0;
-        if (fromSetup) {
+        if (from === 1 /* setup */) {
           bx = setup.scaleX;
           by = setup.scaleY;
         } else {
@@ -2076,28 +2106,34 @@ var spine = (() => {
     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;
       }
@@ -2163,7 +2199,7 @@ var spine = (() => {
             /*BEZIER*/
           );
       }
-      if (fromSetup) {
+      if (from === 1 /* setup */) {
         pose.shearX = setup.shearX + x * alpha;
         pose.shearY = setup.shearY + y * alpha;
       } else if (add) {
@@ -2179,16 +2215,16 @@ var spine = (() => {
     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 {
@@ -2212,16 +2248,16 @@ var spine = (() => {
         /*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(
@@ -2241,9 +2277,9 @@ var spine = (() => {
       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 {
@@ -2282,11 +2318,24 @@ var spine = (() => {
         /*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;
@@ -2392,7 +2441,7 @@ var spine = (() => {
       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,
@@ -2429,16 +2478,25 @@ var spine = (() => {
         /*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;
       }
@@ -2520,7 +2578,7 @@ var spine = (() => {
           );
       }
       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;
@@ -2542,19 +2600,27 @@ var spine = (() => {
       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
@@ -2613,18 +2679,33 @@ var spine = (() => {
         /*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;
       }
@@ -2784,7 +2865,7 @@ var spine = (() => {
       }
       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(
@@ -2852,20 +2933,30 @@ var spine = (() => {
         /*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;
       }
@@ -3007,7 +3098,7 @@ var spine = (() => {
           );
       }
       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;
@@ -3052,12 +3143,12 @@ var spine = (() => {
       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)]);
     }
@@ -3139,15 +3230,15 @@ var spine = (() => {
       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;
@@ -3163,17 +3254,49 @@ var spine = (() => {
         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) {
@@ -3269,13 +3392,6 @@ var spine = (() => {
         }
       }
     }
-    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;
@@ -3284,7 +3400,7 @@ var spine = (() => {
     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;
@@ -3311,13 +3427,13 @@ var spine = (() => {
       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);
@@ -3393,12 +3509,12 @@ var spine = (() => {
       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;
@@ -3438,11 +3554,11 @@ var spine = (() => {
       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)];
@@ -3455,6 +3571,7 @@ var spine = (() => {
     }
   };
   var DrawOrderFolderTimeline = class _DrawOrderFolderTimeline extends Timeline {
+    static propertyID = `${15 /* drawOrderFolder */}`;
     slots;
     inFolder;
     drawOrders;
@@ -3473,7 +3590,7 @@ var spine = (() => {
       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() {
@@ -3495,11 +3612,11 @@ var spine = (() => {
       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)
@@ -3532,7 +3649,7 @@ var spine = (() => {
   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() {
@@ -3566,19 +3683,30 @@ var spine = (() => {
         /*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;
       }
@@ -3644,11 +3772,11 @@ var spine = (() => {
             /*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;
@@ -3673,7 +3801,7 @@ var spine = (() => {
     /** 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;
     }
@@ -3712,20 +3840,32 @@ var spine = (() => {
         /*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;
       }
@@ -3867,7 +4007,7 @@ var spine = (() => {
             /*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;
@@ -3894,29 +4034,29 @@ var spine = (() => {
   };
   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
@@ -3927,7 +4067,7 @@ var spine = (() => {
   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() {
@@ -3953,17 +4093,26 @@ var spine = (() => {
         /*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;
       }
@@ -4045,7 +4194,7 @@ var spine = (() => {
             /*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;
@@ -4062,7 +4211,7 @@ var spine = (() => {
     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;
@@ -4070,21 +4219,21 @@ var spine = (() => {
         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;
@@ -4098,7 +4247,7 @@ var spine = (() => {
   };
   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;
@@ -4112,7 +4261,7 @@ var spine = (() => {
   };
   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;
@@ -4126,7 +4275,7 @@ var spine = (() => {
   };
   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;
@@ -4140,7 +4289,7 @@ var spine = (() => {
   };
   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) {
@@ -4155,7 +4304,7 @@ var spine = (() => {
   };
   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) {
@@ -4170,7 +4319,7 @@ var spine = (() => {
   };
   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;
@@ -4183,7 +4332,7 @@ var spine = (() => {
     }
   };
   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;
@@ -4202,7 +4351,7 @@ var spine = (() => {
       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];
@@ -4210,7 +4359,7 @@ var spine = (() => {
       }
       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;
@@ -4228,26 +4377,26 @@ var spine = (() => {
   };
   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);
       }
     }
   };
@@ -4268,7 +4417,7 @@ var spine = (() => {
     events = [];
     listeners = [];
     queue = new EventQueue(this);
-    propertyIds = new StringSet();
+    propertyIds = /* @__PURE__ */ new Map();
     animationsChanged = false;
     trackEntryPool = new Pool(() => new TrackEntry());
     constructor(data) {
@@ -4377,9 +4526,9 @@ var spine = (() => {
             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;
@@ -4389,14 +4538,14 @@ var spine = (() => {
           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);
             }
           }
         }
@@ -4406,7 +4555,7 @@ var spine = (() => {
         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];
@@ -4444,29 +4593,29 @@ var spine = (() => {
       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);
@@ -4478,10 +4627,10 @@ var spine = (() => {
     }
     /** 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) {
@@ -4489,33 +4638,44 @@ var spine = (() => {
         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) {
@@ -4830,57 +4990,72 @@ var spine = (() => {
       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) {
@@ -5005,7 +5180,7 @@ var spine = (() => {
      * 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.
@@ -5089,8 +5264,8 @@ var spine = (() => {
       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 = [];
@@ -5284,12 +5459,13 @@ var spine = (() => {
     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 {
@@ -8337,7 +8513,7 @@ ${error}` : ""}`);
     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() {
@@ -8409,7 +8585,7 @@ ${error}` : ""}`);
       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;
@@ -8467,6 +8643,9 @@ ${error}` : ""}`);
     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());
     }
@@ -9149,7 +9328,7 @@ ${error}` : ""}`);
         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)
@@ -9157,8 +9336,8 @@ ${error}` : ""}`);
         }
         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;
       }
     }
   };
@@ -9438,7 +9617,13 @@ ${error}` : ""}`);
             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;
@@ -11863,7 +12048,6 @@ ${error}` : ""}`);
               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) {
@@ -11875,8 +12059,10 @@ ${error}` : ""}`);
                 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;
             }
@@ -12453,7 +12639,7 @@ ${error}` : ""}`);
           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];
@@ -12481,7 +12667,7 @@ ${error}` : ""}`);
             mixY = mixY2;
             mixScaleX = mixScaleX2;
             mixScaleY = mixScaleY2;
-            mixScaleX = mixScaleX2;
+            mixShearY = mixShearY2;
             keyMap = nextMap;
           }
           timelines.push(timeline);