@esotericsoftware/spine-webgl 4.2.26 → 4.2.28

package/dist/iife/spine-webgl.js

@@ -103,6 +103,16 @@ var spine = (() => {
     PathConstraintMixTimeline: () => PathConstraintMixTimeline,
     PathConstraintPositionTimeline: () => PathConstraintPositionTimeline,
     PathConstraintSpacingTimeline: () => PathConstraintSpacingTimeline,
+    Physics: () => Physics,
+    PhysicsConstraintDampingTimeline: () => PhysicsConstraintDampingTimeline,
+    PhysicsConstraintGravityTimeline: () => PhysicsConstraintGravityTimeline,
+    PhysicsConstraintInertiaTimeline: () => PhysicsConstraintInertiaTimeline,
+    PhysicsConstraintMassTimeline: () => PhysicsConstraintMassTimeline,
+    PhysicsConstraintMixTimeline: () => PhysicsConstraintMixTimeline,
+    PhysicsConstraintResetTimeline: () => PhysicsConstraintResetTimeline,
+    PhysicsConstraintStrengthTimeline: () => PhysicsConstraintStrengthTimeline,
+    PhysicsConstraintTimeline: () => PhysicsConstraintTimeline,
+    PhysicsConstraintWindTimeline: () => PhysicsConstraintWindTimeline,
     PointAttachment: () => PointAttachment,
     PolygonBatcher: () => PolygonBatcher,
     Pool: () => Pool,
@@ -132,7 +142,7 @@ var spine = (() => {
     ShearTimeline: () => ShearTimeline,
     ShearXTimeline: () => ShearXTimeline,
     ShearYTimeline: () => ShearYTimeline,
-    Skeleton: () => Skeleton,
+    Skeleton: () => Skeleton2,
     SkeletonBinary: () => SkeletonBinary,
     SkeletonBounds: () => SkeletonBounds,
     SkeletonClipping: () => SkeletonClipping,
@@ -310,6 +320,9 @@ var spine = (() => {
     static sinDeg(degrees) {
       return Math.sin(degrees * _MathUtils.degRad);
     }
+    static atan2Deg(y, x) {
+      return Math.atan2(y, x) * _MathUtils.degRad;
+    }
     static signum(value) {
       return value > 0 ? 1 : value < 0 ? -1 : 0;
     }
@@ -337,6 +350,7 @@ var spine = (() => {
   var MathUtils = _MathUtils;
   __publicField(MathUtils, "PI", 3.1415927);
   __publicField(MathUtils, "PI2", _MathUtils.PI * 2);
+  __publicField(MathUtils, "invPI2", 1 / _MathUtils.PI2);
   __publicField(MathUtils, "radiansToDegrees", 180 / _MathUtils.PI);
   __publicField(MathUtils, "radDeg", _MathUtils.radiansToDegrees);
   __publicField(MathUtils, "degreesToRadians", _MathUtils.PI / 180);
@@ -812,7 +826,15 @@ var spine = (() => {
     pathConstraintPosition: 16,
     pathConstraintSpacing: 17,
     pathConstraintMix: 18,
-    sequence: 19
+    physicsConstraintInertia: 19,
+    physicsConstraintStrength: 20,
+    physicsConstraintDamping: 21,
+    physicsConstraintMass: 22,
+    physicsConstraintWind: 23,
+    physicsConstraintGravity: 24,
+    physicsConstraintMix: 25,
+    physicsConstraintReset: 26,
+    sequence: 27
   };
   var Timeline = class {
     propertyIds;
@@ -990,6 +1012,94 @@ var spine = (() => {
         /*BEZIER*/
       );
     }
+    getRelativeValue(time, alpha, blend, current, setup) {
+      if (time < this.frames[0]) {
+        switch (blend) {
+          case 0 /* setup */:
+            return setup;
+          case 1 /* first */:
+            return current + (setup - current) * alpha;
+        }
+        return current;
+      }
+      let value = this.getCurveValue(time);
+      switch (blend) {
+        case 0 /* setup */:
+          return setup + value * alpha;
+        case 1 /* first */:
+        case 2 /* replace */:
+          value += setup - current;
+      }
+      return current + value * alpha;
+    }
+    getAbsoluteValue(time, alpha, blend, current, setup) {
+      if (time < this.frames[0]) {
+        switch (blend) {
+          case 0 /* setup */:
+            return setup;
+          case 1 /* first */:
+            return current + (setup - current) * alpha;
+        }
+        return current;
+      }
+      let value = this.getCurveValue(time);
+      if (blend == 0 /* setup */)
+        return setup + (value - setup) * alpha;
+      return current + (value - current) * alpha;
+    }
+    getAbsoluteValue2(time, alpha, blend, current, setup, value) {
+      if (time < this.frames[0]) {
+        switch (blend) {
+          case 0 /* setup */:
+            return setup;
+          case 1 /* first */:
+            return current + (setup - current) * alpha;
+        }
+        return current;
+      }
+      if (blend == 0 /* setup */)
+        return setup + (value - setup) * alpha;
+      return current + (value - current) * alpha;
+    }
+    getScaleValue(time, alpha, blend, direction, current, setup) {
+      const frames = this.frames;
+      if (time < frames[0]) {
+        switch (blend) {
+          case 0 /* setup */:
+            return setup;
+          case 1 /* first */:
+            return current + (setup - current) * alpha;
+        }
+        return current;
+      }
+      let value = this.getCurveValue(time) * setup;
+      if (alpha == 1) {
+        if (blend == 3 /* add */)
+          return current + value - setup;
+        return value;
+      }
+      if (direction == 1 /* mixOut */) {
+        switch (blend) {
+          case 0 /* setup */:
+            return setup + (Math.abs(value) * MathUtils.signum(setup) - setup) * alpha;
+          case 1 /* first */:
+          case 2 /* replace */:
+            return current + (Math.abs(value) * MathUtils.signum(current) - current) * alpha;
+        }
+      } else {
+        let s = 0;
+        switch (blend) {
+          case 0 /* setup */:
+            s = Math.abs(setup) * MathUtils.signum(value);
+            return s + (value - s) * alpha;
+          case 1 /* first */:
+          case 2 /* replace */:
+            s = Math.abs(current) * MathUtils.signum(value);
+            return s + (value - s) * alpha;
+        }
+      }
+      return current + (value - setup) * alpha;
+    }
   };
   var CurveTimeline2 = class extends CurveTimeline {
     /** @param bezierCount The maximum number of Bezier curves. See {@link #shrink(int)}.
@@ -1024,30 +1134,8 @@ var spine = (() => {
     }
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
       let bone = skeleton.bones[this.boneIndex];
-      if (!bone.active)
-        return;
-      let frames = this.frames;
-      if (time < frames[0]) {
-        switch (blend) {
-          case 0 /* setup */:
-            bone.rotation = bone.data.rotation;
-            return;
-          case 1 /* first */:
-            bone.rotation += (bone.data.rotation - bone.rotation) * alpha;
-        }
-        return;
-      }
-      let r = this.getCurveValue(time);
-      switch (blend) {
-        case 0 /* setup */:
-          bone.rotation = bone.data.rotation + r * alpha;
-          break;
-        case 1 /* first */:
-        case 2 /* replace */:
-          r += bone.data.rotation - bone.rotation;
-        case 3 /* add */:
-          bone.rotation += r * alpha;
-      }
+      if (bone.active)
+        bone.rotation = this.getRelativeValue(time, alpha, blend, bone.rotation, bone.data.rotation);
     }
   };
   var TranslateTimeline = class extends CurveTimeline2 {
@@ -1163,31 +1251,8 @@ var spine = (() => {
     }
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
       let bone = skeleton.bones[this.boneIndex];
-      if (!bone.active)
-        return;
-      let frames = this.frames;
-      if (time < frames[0]) {
-        switch (blend) {
-          case 0 /* setup */:
-            bone.x = bone.data.x;
-            return;
-          case 1 /* first */:
-            bone.x += (bone.data.x - bone.x) * alpha;
-        }
-        return;
-      }
-      let x = this.getCurveValue(time);
-      switch (blend) {
-        case 0 /* setup */:
-          bone.x = bone.data.x + x * alpha;
-          break;
-        case 1 /* first */:
-        case 2 /* replace */:
-          bone.x += (bone.data.x + x - bone.x) * alpha;
-          break;
-        case 3 /* add */:
-          bone.x += x * alpha;
-      }
+      if (bone.active)
+        bone.x = this.getRelativeValue(time, alpha, blend, bone.x, bone.data.x);
     }
   };
   var TranslateYTimeline = class extends CurveTimeline1 {
@@ -1198,31 +1263,8 @@ var spine = (() => {
     }
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
       let bone = skeleton.bones[this.boneIndex];
-      if (!bone.active)
-        return;
-      let frames = this.frames;
-      if (time < frames[0]) {
-        switch (blend) {
-          case 0 /* setup */:
-            bone.y = bone.data.y;
-            return;
-          case 1 /* first */:
-            bone.y += (bone.data.y - bone.y) * alpha;
-        }
-        return;
-      }
-      let y = this.getCurveValue(time);
-      switch (blend) {
-        case 0 /* setup */:
-          bone.y = bone.data.y + y * alpha;
-          break;
-        case 1 /* first */:
-        case 2 /* replace */:
-          bone.y += (bone.data.y + y - bone.y) * alpha;
-          break;
-        case 3 /* add */:
-          bone.y += y * alpha;
-      }
+      if (bone.active)
+        bone.y = this.getRelativeValue(time, alpha, blend, bone.y, bone.data.y);
     }
   };
   var ScaleTimeline = class extends CurveTimeline2 {
@@ -1376,57 +1418,8 @@ var spine = (() => {
     }
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
       let bone = skeleton.bones[this.boneIndex];
-      if (!bone.active)
-        return;
-      let frames = this.frames;
-      if (time < frames[0]) {
-        switch (blend) {
-          case 0 /* setup */:
-            bone.scaleX = bone.data.scaleX;
-            return;
-          case 1 /* first */:
-            bone.scaleX += (bone.data.scaleX - bone.scaleX) * alpha;
-        }
-        return;
-      }
-      let x = this.getCurveValue(time) * bone.data.scaleX;
-      if (alpha == 1) {
-        if (blend == 3 /* add */)
-          bone.scaleX += x - bone.data.scaleX;
-        else
-          bone.scaleX = x;
-      } else {
-        let bx = 0;
-        if (direction == 1 /* mixOut */) {
-          switch (blend) {
-            case 0 /* setup */:
-              bx = bone.data.scaleX;
-              bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
-              break;
-            case 1 /* first */:
-            case 2 /* replace */:
-              bx = bone.scaleX;
-              bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
-              break;
-            case 3 /* add */:
-              bone.scaleX += (x - bone.data.scaleX) * alpha;
-          }
-        } else {
-          switch (blend) {
-            case 0 /* setup */:
-              bx = Math.abs(bone.data.scaleX) * MathUtils.signum(x);
-              bone.scaleX = bx + (x - bx) * alpha;
-              break;
-            case 1 /* first */:
-            case 2 /* replace */:
-              bx = Math.abs(bone.scaleX) * MathUtils.signum(x);
-              bone.scaleX = bx + (x - bx) * alpha;
-              break;
-            case 3 /* add */:
-              bone.scaleX += (x - bone.data.scaleX) * alpha;
-          }
-        }
-      }
+      if (bone.active)
+        bone.scaleX = this.getScaleValue(time, alpha, blend, direction, bone.scaleX, bone.data.scaleX);
     }
   };
   var ScaleYTimeline = class extends CurveTimeline1 {
@@ -1437,57 +1430,8 @@ var spine = (() => {
     }
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
       let bone = skeleton.bones[this.boneIndex];
-      if (!bone.active)
-        return;
-      let frames = this.frames;
-      if (time < frames[0]) {
-        switch (blend) {
-          case 0 /* setup */:
-            bone.scaleY = bone.data.scaleY;
-            return;
-          case 1 /* first */:
-            bone.scaleY += (bone.data.scaleY - bone.scaleY) * alpha;
-        }
-        return;
-      }
-      let y = this.getCurveValue(time) * bone.data.scaleY;
-      if (alpha == 1) {
-        if (blend == 3 /* add */)
-          bone.scaleY += y - bone.data.scaleY;
-        else
-          bone.scaleY = y;
-      } else {
-        let by = 0;
-        if (direction == 1 /* mixOut */) {
-          switch (blend) {
-            case 0 /* setup */:
-              by = bone.data.scaleY;
-              bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
-              break;
-            case 1 /* first */:
-            case 2 /* replace */:
-              by = bone.scaleY;
-              bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
-              break;
-            case 3 /* add */:
-              bone.scaleY += (y - bone.data.scaleY) * alpha;
-          }
-        } else {
-          switch (blend) {
-            case 0 /* setup */:
-              by = Math.abs(bone.data.scaleY) * MathUtils.signum(y);
-              bone.scaleY = by + (y - by) * alpha;
-              break;
-            case 1 /* first */:
-            case 2 /* replace */:
-              by = Math.abs(bone.scaleY) * MathUtils.signum(y);
-              bone.scaleY = by + (y - by) * alpha;
-              break;
-            case 3 /* add */:
-              bone.scaleY += (y - bone.data.scaleY) * alpha;
-          }
-        }
-      }
+      if (bone.active)
+        bone.scaleY = this.getScaleValue(time, alpha, blend, direction, bone.scaleX, bone.data.scaleY);
     }
   };
   var ShearTimeline = class extends CurveTimeline2 {
@@ -1603,31 +1547,8 @@ var spine = (() => {
     }
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
       let bone = skeleton.bones[this.boneIndex];
-      if (!bone.active)
-        return;
-      let frames = this.frames;
-      if (time < frames[0]) {
-        switch (blend) {
-          case 0 /* setup */:
-            bone.shearX = bone.data.shearX;
-            return;
-          case 1 /* first */:
-            bone.shearX += (bone.data.shearX - bone.shearX) * alpha;
-        }
-        return;
-      }
-      let x = this.getCurveValue(time);
-      switch (blend) {
-        case 0 /* setup */:
-          bone.shearX = bone.data.shearX + x * alpha;
-          break;
-        case 1 /* first */:
-        case 2 /* replace */:
-          bone.shearX += (bone.data.shearX + x - bone.shearX) * alpha;
-          break;
-        case 3 /* add */:
-          bone.shearX += x * alpha;
-      }
+      if (bone.active)
+        bone.shearX = this.getRelativeValue(time, alpha, blend, bone.shearX, bone.data.shearX);
     }
   };
   var ShearYTimeline = class extends CurveTimeline1 {
@@ -1638,31 +1559,8 @@ var spine = (() => {
     }
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
       let bone = skeleton.bones[this.boneIndex];
-      if (!bone.active)
-        return;
-      let frames = this.frames;
-      if (time < frames[0]) {
-        switch (blend) {
-          case 0 /* setup */:
-            bone.shearY = bone.data.shearY;
-            return;
-          case 1 /* first */:
-            bone.shearY += (bone.data.shearY - bone.shearY) * alpha;
-        }
-        return;
-      }
-      let y = this.getCurveValue(time);
-      switch (blend) {
-        case 0 /* setup */:
-          bone.shearY = bone.data.shearY + y * alpha;
-          break;
-        case 1 /* first */:
-        case 2 /* replace */:
-          bone.shearY += (bone.data.shearY + y - bone.shearY) * alpha;
-          break;
-        case 3 /* add */:
-          bone.shearY += y * alpha;
-      }
+      if (bone.active)
+        bone.shearY = this.getRelativeValue(time, alpha, blend, bone.shearX, bone.data.shearY);
     }
   };
   var RGBATimeline = class extends CurveTimeline {
@@ -2838,13 +2736,13 @@ var spine = (() => {
   var DrawOrderTimeline = _DrawOrderTimeline;
   __publicField(DrawOrderTimeline, "propertyIds", ["" + Property.drawOrder]);
   var IkConstraintTimeline = class extends CurveTimeline {
-    /** The index of the IK constraint slot in {@link Skeleton#ikConstraints} that will be changed. */
-    ikConstraintIndex = 0;
+    /** The index of the IK constraint in {@link Skeleton#getIkConstraints()} that will be changed when this timeline is */
+    constraintIndex = 0;
     constructor(frameCount, bezierCount, ikConstraintIndex) {
       super(frameCount, bezierCount, [
         Property.ikConstraint + "|" + ikConstraintIndex
       ]);
-      this.ikConstraintIndex = ikConstraintIndex;
+      this.constraintIndex = ikConstraintIndex;
     }
     getFrameEntries() {
       return 6;
@@ -2875,7 +2773,7 @@ var spine = (() => {
       ] = stretch ? 1 : 0;
     }
     apply(skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
-      let constraint = skeleton.ikConstraints[this.ikConstraintIndex];
+      let constraint = skeleton.ikConstraints[this.constraintIndex];
       if (!constraint.active)
         return;
       let frames = this.frames;
@@ -3001,12 +2899,12 @@ var spine = (() => {
   };
   var TransformConstraintTimeline = class extends CurveTimeline {
     /** The index of the transform constraint slot in {@link Skeleton#transformConstraints} that will be changed. */
-    transformConstraintIndex = 0;
+    constraintIndex = 0;
     constructor(frameCount, bezierCount, transformConstraintIndex) {
       super(frameCount, bezierCount, [
         Property.transformConstraint + "|" + transformConstraintIndex
       ]);
-      this.transformConstraintIndex = transformConstraintIndex;
+      this.constraintIndex = transformConstraintIndex;
     }
     getFrameEntries() {
       return 7;
@@ -3042,7 +2940,7 @@ var spine = (() => {
       ] = mixShearY;
     }
     apply(skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
-      let constraint = skeleton.transformConstraints[this.transformConstraintIndex];
+      let constraint = skeleton.transformConstraints[this.constraintIndex];
       if (!constraint.active)
         return;
       let frames = this.frames;
@@ -3223,71 +3121,42 @@ var spine = (() => {
     }
   };
   var PathConstraintPositionTimeline = class extends CurveTimeline1 {
-    /** The index of the path constraint slot in {@link Skeleton#pathConstraints} that will be changed. */
-    pathConstraintIndex = 0;
+    /** The index of the path constraint in {@link Skeleton#getPathConstraints()} that will be changed when this timeline is
+     * applied. */
+    constraintIndex = 0;
     constructor(frameCount, bezierCount, pathConstraintIndex) {
       super(frameCount, bezierCount, Property.pathConstraintPosition + "|" + pathConstraintIndex);
-      this.pathConstraintIndex = pathConstraintIndex;
+      this.constraintIndex = pathConstraintIndex;
     }
     apply(skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
-      let constraint = skeleton.pathConstraints[this.pathConstraintIndex];
-      if (!constraint.active)
-        return;
-      let frames = this.frames;
-      if (time < frames[0]) {
-        switch (blend) {
-          case 0 /* setup */:
-            constraint.position = constraint.data.position;
-            return;
-          case 1 /* first */:
-            constraint.position += (constraint.data.position - constraint.position) * alpha;
-        }
-        return;
-      }
-      let position = this.getCurveValue(time);
-      if (blend == 0 /* setup */)
-        constraint.position = constraint.data.position + (position - constraint.data.position) * alpha;
-      else
-        constraint.position += (position - constraint.position) * alpha;
+      let constraint = skeleton.pathConstraints[this.constraintIndex];
+      if (constraint.active)
+        constraint.position = this.getAbsoluteValue(time, alpha, blend, constraint.position, constraint.data.position);
     }
   };
   var PathConstraintSpacingTimeline = class extends CurveTimeline1 {
-    /** The index of the path constraint slot in {@link Skeleton#getPathConstraints()} that will be changed. */
-    pathConstraintIndex = 0;
+    /** The index of the path constraint in {@link Skeleton#getPathConstraints()} that will be changed when this timeline is
+     * applied. */
+    constraintIndex = 0;
     constructor(frameCount, bezierCount, pathConstraintIndex) {
       super(frameCount, bezierCount, Property.pathConstraintSpacing + "|" + pathConstraintIndex);
-      this.pathConstraintIndex = pathConstraintIndex;
+      this.constraintIndex = pathConstraintIndex;
     }
     apply(skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
-      let constraint = skeleton.pathConstraints[this.pathConstraintIndex];
-      if (!constraint.active)
-        return;
-      let frames = this.frames;
-      if (time < frames[0]) {
-        switch (blend) {
-          case 0 /* setup */:
-            constraint.spacing = constraint.data.spacing;
-            return;
-          case 1 /* first */:
-            constraint.spacing += (constraint.data.spacing - constraint.spacing) * alpha;
-        }
-        return;
-      }
-      let spacing = this.getCurveValue(time);
-      if (blend == 0 /* setup */)
-        constraint.spacing = constraint.data.spacing + (spacing - constraint.data.spacing) * alpha;
-      else
-        constraint.spacing += (spacing - constraint.spacing) * alpha;
+      let constraint = skeleton.pathConstraints[this.constraintIndex];
+      if (constraint.active)
+        constraint.spacing = this.getAbsoluteValue(time, alpha, blend, constraint.spacing, constraint.data.spacing);
     }
   };
   var PathConstraintMixTimeline = class extends CurveTimeline {
-    /** The index of the path constraint slot in {@link Skeleton#getPathConstraints()} that will be changed. */
-    pathConstraintIndex = 0;
+    /** The index of the path constraint in {@link Skeleton#getPathConstraints()} that will be changed when this timeline is
+     * applied. */
+    constraintIndex = 0;
     constructor(frameCount, bezierCount, pathConstraintIndex) {
       super(frameCount, bezierCount, [
         Property.pathConstraintMix + "|" + pathConstraintIndex
       ]);
-      this.pathConstraintIndex = pathConstraintIndex;
+      this.constraintIndex = pathConstraintIndex;
     }
     getFrameEntries() {
       return 4;
@@ -3310,7 +3179,7 @@ var spine = (() => {
       ] = mixY;
     }
     apply(skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
-      let constraint = skeleton.pathConstraints[this.pathConstraintIndex];
+      let constraint = skeleton.pathConstraints[this.constraintIndex];
       if (!constraint.active)
         return;
       let frames = this.frames;
@@ -3417,6 +3286,196 @@ var spine = (() => {
       }
     }
   };
+  var PhysicsConstraintTimeline = class extends CurveTimeline1 {
+    /** The index of the physics constraint in {@link Skeleton#getPhysicsConstraints()} that will be changed when this timeline
+     * is applied, or -1 if all physics constraints in the skeleton will be changed. */
+    constraintIndex = 0;
+    /** @param physicsConstraintIndex -1 for all physics constraints in the skeleton. */
+    constructor(frameCount, bezierCount, physicsConstraintIndex, property) {
+      super(frameCount, bezierCount, property + "|" + physicsConstraintIndex);
+      this.constraintIndex = physicsConstraintIndex;
+    }
+    apply(skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
+      let constraint;
+      if (this.constraintIndex == -1) {
+        const value = time >= this.frames[0] ? this.getCurveValue(time) : 0;
+        for (const constraint2 of skeleton.physicsConstraints) {
+          if (constraint2.active && this.global(constraint2.data))
+            this.set(constraint2, this.getAbsoluteValue2(time, alpha, blend, this.get(constraint2), this.setup(constraint2), value));
+        }
+      } else {
+        constraint = skeleton.physicsConstraints[this.constraintIndex];
+        if (constraint.active)
+          this.set(constraint, this.getAbsoluteValue(time, alpha, blend, this.get(constraint), this.setup(constraint)));
+      }
+    }
+  };
+  var PhysicsConstraintInertiaTimeline = class extends PhysicsConstraintTimeline {
+    constructor(frameCount, bezierCount, physicsConstraintIndex, property) {
+      super(frameCount, bezierCount, physicsConstraintIndex, Property.physicsConstraintInertia);
+    }
+    setup(constraint) {
+      return constraint.data.inertia;
+    }
+    get(constraint) {
+      return constraint.inertia;
+    }
+    set(constraint, value) {
+      constraint.inertia = value;
+    }
+    global(constraint) {
+      return constraint.inertiaGlobal;
+    }
+  };
+  var PhysicsConstraintStrengthTimeline = class extends PhysicsConstraintTimeline {
+    constructor(frameCount, bezierCount, physicsConstraintIndex, property) {
+      super(frameCount, bezierCount, physicsConstraintIndex, Property.physicsConstraintStrength);
+    }
+    setup(constraint) {
+      return constraint.data.strength;
+    }
+    get(constraint) {
+      return constraint.strength;
+    }
+    set(constraint, value) {
+      constraint.strength = value;
+    }
+    global(constraint) {
+      return constraint.strengthGlobal;
+    }
+  };
+  var PhysicsConstraintDampingTimeline = class extends PhysicsConstraintTimeline {
+    constructor(frameCount, bezierCount, physicsConstraintIndex, property) {
+      super(frameCount, bezierCount, physicsConstraintIndex, Property.physicsConstraintDamping);
+    }
+    setup(constraint) {
+      return constraint.data.damping;
+    }
+    get(constraint) {
+      return constraint.damping;
+    }
+    set(constraint, value) {
+      constraint.damping = value;
+    }
+    global(constraint) {
+      return constraint.dampingGlobal;
+    }
+  };
+  var PhysicsConstraintMassTimeline = class extends PhysicsConstraintTimeline {
+    constructor(frameCount, bezierCount, physicsConstraintIndex, property) {
+      super(frameCount, bezierCount, physicsConstraintIndex, Property.physicsConstraintMass);
+    }
+    setup(constraint) {
+      return 1 / constraint.data.massInverse;
+    }
+    get(constraint) {
+      return 1 / constraint.massInverse;
+    }
+    set(constraint, value) {
+      constraint.massInverse = 1 / value;
+    }
+    global(constraint) {
+      return constraint.massGlobal;
+    }
+  };
+  var PhysicsConstraintWindTimeline = class extends PhysicsConstraintTimeline {
+    constructor(frameCount, bezierCount, physicsConstraintIndex, property) {
+      super(frameCount, bezierCount, physicsConstraintIndex, Property.physicsConstraintWind);
+    }
+    setup(constraint) {
+      return constraint.data.wind;
+    }
+    get(constraint) {
+      return constraint.wind;
+    }
+    set(constraint, value) {
+      constraint.wind = value;
+    }
+    global(constraint) {
+      return constraint.windGlobal;
+    }
+  };
+  var PhysicsConstraintGravityTimeline = class extends PhysicsConstraintTimeline {
+    constructor(frameCount, bezierCount, physicsConstraintIndex, property) {
+      super(frameCount, bezierCount, physicsConstraintIndex, Property.physicsConstraintGravity);
+    }
+    setup(constraint) {
+      return constraint.data.gravity;
+    }
+    get(constraint) {
+      return constraint.gravity;
+    }
+    set(constraint, value) {
+      constraint.gravity = value;
+    }
+    global(constraint) {
+      return constraint.gravityGlobal;
+    }
+  };
+  var PhysicsConstraintMixTimeline = class extends PhysicsConstraintTimeline {
+    constructor(frameCount, bezierCount, physicsConstraintIndex, property) {
+      super(frameCount, bezierCount, physicsConstraintIndex, Property.physicsConstraintMix);
+    }
+    setup(constraint) {
+      return constraint.data.mix;
+    }
+    get(constraint) {
+      return constraint.mix;
+    }
+    set(constraint, value) {
+      constraint.mix = value;
+    }
+    global(constraint) {
+      return constraint.mixGlobal;
+    }
+  };
+  var _PhysicsConstraintResetTimeline = class extends Timeline {
+    /** The index of the physics constraint in {@link Skeleton#getPhysicsConstraints()} that will be reset when this timeline is
+    * applied, or -1 if all physics constraints in the skeleton will be reset. */
+    constraintIndex;
+    /** @param physicsConstraintIndex -1 for all physics constraints in the skeleton. */
+    constructor(frameCount, physicsConstraintIndex) {
+      super(frameCount, _PhysicsConstraintResetTimeline.propertyIds);
+      this.constraintIndex = physicsConstraintIndex;
+    }
+    getFrameCount() {
+      return this.frames.length;
+    }
+    /** Sets the time for the specified frame.
+     * @param frame Between 0 and <code>frameCount</code>, inclusive. */
+    setFrame(frame, time) {
+      this.frames[frame] = time;
+    }
+    /** Resets the physics constraint when frames > <code>lastTime</code> and <= <code>time</code>. */
+    apply(skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
+      let constraint;
+      if (this.constraintIndex != -1) {
+        constraint = skeleton.physicsConstraints[this.constraintIndex];
+        if (!constraint.active)
+          return;
+      }
+      const frames = this.frames;
+      if (lastTime > time) {
+        this.apply(skeleton, lastTime, Number.MAX_VALUE, [], alpha, blend, direction);
+        lastTime = -1;
+      } else if (lastTime >= frames[frames.length - 1])
+        return;
+      if (time < frames[0])
+        return;
+      if (lastTime < frames[0] || time >= frames[Timeline.search1(frames, lastTime) + 1]) {
+        if (constraint != null)
+          constraint.reset();
+        else {
+          for (const constraint2 of skeleton.physicsConstraints) {
+            if (constraint2.active)
+              constraint2.reset();
+          }
+        }
+      }
+    }
+  };
+  var PhysicsConstraintResetTimeline = _PhysicsConstraintResetTimeline;
+  __publicField(PhysicsConstraintResetTimeline, "propertyIds", [Property.physicsConstraintReset.toString()]);
   var _SequenceTimeline = class extends Timeline {
     slotIndex;
     attachment;
@@ -3623,11 +3682,12 @@ var spine = (() => {
           continue;
         applied = true;
         let blend = i2 == 0 ? 1 /* first */ : current.mixBlend;
-        let mix = current.alpha;
+        let alpha = current.alpha;
         if (current.mixingFrom)
-          mix *= this.applyMixingFrom(current, skeleton, blend);
+          alpha *= this.applyMixingFrom(current, skeleton, blend);
         else if (current.trackTime >= current.trackEnd && !current.next)
-          mix = 0;
+          alpha = 0;
+        let attachments = alpha >= current.alphaAttachmentThreshold;
         let animationLast = current.animationLast, animationTime = current.getAnimationTime(), applyTime = animationTime;
         let applyEvents = events;
         if (current.reverse) {
@@ -3636,14 +3696,16 @@ var spine = (() => {
         }
         let timelines = current.animation.timelines;
         let timelineCount = timelines.length;
-        if (i2 == 0 && mix == 1 || blend == 3 /* add */) {
+        if (i2 == 0 && alpha == 1 || blend == 3 /* add */) {
+          if (i2 == 0)
+            attachments = true;
           for (let ii = 0; ii < timelineCount; ii++) {
-            Utils.webkit602BugfixHelper(mix, blend);
+            Utils.webkit602BugfixHelper(alpha, blend);
             var timeline = timelines[ii];
             if (timeline instanceof AttachmentTimeline)
-              this.applyAttachmentTimeline(timeline, skeleton, applyTime, blend, true);
+              this.applyAttachmentTimeline(timeline, skeleton, applyTime, blend, attachments);
             else
-              timeline.apply(skeleton, animationLast, applyTime, applyEvents, mix, blend, 0 /* mixIn */);
+              timeline.apply(skeleton, animationLast, applyTime, applyEvents, alpha, blend, 0 /* mixIn */);
           }
         } else {
           let timelineMode = current.timelineMode;
@@ -3655,12 +3717,12 @@ var spine = (() => {
             let timeline2 = timelines[ii];
             let timelineBlend = timelineMode[ii] == SUBSEQUENT ? blend : 0 /* setup */;
             if (!shortestRotation && timeline2 instanceof RotateTimeline) {
-              this.applyRotateTimeline(timeline2, skeleton, applyTime, mix, timelineBlend, current.timelinesRotation, ii << 1, firstFrame);
+              this.applyRotateTimeline(timeline2, skeleton, applyTime, alpha, timelineBlend, current.timelinesRotation, ii << 1, firstFrame);
             } else if (timeline2 instanceof AttachmentTimeline) {
-              this.applyAttachmentTimeline(timeline2, skeleton, applyTime, blend, true);
+              this.applyAttachmentTimeline(timeline2, skeleton, applyTime, blend, attachments);
             } else {
-              Utils.webkit602BugfixHelper(mix, blend);
-              timeline2.apply(skeleton, animationLast, applyTime, applyEvents, mix, timelineBlend, 0 /* mixIn */);
+              Utils.webkit602BugfixHelper(alpha, blend);
+              timeline2.apply(skeleton, animationLast, applyTime, applyEvents, alpha, timelineBlend, 0 /* mixIn */);
             }
           }
         }
@@ -3698,7 +3760,7 @@ var spine = (() => {
         if (blend != 1 /* first */)
           blend = from.mixBlend;
       }
-      let attachments = mix < from.attachmentThreshold, drawOrder = mix < from.drawOrderThreshold;
+      let attachments = mix < from.mixAttachmentThreshold, drawOrder = mix < from.mixDrawOrderThreshold;
       let timelines = from.animation.timelines;
       let timelineCount = timelines.length;
       let alphaHold = from.alpha * to.interruptAlpha, alphaMix = alphaHold * (1 - mix);
@@ -3753,7 +3815,7 @@ var spine = (() => {
           if (!shortestRotation && timeline instanceof RotateTimeline)
             this.applyRotateTimeline(timeline, skeleton, applyTime, alpha, timelineBlend, from.timelinesRotation, i << 1, firstFrame);
           else if (timeline instanceof AttachmentTimeline)
-            this.applyAttachmentTimeline(timeline, skeleton, applyTime, timelineBlend, attachments);
+            this.applyAttachmentTimeline(timeline, skeleton, applyTime, timelineBlend, attachments && alpha >= from.alphaAttachmentThreshold);
           else {
             Utils.webkit602BugfixHelper(alpha, blend);
             if (drawOrder && timeline instanceof DrawOrderTimeline && timelineBlend == 0 /* setup */)
@@ -3813,7 +3875,7 @@ var spine = (() => {
         r2 = bone.data.rotation + timeline.getCurveValue(time);
       }
       let total = 0, diff = r2 - r1;
-      diff -= (16384 - (16384.499999999996 - diff / 360 | 0)) * 360;
+      diff -= Math.ceil(diff / 360 - 0.5) * 360;
       if (diff == 0) {
         total = timelinesRotation[i];
       } else {
@@ -4070,8 +4132,9 @@ var spine = (() => {
       entry.reverse = false;
       entry.shortestRotation = false;
       entry.eventThreshold = 0;
-      entry.attachmentThreshold = 0;
-      entry.drawOrderThreshold = 0;
+      entry.alphaAttachmentThreshold = 0;
+      entry.mixAttachmentThreshold = 0;
+      entry.mixDrawOrderThreshold = 0;
       entry.animationStart = 0;
       entry.animationEnd = animation.duration;
       entry.animationLast = -1;
@@ -4229,11 +4292,14 @@ var spine = (() => {
     /** When the mix percentage ({@link #mixtime} / {@link #mixDuration}) is less than the
      * `attachmentThreshold`, attachment timelines are applied while this animation is being mixed out. Defaults to
      * 0, so attachment timelines are not applied while this animation is being mixed out. */
-    attachmentThreshold = 0;
-    /** When the mix percentage ({@link #mixTime} / {@link #mixDuration}) is less than the
-     * `drawOrderThreshold`, draw order timelines are applied while this animation is being mixed out. Defaults to 0,
-     * so draw order timelines are not applied while this animation is being mixed out. */
-    drawOrderThreshold = 0;
+    mixAttachmentThreshold = 0;
+    /** When {@link #getAlpha()} is greater than <code>alphaAttachmentThreshold</code>, attachment timelines are applied.
+     * Defaults to 0, so attachment timelines are always applied. */
+    alphaAttachmentThreshold = 0;
+    /** When the mix percentage ({@link #getMixTime()} / {@link #getMixDuration()}) is less than the
+     * <code>mixDrawOrderThreshold</code>, draw order timelines are applied while this animation is being mixed out. Defaults to
+     * 0, so draw order timelines are not applied while this animation is being mixed out. */
+    mixDrawOrderThreshold = 0;
     /** Seconds when this animation starts, both initially and after looping. Defaults to 0.
      *
      * When changing the `animationStart` time, it often makes sense to set {@link #animationLast} to the same
@@ -4303,9 +4369,18 @@ var spine = (() => {
      * When using {@link AnimationState#addAnimation()} with a `delay` <= 0, note the
      * {@link #delay} is set using the mix duration from the {@link AnimationStateData}, not a mix duration set
      * afterward. */
-    mixDuration = 0;
+    _mixDuration = 0;
     interruptAlpha = 0;
     totalAlpha = 0;
+    get mixDuration() {
+      return this._mixDuration;
+    }
+    set mixDuration(mixDuration) {
+      this._mixDuration = mixDuration;
+      if (this.previous != null && this.delay <= 0)
+        this.delay += this.previous.getTrackComplete() - mixDuration;
+      this.delay = this.delay;
+    }
     /** Controls how properties keyed in the animation are mixed with lower tracks. Defaults to {@link MixBlend#replace}, which
      * replaces the values from the lower tracks with the animation values. {@link MixBlend#add} adds the animation values to
      * the values from the lower tracks.
@@ -4369,6 +4444,12 @@ var spine = (() => {
       }
       return this.trackTime;
     }
+    /** Returns true if this track entry has been applied at least once.
+     * <p>
+     * See {@link AnimationState#apply(Skeleton)}. */
+    wasApplied() {
+      return this.nextTrackLast != -1;
+    }
   };
   var EventQueue = class {
     objects = [];
@@ -5069,10 +5150,10 @@ var spine = (() => {
       return point;
     }
     computeWorldRotation(bone) {
-      let cos = MathUtils.cosDeg(this.rotation), sin = MathUtils.sinDeg(this.rotation);
-      let x = cos * bone.a + sin * bone.b;
-      let y = cos * bone.c + sin * bone.d;
-      return Math.atan2(y, x) * MathUtils.radDeg;
+      const r = this.rotation * MathUtils.degRad, cos = Math.cos(r), sin = Math.sin(r);
+      const x = cos * bone.a + sin * bone.b;
+      const y = cos * bone.c + sin * bone.d;
+      return MathUtils.atan2Deg(y, x);
     }
     copy() {
       let copy = new PointAttachment(this.name);
@@ -5139,7 +5220,7 @@ var spine = (() => {
       let localY = -this.height / 2 * this.scaleY + this.region.offsetY * regionScaleY;
       let localX2 = localX + this.region.width * regionScaleX;
       let localY2 = localY + this.region.height * regionScaleY;
-      let radians = this.rotation * Math.PI / 180;
+      let radians = this.rotation * MathUtils.degRad;
       let cos = Math.cos(radians);
       let sin = Math.sin(radians);
       let x = this.x, y = this.y;
@@ -5335,7 +5416,7 @@ var spine = (() => {
     x = 0;
     /** The local y translation. */
     y = 0;
-    /** The local rotation. */
+    /** The local rotation in degrees, counter clockwise. */
     rotation = 0;
     /** The local scaleX. */
     scaleX = 1;
@@ -5354,6 +5435,10 @@ var spine = (() => {
     /** The color of the bone as it was in Spine. Available only when nonessential data was exported. Bones are not usually
      * rendered at runtime. */
     color = new Color();
+    /** The bone icon as it was in Spine, or null if nonessential data was not exported. */
+    icon;
+    /** False if the bone was hidden in Spine and nonessential data was exported. Does not affect runtime rendering. */
+    visible = false;
     constructor(index, name, parent) {
       if (index < 0)
         throw new Error("index must be >= 0.");
@@ -5442,7 +5527,7 @@ var spine = (() => {
       return this.active;
     }
     /** Computes the world transform using the parent bone and this bone's local applied transform. */
-    update() {
+    update(physics) {
       this.updateWorldTransformWith(this.ax, this.ay, this.arotation, this.ascaleX, this.ascaleY, this.ashearX, this.ashearY);
     }
     /** Computes the world transform using the parent bone and this bone's local transform.
@@ -5467,13 +5552,13 @@ var spine = (() => {
       let parent = this.parent;
       if (!parent) {
         let skeleton = this.skeleton;
-        let rotationY = rotation + 90 + shearY;
-        let sx = skeleton.scaleX;
-        let sy = skeleton.scaleY;
-        this.a = MathUtils.cosDeg(rotation + shearX) * scaleX * sx;
-        this.b = MathUtils.cosDeg(rotationY) * scaleY * sx;
-        this.c = MathUtils.sinDeg(rotation + shearX) * scaleX * sy;
-        this.d = MathUtils.sinDeg(rotationY) * scaleY * sy;
+        const sx = skeleton.scaleX, sy = skeleton.scaleY;
+        const rx = (rotation + shearX) * MathUtils.degRad;
+        const ry = (rotation + 90 + shearY) * MathUtils.degRad;
+        this.a = Math.cos(rx) * scaleX * sx;
+        this.b = Math.cos(ry) * scaleY * sx;
+        this.c = Math.sin(rx) * scaleX * sy;
+        this.d = Math.sin(ry) * scaleY * sy;
         this.worldX = x * sx + skeleton.x;
         this.worldY = y * sy + skeleton.y;
         return;
@@ -5483,11 +5568,12 @@ var spine = (() => {
       this.worldY = pc * x + pd * y + parent.worldY;
       switch (this.data.transformMode) {
         case 0 /* Normal */: {
-          let rotationY = rotation + 90 + shearY;
-          let la = MathUtils.cosDeg(rotation + shearX) * scaleX;
-          let lb = MathUtils.cosDeg(rotationY) * scaleY;
-          let lc = MathUtils.sinDeg(rotation + shearX) * scaleX;
-          let ld = MathUtils.sinDeg(rotationY) * scaleY;
+          const rx = (rotation + shearX) * MathUtils.degRad;
+          const ry = (rotation + 90 + shearY) * MathUtils.degRad;
+          const la = Math.cos(rx) * scaleX;
+          const lb = Math.cos(ry) * scaleY;
+          const lc = Math.sin(rx) * scaleX;
+          const ld = Math.sin(ry) * scaleY;
           this.a = pa * la + pb * lc;
           this.b = pa * lb + pb * ld;
           this.c = pc * la + pd * lc;
@@ -5495,11 +5581,12 @@ var spine = (() => {
           return;
         }
         case 1 /* OnlyTranslation */: {
-          let rotationY = rotation + 90 + shearY;
-          this.a = MathUtils.cosDeg(rotation + shearX) * scaleX;
-          this.b = MathUtils.cosDeg(rotationY) * scaleY;
-          this.c = MathUtils.sinDeg(rotation + shearX) * scaleX;
-          this.d = MathUtils.sinDeg(rotationY) * scaleY;
+          const rx = (rotation + shearX) * MathUtils.degRad;
+          const ry = (rotation + 90 + shearY) * MathUtils.degRad;
+          this.a = Math.cos(rx) * scaleX;
+          this.b = Math.cos(ry) * scaleY;
+          this.c = Math.sin(rx) * scaleX;
+          this.d = Math.sin(ry) * scaleY;
           break;
         }
         case 2 /* NoRotationOrReflection */: {
@@ -5517,12 +5604,12 @@ var spine = (() => {
             pc = 0;
             prx = 90 - Math.atan2(pd, pb) * MathUtils.radDeg;
           }
-          let rx = rotation + shearX - prx;
-          let ry = rotation + shearY - prx + 90;
-          let la = MathUtils.cosDeg(rx) * scaleX;
-          let lb = MathUtils.cosDeg(ry) * scaleY;
-          let lc = MathUtils.sinDeg(rx) * scaleX;
-          let ld = MathUtils.sinDeg(ry) * scaleY;
+          const rx = (rotation + shearX - prx) * MathUtils.degRad;
+          const ry = (rotation + shearY - prx + 90) * MathUtils.degRad;
+          const la = Math.cos(rx) * scaleX;
+          const lb = Math.cos(ry) * scaleY;
+          const lc = Math.sin(rx) * scaleX;
+          const ld = Math.sin(ry) * scaleY;
           this.a = pa * la - pb * lc;
           this.b = pa * lb - pb * ld;
           this.c = pc * la + pd * lc;
@@ -5531,8 +5618,8 @@ var spine = (() => {
         }
         case 3 /* NoScale */:
         case 4 /* NoScaleOrReflection */: {
-          let cos = MathUtils.cosDeg(rotation);
-          let sin = MathUtils.sinDeg(rotation);
+          rotation *= MathUtils.degRad;
+          const cos = Math.cos(rotation), sin = Math.sin(rotation);
           let za = (pa * cos + pb * sin) / this.skeleton.scaleX;
           let zc = (pc * cos + pd * sin) / this.skeleton.scaleY;
           let s = Math.sqrt(za * za + zc * zc);
@@ -5543,13 +5630,15 @@ var spine = (() => {
           s = Math.sqrt(za * za + zc * zc);
           if (this.data.transformMode == 3 /* NoScale */ && pa * pd - pb * pc < 0 != (this.skeleton.scaleX < 0 != this.skeleton.scaleY < 0))
             s = -s;
-          let r = Math.PI / 2 + Math.atan2(zc, za);
-          let zb = Math.cos(r) * s;
-          let zd = Math.sin(r) * s;
-          let la = MathUtils.cosDeg(shearX) * scaleX;
-          let lb = MathUtils.cosDeg(90 + shearY) * scaleY;
-          let lc = MathUtils.sinDeg(shearX) * scaleX;
-          let ld = MathUtils.sinDeg(90 + shearY) * scaleY;
+          rotation = Math.PI / 2 + Math.atan2(zc, za);
+          const zb = Math.cos(rotation) * s;
+          const zd = Math.sin(rotation) * s;
+          shearX *= MathUtils.degRad;
+          shearY = (90 + shearY) * MathUtils.degRad;
+          const la = Math.cos(shearX) * scaleX;
+          const lb = Math.cos(shearY) * scaleY;
+          const lc = Math.sin(shearX) * scaleX;
+          const ld = Math.sin(shearY) * scaleY;
           this.a = za * la + zb * lc;
           this.b = za * lb + zb * ld;
           this.c = zc * la + zd * lc;
@@ -5573,22 +5662,6 @@ var spine = (() => {
       this.shearX = data.shearX;
       this.shearY = data.shearY;
     }
-    /** The world rotation for the X axis, calculated using {@link #a} and {@link #c}. */
-    getWorldRotationX() {
-      return Math.atan2(this.c, this.a) * MathUtils.radDeg;
-    }
-    /** The world rotation for the Y axis, calculated using {@link #b} and {@link #d}. */
-    getWorldRotationY() {
-      return Math.atan2(this.d, this.b) * MathUtils.radDeg;
-    }
-    /** The magnitude (always positive) of the world scale X, calculated using {@link #a} and {@link #c}. */
-    getWorldScaleX() {
-      return Math.sqrt(this.a * this.a + this.c * this.c);
-    }
-    /** The magnitude (always positive) of the world scale Y, calculated using {@link #b} and {@link #d}. */
-    getWorldScaleY() {
-      return Math.sqrt(this.b * this.b + this.d * this.d);
-    }
     /** Computes the applied transform values from the world transform.
      *
      * If the world transform is modified (by a constraint, {@link #rotateWorld(float)}, etc) then this method should be called so
@@ -5675,6 +5748,22 @@ var spine = (() => {
         this.arotation = 90 - Math.atan2(rd, rb) * MathUtils.radDeg;
       }
     }
+    /** The world rotation for the X axis, calculated using {@link #a} and {@link #c}. */
+    getWorldRotationX() {
+      return Math.atan2(this.c, this.a) * MathUtils.radDeg;
+    }
+    /** The world rotation for the Y axis, calculated using {@link #b} and {@link #d}. */
+    getWorldRotationY() {
+      return Math.atan2(this.d, this.b) * MathUtils.radDeg;
+    }
+    /** The magnitude (always positive) of the world scale X, calculated using {@link #a} and {@link #c}. */
+    getWorldScaleX() {
+      return Math.sqrt(this.a * this.a + this.c * this.c);
+    }
+    /** The magnitude (always positive) of the world scale Y, calculated using {@link #b} and {@link #d}. */
+    getWorldScaleY() {
+      return Math.sqrt(this.b * this.b + this.d * this.d);
+    }
     /** Transforms a point from world coordinates to the bone's local coordinates. */
     worldToLocal(world) {
       let invDet = 1 / (this.a * this.d - this.b * this.c);
@@ -5690,6 +5779,18 @@ var spine = (() => {
       local.y = x * this.c + y * this.d + this.worldY;
       return local;
     }
+    /** Transforms a point from world coordinates to the parent bone's local coordinates. */
+    worldToParent(world) {
+      if (world == null)
+        throw new Error("world cannot be null.");
+      return this.parent == null ? world : this.parent.worldToLocal(world);
+    }
+    /** Transforms a point from the parent bone's coordinates to world coordinates. */
+    parentToWorld(world) {
+      if (world == null)
+        throw new Error("world cannot be null.");
+      return this.parent == null ? world : this.parent.localToWorld(world);
+    }
     /** Transforms a world rotation to a local rotation. */
     worldToLocalRotation(worldRotation) {
       let sin = MathUtils.sinDeg(worldRotation), cos = MathUtils.cosDeg(worldRotation);
@@ -5703,15 +5804,16 @@ var spine = (() => {
     }
     /** Rotates the world transform the specified amount.
      * <p>
-     * After changes are made to the world transform, {@link #updateAppliedTransform()} should be called and {@link #update()} will
-     * need to be called on any child bones, recursively. */
+     * After changes are made to the world transform, {@link #updateAppliedTransform()} should be called and
+     * {@link #update(Physics)} will need to be called on any child bones, recursively. */
     rotateWorld(degrees) {
-      let a = this.a, b = this.b, c = this.c, d = this.d;
-      let cos = MathUtils.cosDeg(degrees), sin = MathUtils.sinDeg(degrees);
-      this.a = cos * a - sin * c;
-      this.b = cos * b - sin * d;
-      this.c = sin * a + cos * c;
-      this.d = sin * b + cos * d;
+      degrees *= MathUtils.degRad;
+      const sin = Math.sin(degrees), cos = Math.cos(degrees);
+      const ra = this.a, rb = this.b;
+      this.a = cos * ra - sin * this.c;
+      this.b = cos * rb - sin * this.d;
+      this.c = sin * ra + cos * this.c;
+      this.d = sin * rb + cos * this.d;
     }
   };
 
@@ -6101,7 +6203,15 @@ var spine = (() => {
     isActive() {
       return this.active;
     }
-    update() {
+    setToSetupPose() {
+      const data = this.data;
+      this.mix = data.mix;
+      this.softness = data.softness;
+      this.bendDirection = data.bendDirection;
+      this.compress = data.compress;
+      this.stretch = data.stretch;
+    }
+    update(physics) {
       if (this.mix == 0)
         return;
       let target = this.target;
@@ -6160,12 +6270,15 @@ var spine = (() => {
             tx = targetX - bone.worldX;
             ty = targetY - bone.worldY;
         }
-        let b = bone.data.length * sx, dd = Math.sqrt(tx * tx + ty * ty);
-        if (compress && dd < b || stretch && dd > b && b > 1e-4) {
-          let s = (dd / b - 1) * alpha + 1;
-          sx *= s;
-          if (uniform)
-            sy *= s;
+        const b = bone.data.length * sx;
+        if (b > 1e-4) {
+          const dd = tx * tx + ty * ty;
+          if (compress && dd < b * b || stretch && dd > b * b) {
+            const s = (Math.sqrt(dd) / b - 1) * alpha + 1;
+            sx *= s;
+            if (uniform)
+              sy *= s;
+          }
         }
       }
       bone.updateWorldTransformWith(
@@ -6466,7 +6579,15 @@ var spine = (() => {
     isActive() {
       return this.active;
     }
-    update() {
+    setToSetupPose() {
+      const data = this.data;
+      this.position = data.position;
+      this.spacing = data.spacing;
+      this.mixRotate = data.mixRotate;
+      this.mixX = data.mixX;
+      this.mixY = data.mixY;
+    }
+    update(physics) {
       let attachment = this.target.getAttachment();
       if (!(attachment instanceof PathAttachment))
         return;
@@ -6485,12 +6606,8 @@ var spine = (() => {
             for (let i = 0, n = spacesCount - 1; i < n; i++) {
               let bone = bones[i];
               let setupLength = bone.data.length;
-              if (setupLength < _PathConstraint.epsilon)
-                lengths[i] = 0;
-              else {
-                let x = setupLength * bone.a, y = setupLength * bone.c;
-                lengths[i] = Math.sqrt(x * x + y * y);
-              }
+              let x = setupLength * bone.a, y = setupLength * bone.c;
+              lengths[i] = Math.sqrt(x * x + y * y);
             }
           }
           Utils.arrayFill(spaces, 1, spacesCount, spacing);
@@ -6865,6 +6982,238 @@ var spine = (() => {
   __publicField(PathConstraint, "AFTER", -3);
   __publicField(PathConstraint, "epsilon", 1e-5);
 
+  // spine-core/src/PhysicsConstraint.ts
+  var PhysicsConstraint = class {
+    data;
+    _bone = null;
+    /** The bone constrained by this physics constraint. */
+    set bone(bone) {
+      this._bone = bone;
+    }
+    get bone() {
+      if (!this._bone)
+        throw new Error("Bone not set.");
+      else
+        return this._bone;
+    }
+    inertia = 0;
+    strength = 0;
+    damping = 0;
+    massInverse = 0;
+    wind = 0;
+    gravity = 0;
+    mix = 0;
+    _reset = true;
+    ux = 0;
+    uy = 0;
+    cx = 0;
+    cy = 0;
+    tx = 0;
+    ty = 0;
+    xOffset = 0;
+    xVelocity = 0;
+    yOffset = 0;
+    yVelocity = 0;
+    rotateOffset = 0;
+    rotateVelocity = 0;
+    scaleOffset = 0;
+    scaleVelocity = 0;
+    active = false;
+    skeleton;
+    remaining = 0;
+    lastTime = 0;
+    constructor(data, skeleton) {
+      this.data = data;
+      this.skeleton = skeleton;
+      this.bone = skeleton.bones[data.bone.index];
+      this.inertia = data.inertia;
+      this.strength = data.strength;
+      this.damping = data.damping;
+      this.massInverse = data.massInverse;
+      this.wind = data.wind;
+      this.gravity = data.gravity;
+      this.mix = data.mix;
+    }
+    reset() {
+      this.remaining = 0;
+      this.lastTime = this.skeleton.time;
+      this._reset = true;
+      this.xOffset = 0;
+      this.xVelocity = 0;
+      this.yOffset = 0;
+      this.yVelocity = 0;
+      this.rotateOffset = 0;
+      this.rotateVelocity = 0;
+      this.scaleOffset = 0;
+      this.scaleVelocity = 0;
+    }
+    setToSetupPose() {
+      const data = this.data;
+      this.inertia = data.inertia;
+      this.strength = data.strength;
+      this.damping = data.damping;
+      this.massInverse = data.massInverse;
+      this.wind = data.wind;
+      this.gravity = data.gravity;
+      this.mix = data.mix;
+    }
+    isActive() {
+      return this.active;
+    }
+    /** Applies the constraint to the constrained bones. */
+    update(physics) {
+      const mix = this.mix;
+      if (mix == 0)
+        return;
+      const x = this.data.x > 0, y = this.data.y > 0, rotateOrShearX = this.data.rotate > 0 || this.data.shearX > 0, scaleX = this.data.scaleX > 0;
+      const bone = this.bone;
+      const l = bone.data.length;
+      switch (physics) {
+        case 0 /* none */:
+          return;
+        case 1 /* reset */:
+          this.reset();
+        case 2 /* update */:
+          this.remaining += Math.max(this.skeleton.time - this.lastTime, 0);
+          this.lastTime = this.skeleton.time;
+          const bx = bone.worldX, by = bone.worldY;
+          if (this._reset) {
+            this._reset = false;
+            this.ux = bx;
+            this.uy = by;
+          } else {
+            let remaining = this.remaining, i = this.inertia, step = this.data.step;
+            if (x || y) {
+              if (x) {
+                this.xOffset += (this.ux - bx) * i;
+                this.ux = bx;
+              }
+              if (y) {
+                this.yOffset += (this.uy - by) * i;
+                this.uy = by;
+              }
+              if (remaining >= step) {
+                const m = this.massInverse * step, e = this.strength, w = this.wind * 100, g = this.gravity * -100;
+                const d = Math.pow(this.damping, 60 * step);
+                do {
+                  if (x) {
+                    this.xVelocity += (w - this.xOffset * e) * m;
+                    this.xOffset += this.xVelocity * step;
+                    this.xVelocity *= d;
+                  }
+                  if (y) {
+                    this.yVelocity += (g - this.yOffset * e) * m;
+                    this.yOffset += this.yVelocity * step;
+                    this.yVelocity *= d;
+                  }
+                  remaining -= step;
+                } while (remaining >= step);
+              }
+              if (x)
+                bone.worldX += this.xOffset * mix * this.data.x;
+              if (y)
+                bone.worldY += this.yOffset * mix * this.data.y;
+            }
+            if (rotateOrShearX || scaleX) {
+              let ca = Math.atan2(bone.c, bone.a), c = 0, s = 0, mr = 0;
+              if (rotateOrShearX) {
+                mr = mix * this.data.rotate;
+                let dx = this.cx - bone.worldX, dy = this.cy - bone.worldY, r = Math.atan2(dy + this.ty, dx + this.tx) - ca - this.rotateOffset * mr;
+                this.rotateOffset += (r - Math.ceil(r * MathUtils.invPI2 - 0.5) * MathUtils.PI2) * i;
+                r = this.rotateOffset * mr + ca;
+                c = Math.cos(r);
+                s = Math.sin(r);
+                if (scaleX) {
+                  r = l * bone.getWorldScaleX();
+                  if (r > 0)
+                    this.scaleOffset += (dx * c + dy * s) * i / r;
+                }
+              } else {
+                c = Math.cos(ca);
+                s = Math.sin(ca);
+                const r = l * bone.getWorldScaleX();
+                if (r > 0)
+                  this.scaleOffset += ((this.cx - bone.worldX) * c + (this.cy - bone.worldY) * s) * i / r;
+              }
+              remaining = this.remaining;
+              if (remaining >= step) {
+                const m = this.massInverse * step, e = this.strength, w = this.wind, g = this.gravity;
+                const d = Math.pow(this.damping, 60 * step);
+                while (true) {
+                  remaining -= step;
+                  if (scaleX) {
+                    this.scaleVelocity += (w * c - g * s - this.scaleOffset * e) * m;
+                    this.scaleOffset += this.scaleVelocity * step;
+                    this.scaleVelocity *= d;
+                  }
+                  if (rotateOrShearX) {
+                    this.rotateVelocity += (-0.01 * l * (w * s + g * c) - this.rotateOffset * e) * m;
+                    this.rotateOffset += this.rotateVelocity * step;
+                    this.rotateVelocity *= d;
+                    if (remaining < step)
+                      break;
+                    const r = this.rotateOffset * mr + ca;
+                    c = Math.cos(r);
+                    s = Math.sin(r);
+                  } else if (remaining < step)
+                    break;
+                }
+              }
+            }
+            this.remaining = remaining;
+          }
+          this.cx = bone.worldX;
+          this.cy = bone.worldY;
+          break;
+        case 3 /* pose */:
+          if (x)
+            bone.worldX += this.xOffset * mix * this.data.x;
+          if (y)
+            bone.worldY += this.yOffset * mix * this.data.y;
+      }
+      if (rotateOrShearX) {
+        let o = this.rotateOffset * mix, s = 0, c = 0, a = 0;
+        if (this.data.shearX > 0) {
+          let r = 0;
+          if (this.data.rotate > 0) {
+            r = o * this.data.rotate;
+            s = Math.sin(r);
+            c = Math.cos(r);
+            a = bone.b;
+            bone.b = c * a - s * bone.d;
+            bone.d = s * a + c * bone.d;
+          }
+          r += o * this.data.shearX;
+          s = Math.sin(r);
+          c = Math.cos(r);
+          a = bone.a;
+          bone.a = c * a - s * bone.c;
+          bone.c = s * a + c * bone.c;
+        } else {
+          o *= this.data.rotate;
+          s = Math.sin(o);
+          c = Math.cos(o);
+          a = bone.a;
+          bone.a = c * a - s * bone.c;
+          bone.c = s * a + c * bone.c;
+          a = bone.b;
+          bone.b = c * a - s * bone.d;
+          bone.d = s * a + c * bone.d;
+        }
+      }
+      if (scaleX) {
+        const s = 1 + this.scaleOffset * mix * this.data.scaleX;
+        bone.a *= s;
+        bone.c *= s;
+      }
+      if (physics != 3 /* pose */) {
+        this.tx = l * bone.a;
+        this.ty = l * bone.c;
+      }
+      bone.updateAppliedTransform();
+    }
+  };
+
   // spine-core/src/Slot.ts
   var Slot = class {
     /** The slot's setup pose data. */
@@ -6975,7 +7324,16 @@ var spine = (() => {
     isActive() {
       return this.active;
     }
-    update() {
+    setToSetupPose() {
+      const data = this.data;
+      this.mixRotate = data.mixRotate;
+      this.mixX = data.mixX;
+      this.mixY = data.mixY;
+      this.mixScaleX = data.mixScaleX;
+      this.mixScaleY = data.mixScaleY;
+      this.mixShearY = data.mixShearY;
+    }
+    update(physics) {
       if (this.mixRotate == 0 && this.mixX == 0 && this.mixY == 0 && this.mixScaleX == 0 && this.mixScaleY == 0 && this.mixShearY == 0)
         return;
       if (this.data.local) {
@@ -7115,7 +7473,7 @@ var spine = (() => {
         let rotation = bone.arotation;
         if (mixRotate != 0) {
           let r = target.arotation - rotation + this.data.offsetRotation;
-          r -= (16384 - (16384.499999999996 - r / 360 | 0)) * 360;
+          r -= Math.ceil(r / 360 - 0.5) * 360;
           rotation += r * mixRotate;
         }
         let x = bone.ax, y = bone.ay;
@@ -7129,7 +7487,7 @@ var spine = (() => {
         let shearY = bone.ashearY;
         if (mixShearY != 0) {
           let r = target.ashearY - shearY + this.data.offsetShearY;
-          r -= (16384 - (16384.499999999996 - r / 360 | 0)) * 360;
+          r -= Math.ceil(r / 360 - 0.5) * 360;
           shearY += r * mixShearY;
         }
         bone.updateWorldTransformWith(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
@@ -7168,6 +7526,8 @@ var spine = (() => {
     transformConstraints;
     /** The skeleton's path constraints. */
     pathConstraints;
+    /** The skeleton's physics constraints. */
+    physicsConstraints;
     /** The list of bones and constraints, sorted in the order they should be updated, as computed by {@link #updateCache()}. */
     _updateCache = new Array();
     /** The skeleton's current skin. May be null. */
@@ -7190,6 +7550,10 @@ var spine = (() => {
     x = 0;
     /** Sets the skeleton Y position, which is added to the root bone worldY position. */
     y = 0;
+    /** Returns the skeleton's time. This is used for time-based manipulations, such as {@link PhysicsConstraint}.
+     * <p>
+     * See {@link #update(float)}. */
+    time = 0;
     constructor(data) {
       if (!data)
         throw new Error("data cannot be null.");
@@ -7231,6 +7595,11 @@ var spine = (() => {
         let pathConstraintData = data.pathConstraints[i];
         this.pathConstraints.push(new PathConstraint(pathConstraintData, this));
       }
+      this.physicsConstraints = new Array();
+      for (let i = 0; i < data.physicsConstraints.length; i++) {
+        let physicsConstraintData = data.physicsConstraints[i];
+        this.physicsConstraints.push(new PhysicsConstraint(physicsConstraintData, this));
+      }
       this.color = new Color(1, 1, 1, 1);
       this.updateCache();
     }
@@ -7259,8 +7628,9 @@ var spine = (() => {
       let ikConstraints = this.ikConstraints;
       let transformConstraints = this.transformConstraints;
       let pathConstraints = this.pathConstraints;
-      let ikCount = ikConstraints.length, transformCount = transformConstraints.length, pathCount = pathConstraints.length;
-      let constraintCount = ikCount + transformCount + pathCount;
+      let physicsConstraints = this.physicsConstraints;
+      let ikCount = ikConstraints.length, transformCount = transformConstraints.length, pathCount = pathConstraints.length, physicsCount = this.physicsConstraints.length;
+      let constraintCount = ikCount + transformCount + pathCount + physicsCount;
       outer:
         for (let i = 0; i < constraintCount; i++) {
           for (let ii = 0; ii < ikCount; ii++) {
@@ -7284,6 +7654,13 @@ var spine = (() => {
               continue outer;
             }
           }
+          for (let ii = 0; ii < physicsCount; ii++) {
+            const constraint = physicsConstraints[ii];
+            if (constraint.data.order == i) {
+              this.sortPhysicsConstraint(constraint);
+              continue outer;
+            }
+          }
         }
       for (let i = 0, n = bones.length; i < n; i++)
         this.sortBone(bones[i]);
@@ -7382,6 +7759,16 @@ var spine = (() => {
         }
       }
     }
+    sortPhysicsConstraint(constraint) {
+      const bone = constraint.bone;
+      constraint.active = bone.active && !constraint.data.skinRequired || this.skin != null && Utils.contains(this.skin.constraints, constraint.data, true);
+      if (!constraint.active)
+        return;
+      this.sortBone(bone);
+      this._updateCache.push(constraint);
+      this.sortReset(bone.children);
+      bone.sorted = true;
+    }
     sortBone(bone) {
       if (!bone)
         return;
@@ -7407,7 +7794,9 @@ var spine = (() => {
      *
      * See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine
      * Runtimes Guide. */
-    updateWorldTransform() {
+    updateWorldTransform(physics) {
+      if (!physics)
+        throw new Error("physics is undefined");
       let bones = this.bones;
       for (let i = 0, n = bones.length; i < n; i++) {
         let bone = bones[i];
@@ -7421,20 +7810,21 @@ var spine = (() => {
       }
       let updateCache = this._updateCache;
       for (let i = 0, n = updateCache.length; i < n; i++)
-        updateCache[i].update();
+        updateCache[i].update(physics);
     }
-    updateWorldTransformWith(parent) {
+    updateWorldTransformWith(physics, parent) {
       let rootBone = this.getRootBone();
       if (!rootBone)
         throw new Error("Root bone must not be null.");
       let pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d;
       rootBone.worldX = pa * this.x + pb * this.y + parent.worldX;
       rootBone.worldY = pc * this.x + pd * this.y + parent.worldY;
-      let rotationY = rootBone.rotation + 90 + rootBone.shearY;
-      let la = MathUtils.cosDeg(rootBone.rotation + rootBone.shearX) * rootBone.scaleX;
-      let lb = MathUtils.cosDeg(rotationY) * rootBone.scaleY;
-      let lc = MathUtils.sinDeg(rootBone.rotation + rootBone.shearX) * rootBone.scaleX;
-      let ld = MathUtils.sinDeg(rotationY) * rootBone.scaleY;
+      const rx = (rootBone.rotation + rootBone.shearX) * MathUtils.degRad;
+      const ry = (rootBone.rotation + 90 + rootBone.shearY) * MathUtils.degRad;
+      const la = Math.cos(rx) * rootBone.scaleX;
+      const lb = Math.cos(ry) * rootBone.scaleY;
+      const lc = Math.sin(rx) * rootBone.scaleX;
+      const ld = Math.sin(ry) * rootBone.scaleY;
       rootBone.a = (pa * la + pb * lc) * this.scaleX;
       rootBone.b = (pa * lb + pb * ld) * this.scaleX;
       rootBone.c = (pc * la + pd * lc) * this.scaleY;
@@ -7443,7 +7833,7 @@ var spine = (() => {
       for (let i = 0, n = updateCache.length; i < n; i++) {
         let updatable = updateCache[i];
         if (updatable != rootBone)
-          updatable.update();
+          updatable.update(physics);
       }
     }
     /** Sets the bones, constraints, and slots to their setup pose values. */
@@ -7453,39 +7843,16 @@ var spine = (() => {
     }
     /** Sets the bones and constraints to their setup pose values. */
     setBonesToSetupPose() {
-      let bones = this.bones;
-      for (let i = 0, n = bones.length; i < n; i++)
-        bones[i].setToSetupPose();
-      let ikConstraints = this.ikConstraints;
-      for (let i = 0, n = ikConstraints.length; i < n; i++) {
-        let constraint = ikConstraints[i];
-        constraint.mix = constraint.data.mix;
-        constraint.softness = constraint.data.softness;
-        constraint.bendDirection = constraint.data.bendDirection;
-        constraint.compress = constraint.data.compress;
-        constraint.stretch = constraint.data.stretch;
-      }
-      let transformConstraints = this.transformConstraints;
-      for (let i = 0, n = transformConstraints.length; i < n; i++) {
-        let constraint = transformConstraints[i];
-        let data = constraint.data;
-        constraint.mixRotate = data.mixRotate;
-        constraint.mixX = data.mixX;
-        constraint.mixY = data.mixY;
-        constraint.mixScaleX = data.mixScaleX;
-        constraint.mixScaleY = data.mixScaleY;
-        constraint.mixShearY = data.mixShearY;
-      }
-      let pathConstraints = this.pathConstraints;
-      for (let i = 0, n = pathConstraints.length; i < n; i++) {
-        let constraint = pathConstraints[i];
-        let data = constraint.data;
-        constraint.position = data.position;
-        constraint.spacing = data.spacing;
-        constraint.mixRotate = data.mixRotate;
-        constraint.mixX = data.mixX;
-        constraint.mixY = data.mixY;
-      }
+      for (const bone of this.bones)
+        bone.setToSetupPose();
+      for (const constraint of this.ikConstraints)
+        constraint.setToSetupPose();
+      for (const constraint of this.transformConstraints)
+        constraint.setToSetupPose();
+      for (const constraint of this.pathConstraints)
+        constraint.setToSetupPose();
+      for (const constraint of this.physicsConstraints)
+        constraint.setToSetupPose();
     }
     /** Sets the slots and draw order to their setup pose values. */
     setSlotsToSetupPose() {
@@ -7623,13 +7990,7 @@ var spine = (() => {
     findIkConstraint(constraintName) {
       if (!constraintName)
         throw new Error("constraintName cannot be null.");
-      let ikConstraints = this.ikConstraints;
-      for (let i = 0, n = ikConstraints.length; i < n; i++) {
-        let ikConstraint = ikConstraints[i];
-        if (ikConstraint.data.name == constraintName)
-          return ikConstraint;
-      }
-      return null;
+      return this.ikConstraints.find((constraint) => constraint.data.name == constraintName) ?? null;
     }
     /** Finds a transform constraint by comparing each transform constraint's name. It is more efficient to cache the results of
      * this method than to call it repeatedly.
@@ -7637,13 +7998,7 @@ var spine = (() => {
     findTransformConstraint(constraintName) {
       if (!constraintName)
         throw new Error("constraintName cannot be null.");
-      let transformConstraints = this.transformConstraints;
-      for (let i = 0, n = transformConstraints.length; i < n; i++) {
-        let constraint = transformConstraints[i];
-        if (constraint.data.name == constraintName)
-          return constraint;
-      }
-      return null;
+      return this.transformConstraints.find((constraint) => constraint.data.name == constraintName) ?? null;
     }
     /** Finds a path constraint by comparing each path constraint's name. It is more efficient to cache the results of this method
      * than to call it repeatedly.
@@ -7651,13 +8006,14 @@ var spine = (() => {
     findPathConstraint(constraintName) {
       if (!constraintName)
         throw new Error("constraintName cannot be null.");
-      let pathConstraints = this.pathConstraints;
-      for (let i = 0, n = pathConstraints.length; i < n; i++) {
-        let constraint = pathConstraints[i];
-        if (constraint.data.name == constraintName)
-          return constraint;
-      }
-      return null;
+      return this.pathConstraints.find((constraint) => constraint.data.name == constraintName) ?? null;
+    }
+    /** Finds a physics constraint by comparing each physics constraint's name. It is more efficient to cache the results of this
+     * method than to call it repeatedly. */
+    findPhysicsConstraint(constraintName) {
+      if (constraintName == null)
+        throw new Error("constraintName cannot be null.");
+      return this.physicsConstraints.find((constraint) => constraint.data.name == constraintName) ?? null;
     }
     /** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the current pose as `{ x: number, y: number, width: number, height: number }`.
      * Note that this method will create temporary objects which can add to garbage collection pressure. Use `getBounds()` if garbage collection is a concern. */
@@ -7708,9 +8064,20 @@ var spine = (() => {
       offset.set(minX, minY);
       size.set(maxX - minX, maxY - minY);
     }
+    /** Increments the skeleton's {@link #time}. */
+    update(delta) {
+      this.time += delta;
+    }
   };
-  var Skeleton = _Skeleton;
-  __publicField(Skeleton, "yDown", false);
+  var Skeleton2 = _Skeleton;
+  __publicField(Skeleton2, "yDown", false);
+  var Physics = /* @__PURE__ */ ((Physics2) => {
+    Physics2[Physics2["none"] = 0] = "none";
+    Physics2[Physics2["reset"] = 1] = "reset";
+    Physics2[Physics2["update"] = 2] = "update";
+    Physics2[Physics2["pose"] = 3] = "pose";
+    return Physics2;
+  })(Physics || {});
 
   // spine-core/src/SkeletonData.ts
   var SkeletonData = class {
@@ -7738,6 +8105,8 @@ var spine = (() => {
     transformConstraints = new Array();
     /** The skeleton's path constraints. */
     pathConstraints = new Array();
+    /** The skeleton's physics constraints. */
+    physicsConstraints = new Array();
     /** The X coordinate of the skeleton's axis aligned bounding box in the setup pose. */
     x = 0;
     /** The Y coordinate of the skeleton's axis aligned bounding box in the setup pose. */
@@ -7833,9 +8202,9 @@ var spine = (() => {
     findIkConstraint(constraintName) {
       if (!constraintName)
         throw new Error("constraintName cannot be null.");
-      let ikConstraints = this.ikConstraints;
+      const ikConstraints = this.ikConstraints;
       for (let i = 0, n = ikConstraints.length; i < n; i++) {
-        let constraint = ikConstraints[i];
+        const constraint = ikConstraints[i];
         if (constraint.name == constraintName)
           return constraint;
       }
@@ -7847,9 +8216,9 @@ var spine = (() => {
     findTransformConstraint(constraintName) {
       if (!constraintName)
         throw new Error("constraintName cannot be null.");
-      let transformConstraints = this.transformConstraints;
+      const transformConstraints = this.transformConstraints;
       for (let i = 0, n = transformConstraints.length; i < n; i++) {
-        let constraint = transformConstraints[i];
+        const constraint = transformConstraints[i];
         if (constraint.name == constraintName)
           return constraint;
       }
@@ -7861,9 +8230,23 @@ var spine = (() => {
     findPathConstraint(constraintName) {
       if (!constraintName)
         throw new Error("constraintName cannot be null.");
-      let pathConstraints = this.pathConstraints;
+      const pathConstraints = this.pathConstraints;
       for (let i = 0, n = pathConstraints.length; i < n; i++) {
-        let constraint = pathConstraints[i];
+        const constraint = pathConstraints[i];
+        if (constraint.name == constraintName)
+          return constraint;
+      }
+      return null;
+    }
+    /** Finds a physics constraint by comparing each physics constraint's name. It is more efficient to cache the results of this method
+     * than to call it multiple times.
+     * @return May be null. */
+    findPhysicsConstraint(constraintName) {
+      if (!constraintName)
+        throw new Error("constraintName cannot be null.");
+      const physicsConstraints = this.physicsConstraints;
+      for (let i = 0, n = physicsConstraints.length; i < n; i++) {
+        const constraint = physicsConstraints[i];
         if (constraint.name == constraintName)
           return constraint;
       }
@@ -7885,6 +8268,9 @@ var spine = (() => {
     attachments = new Array();
     bones = Array();
     constraints = new Array();
+    /** The color of the skin as it was in Spine, or a default color if nonessential data was not exported. */
+    color = new Color(0.99607843, 0.61960787, 0.30980393, 1);
+    // fe9e4fff
     constructor(name) {
       if (!name)
         throw new Error("name cannot be null.");
@@ -8058,6 +8444,8 @@ var spine = (() => {
     attachmentName = null;
     /** The blend mode for drawing the slot's attachment. */
     blendMode = BlendMode.Normal;
+    /** False if the slot was hidden in Spine and nonessential data was exported. Does not affect runtime rendering. */
+    visible = true;
     constructor(index, name, boneData) {
       if (index < 0)
         throw new Error("index must be >= 0.");