@esotericsoftware/spine-webgl 4.2.25 → 4.2.27

package/dist/iife/spine-webgl.js

@@ -4,6 +4,7 @@ var spine = (() => {
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -17,6 +18,10 @@ var spine = (() => {
     return to;
   };
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => {
+    __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+    return value;
+  };
 
   // spine-webgl/src/index.ts
   var src_exports = {};
@@ -98,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,
@@ -127,7 +142,7 @@ var spine = (() => {
     ShearTimeline: () => ShearTimeline,
     ShearXTimeline: () => ShearXTimeline,
     ShearYTimeline: () => ShearYTimeline,
-    Skeleton: () => Skeleton,
+    Skeleton: () => Skeleton2,
     SkeletonBinary: () => SkeletonBinary,
     SkeletonBounds: () => SkeletonBounds,
     SkeletonClipping: () => SkeletonClipping,
@@ -173,9 +188,7 @@ var spine = (() => {
 
   // spine-core/src/Utils.ts
   var IntSet = class {
-    constructor() {
-      this.array = new Array();
-    }
+    array = new Array();
     add(value) {
       let contains = this.contains(value);
       this.array[value | 0] = value | 0;
@@ -192,10 +205,8 @@ var spine = (() => {
     }
   };
   var StringSet = class {
-    constructor() {
-      this.entries = {};
-      this.size = 0;
-    }
+    entries = {};
+    size = 0;
     add(value) {
       let contains = this.entries[value];
       this.entries[value] = true;
@@ -290,11 +301,11 @@ var spine = (() => {
     }
   };
   var Color = _Color;
-  Color.WHITE = new _Color(1, 1, 1, 1);
-  Color.RED = new _Color(1, 0, 0, 1);
-  Color.GREEN = new _Color(0, 1, 0, 1);
-  Color.BLUE = new _Color(0, 0, 1, 1);
-  Color.MAGENTA = new _Color(1, 0, 1, 1);
+  __publicField(Color, "WHITE", new _Color(1, 1, 1, 1));
+  __publicField(Color, "RED", new _Color(1, 0, 0, 1));
+  __publicField(Color, "GREEN", new _Color(0, 1, 0, 1));
+  __publicField(Color, "BLUE", new _Color(0, 0, 1, 1));
+  __publicField(Color, "MAGENTA", new _Color(1, 0, 1, 1));
   var _MathUtils = class {
     static clamp(value, min, max) {
       if (value < min)
@@ -309,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;
     }
@@ -334,21 +348,22 @@ var spine = (() => {
     }
   };
   var MathUtils = _MathUtils;
-  MathUtils.PI = 3.1415927;
-  MathUtils.PI2 = _MathUtils.PI * 2;
-  MathUtils.radiansToDegrees = 180 / _MathUtils.PI;
-  MathUtils.radDeg = _MathUtils.radiansToDegrees;
-  MathUtils.degreesToRadians = _MathUtils.PI / 180;
-  MathUtils.degRad = _MathUtils.degreesToRadians;
+  __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);
+  __publicField(MathUtils, "degRad", _MathUtils.degreesToRadians);
   var Interpolation = class {
     apply(start, end, a) {
       return start + (end - start) * this.applyInternal(a);
     }
   };
   var Pow = class extends Interpolation {
+    power = 2;
     constructor(power) {
       super();
-      this.power = 2;
       this.power = power;
     }
     applyInternal(a) {
@@ -437,7 +452,7 @@ var spine = (() => {
     }
   };
   var Utils = _Utils;
-  Utils.SUPPORTS_TYPED_ARRAYS = typeof Float32Array !== "undefined";
+  __publicField(Utils, "SUPPORTS_TYPED_ARRAYS", typeof Float32Array !== "undefined");
   var DebugUtils = class {
     static logBones(skeleton) {
       for (let i = 0; i < skeleton.bones.length; i++) {
@@ -447,8 +462,9 @@ var spine = (() => {
     }
   };
   var Pool = class {
+    items = new Array();
+    instantiator;
     constructor(instantiator) {
-      this.items = new Array();
       this.instantiator = instantiator;
     }
     obtain() {
@@ -492,15 +508,13 @@ var spine = (() => {
     }
   };
   var TimeKeeper = class {
-    constructor() {
-      this.maxDelta = 0.064;
-      this.framesPerSecond = 0;
-      this.delta = 0;
-      this.totalTime = 0;
-      this.lastTime = Date.now() / 1e3;
-      this.frameCount = 0;
-      this.frameTime = 0;
-    }
+    maxDelta = 0.064;
+    framesPerSecond = 0;
+    delta = 0;
+    totalTime = 0;
+    lastTime = Date.now() / 1e3;
+    frameCount = 0;
+    frameTime = 0;
     update() {
       let now = Date.now() / 1e3;
       this.delta = now - this.lastTime;
@@ -518,11 +532,12 @@ var spine = (() => {
     }
   };
   var WindowedMean = class {
+    values;
+    addedValues = 0;
+    lastValue = 0;
+    mean = 0;
+    dirty = true;
     constructor(windowSize = 32) {
-      this.addedValues = 0;
-      this.lastValue = 0;
-      this.mean = 0;
-      this.dirty = true;
       this.values = new Array(windowSize);
     }
     hasEnoughData() {
@@ -553,6 +568,7 @@ var spine = (() => {
 
   // spine-core/src/attachments/Attachment.ts
   var Attachment = class {
+    name;
     constructor(name) {
       if (!name)
         throw new Error("name cannot be null.");
@@ -560,24 +576,24 @@ var spine = (() => {
     }
   };
   var _VertexAttachment = class extends Attachment {
+    /** The unique ID for this attachment. */
+    id = _VertexAttachment.nextID++;
+    /** The bones which affect the {@link #getVertices()}. The array entries are, for each vertex, the number of bones affecting
+     * the vertex followed by that many bone indices, which is the index of the bone in {@link Skeleton#bones}. Will be null
+     * if this attachment has no weights. */
+    bones = null;
+    /** The vertex positions in the bone's coordinate system. For a non-weighted attachment, the values are `x,y`
+     * entries for each vertex. For a weighted attachment, the values are `x,y,weight` entries for each bone affecting
+     * each vertex. */
+    vertices = [];
+    /** The maximum number of world vertex values that can be output by
+     * {@link #computeWorldVertices()} using the `count` parameter. */
+    worldVerticesLength = 0;
+    /** Timelines for the timeline attachment are also applied to this attachment.
+     * May be null if no attachment-specific timelines should be applied. */
+    timelineAttachment = this;
     constructor(name) {
       super(name);
-      /** The unique ID for this attachment. */
-      this.id = _VertexAttachment.nextID++;
-      /** The bones which affect the {@link #getVertices()}. The array entries are, for each vertex, the number of bones affecting
-       * the vertex followed by that many bone indices, which is the index of the bone in {@link Skeleton#bones}. Will be null
-       * if this attachment has no weights. */
-      this.bones = null;
-      /** The vertex positions in the bone's coordinate system. For a non-weighted attachment, the values are `x,y`
-       * entries for each vertex. For a weighted attachment, the values are `x,y,weight` entries for each bone affecting
-       * each vertex. */
-      this.vertices = [];
-      /** The maximum number of world vertex values that can be output by
-       * {@link #computeWorldVertices()} using the `count` parameter. */
-      this.worldVerticesLength = 0;
-      /** Timelines for the timeline attachment are also applied to this attachment.
-       * May be null if no attachment-specific timelines should be applied. */
-      this.timelineAttachment = this;
     }
     /** Transforms the attachment's local {@link #vertices} to world coordinates. If the slot's {@link Slot#deform} is
      * not empty, it is used to deform the vertices.
@@ -664,16 +680,17 @@ var spine = (() => {
     }
   };
   var VertexAttachment = _VertexAttachment;
-  VertexAttachment.nextID = 0;
+  __publicField(VertexAttachment, "nextID", 0);
 
   // spine-core/src/attachments/Sequence.ts
   var _Sequence = class {
+    id = _Sequence.nextID();
+    regions;
+    start = 0;
+    digits = 0;
+    /** The index of the region to show for the setup pose. */
+    setupIndex = 0;
     constructor(count) {
-      this.id = _Sequence.nextID();
-      this.start = 0;
-      this.digits = 0;
-      /** The index of the region to show for the setup pose. */
-      this.setupIndex = 0;
       this.regions = new Array(count);
     }
     copy() {
@@ -709,7 +726,7 @@ var spine = (() => {
     }
   };
   var Sequence = _Sequence;
-  Sequence._nextID = 0;
+  __publicField(Sequence, "_nextID", 0);
   var SequenceMode = /* @__PURE__ */ ((SequenceMode2) => {
     SequenceMode2[SequenceMode2["hold"] = 0] = "hold";
     SequenceMode2[SequenceMode2["once"] = 1] = "once";
@@ -732,9 +749,13 @@ var spine = (() => {
 
   // spine-core/src/Animation.ts
   var Animation = class {
+    /** The animation's name, which is unique across all animations in the skeleton. */
+    name;
+    timelines = [];
+    timelineIds = new StringSet();
+    /** The duration of the animation in seconds, which is the highest time of all keys in the timeline. */
+    duration;
     constructor(name, timelines, duration) {
-      this.timelines = [];
-      this.timelineIds = new StringSet();
       if (!name)
         throw new Error("name cannot be null.");
       this.name = name;
@@ -805,9 +826,19 @@ 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;
+    frames;
     constructor(frameCount, propertyIds) {
       this.propertyIds = propertyIds;
       this.frames = Utils.newFloatArray(frameCount * this.getFrameEntries());
@@ -840,6 +871,7 @@ var spine = (() => {
     }
   };
   var CurveTimeline = class extends Timeline {
+    curves;
     // type, x, y, ...
     constructor(frameCount, bezierCount, propertyIds) {
       super(frameCount, propertyIds);
@@ -980,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)}.
@@ -1007,40 +1127,19 @@ var spine = (() => {
     }
   };
   var RotateTimeline = class extends CurveTimeline1 {
+    boneIndex = 0;
     constructor(frameCount, bezierCount, boneIndex) {
       super(frameCount, bezierCount, Property.rotate + "|" + boneIndex);
-      this.boneIndex = 0;
       this.boneIndex = boneIndex;
     }
     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 {
+    boneIndex = 0;
     constructor(frameCount, bezierCount, boneIndex) {
       super(
         frameCount,
@@ -1048,7 +1147,6 @@ var spine = (() => {
         Property.x + "|" + boneIndex,
         Property.y + "|" + boneIndex
       );
-      this.boneIndex = 0;
       this.boneIndex = boneIndex;
     }
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
@@ -1146,76 +1244,31 @@ var spine = (() => {
     }
   };
   var TranslateXTimeline = class extends CurveTimeline1 {
+    boneIndex = 0;
     constructor(frameCount, bezierCount, boneIndex) {
       super(frameCount, bezierCount, Property.x + "|" + boneIndex);
-      this.boneIndex = 0;
       this.boneIndex = boneIndex;
     }
     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 {
+    boneIndex = 0;
     constructor(frameCount, bezierCount, boneIndex) {
       super(frameCount, bezierCount, Property.y + "|" + boneIndex);
-      this.boneIndex = 0;
       this.boneIndex = boneIndex;
     }
     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 {
+    boneIndex = 0;
     constructor(frameCount, bezierCount, boneIndex) {
       super(
         frameCount,
@@ -1223,7 +1276,6 @@ var spine = (() => {
         Property.scaleX + "|" + boneIndex,
         Property.scaleY + "|" + boneIndex
       );
-      this.boneIndex = 0;
       this.boneIndex = boneIndex;
     }
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
@@ -1359,128 +1411,31 @@ var spine = (() => {
     }
   };
   var ScaleXTimeline = class extends CurveTimeline1 {
+    boneIndex = 0;
     constructor(frameCount, bezierCount, boneIndex) {
       super(frameCount, bezierCount, Property.scaleX + "|" + boneIndex);
-      this.boneIndex = 0;
       this.boneIndex = boneIndex;
     }
     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 {
+    boneIndex = 0;
     constructor(frameCount, bezierCount, boneIndex) {
       super(frameCount, bezierCount, Property.scaleY + "|" + boneIndex);
-      this.boneIndex = 0;
       this.boneIndex = boneIndex;
     }
     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 {
+    boneIndex = 0;
     constructor(frameCount, bezierCount, boneIndex) {
       super(
         frameCount,
@@ -1488,7 +1443,6 @@ var spine = (() => {
         Property.shearX + "|" + boneIndex,
         Property.shearY + "|" + boneIndex
       );
-      this.boneIndex = 0;
       this.boneIndex = boneIndex;
     }
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
@@ -1586,82 +1540,36 @@ var spine = (() => {
     }
   };
   var ShearXTimeline = class extends CurveTimeline1 {
+    boneIndex = 0;
     constructor(frameCount, bezierCount, boneIndex) {
       super(frameCount, bezierCount, Property.shearX + "|" + boneIndex);
-      this.boneIndex = 0;
       this.boneIndex = boneIndex;
     }
     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 {
+    boneIndex = 0;
     constructor(frameCount, bezierCount, boneIndex) {
       super(frameCount, bezierCount, Property.shearY + "|" + boneIndex);
-      this.boneIndex = 0;
       this.boneIndex = boneIndex;
     }
     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 {
+    slotIndex = 0;
     constructor(frameCount, bezierCount, slotIndex) {
       super(frameCount, bezierCount, [
         Property.rgb + "|" + slotIndex,
         Property.alpha + "|" + slotIndex
       ]);
-      this.slotIndex = 0;
       this.slotIndex = slotIndex;
     }
     getFrameEntries() {
@@ -1819,11 +1727,11 @@ var spine = (() => {
     }
   };
   var RGBTimeline = class extends CurveTimeline {
+    slotIndex = 0;
     constructor(frameCount, bezierCount, slotIndex) {
       super(frameCount, bezierCount, [
         Property.rgb + "|" + slotIndex
       ]);
-      this.slotIndex = 0;
       this.slotIndex = slotIndex;
     }
     getFrameEntries() {
@@ -1962,9 +1870,9 @@ var spine = (() => {
     }
   };
   var AlphaTimeline = class extends CurveTimeline1 {
+    slotIndex = 0;
     constructor(frameCount, bezierCount, slotIndex) {
       super(frameCount, bezierCount, Property.alpha + "|" + slotIndex);
-      this.slotIndex = 0;
       this.slotIndex = slotIndex;
     }
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
@@ -1994,13 +1902,13 @@ var spine = (() => {
     }
   };
   var RGBA2Timeline = class extends CurveTimeline {
+    slotIndex = 0;
     constructor(frameCount, bezierCount, slotIndex) {
       super(frameCount, bezierCount, [
         Property.rgb + "|" + slotIndex,
         Property.alpha + "|" + slotIndex,
         Property.rgb2 + "|" + slotIndex
       ]);
-      this.slotIndex = 0;
       this.slotIndex = slotIndex;
     }
     getFrameEntries() {
@@ -2241,12 +2149,12 @@ var spine = (() => {
     }
   };
   var RGB2Timeline = class extends CurveTimeline {
+    slotIndex = 0;
     constructor(frameCount, bezierCount, slotIndex) {
       super(frameCount, bezierCount, [
         Property.rgb + "|" + slotIndex,
         Property.rgb2 + "|" + slotIndex
       ]);
-      this.slotIndex = 0;
       this.slotIndex = slotIndex;
     }
     getFrameEntries() {
@@ -2472,11 +2380,13 @@ var spine = (() => {
     }
   };
   var AttachmentTimeline = class extends Timeline {
+    slotIndex = 0;
+    /** The attachment name for each key frame. May contain null values to clear the attachment. */
+    attachmentNames;
     constructor(frameCount, slotIndex) {
       super(frameCount, [
         Property.attachment + "|" + slotIndex
       ]);
-      this.slotIndex = 0;
       this.slotIndex = slotIndex;
       this.attachmentNames = new Array(frameCount);
     }
@@ -2509,11 +2419,15 @@ var spine = (() => {
     }
   };
   var DeformTimeline = class extends CurveTimeline {
+    slotIndex = 0;
+    /** The attachment that will be deformed. */
+    attachment;
+    /** The vertices for each key frame. */
+    vertices;
     constructor(frameCount, bezierCount, slotIndex, attachment) {
       super(frameCount, bezierCount, [
         Property.deform + "|" + slotIndex + "|" + attachment.id
       ]);
-      this.slotIndex = 0;
       this.slotIndex = slotIndex;
       this.attachment = attachment;
       this.vertices = new Array(frameCount);
@@ -2734,6 +2648,8 @@ var spine = (() => {
     }
   };
   var _EventTimeline = class extends Timeline {
+    /** The event for each key frame. */
+    events;
     constructor(frameCount) {
       super(frameCount, _EventTimeline.propertyIds);
       this.events = new Array(frameCount);
@@ -2776,8 +2692,10 @@ var spine = (() => {
     }
   };
   var EventTimeline = _EventTimeline;
-  EventTimeline.propertyIds = ["" + Property.event];
+  __publicField(EventTimeline, "propertyIds", ["" + Property.event]);
   var _DrawOrderTimeline = class extends Timeline {
+    /** The draw order for each key frame. See {@link #setFrame(int, float, int[])}. */
+    drawOrders;
     constructor(frameCount) {
       super(frameCount, _DrawOrderTimeline.propertyIds);
       this.drawOrders = new Array(frameCount);
@@ -2816,15 +2734,15 @@ var spine = (() => {
     }
   };
   var DrawOrderTimeline = _DrawOrderTimeline;
-  DrawOrderTimeline.propertyIds = ["" + Property.drawOrder];
+  __publicField(DrawOrderTimeline, "propertyIds", ["" + Property.drawOrder]);
   var IkConstraintTimeline = class extends CurveTimeline {
+    /** 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
       ]);
-      /** The index of the IK constraint slot in {@link Skeleton#ikConstraints} that will be changed. */
-      this.ikConstraintIndex = 0;
-      this.ikConstraintIndex = ikConstraintIndex;
+      this.constraintIndex = ikConstraintIndex;
     }
     getFrameEntries() {
       return 6;
@@ -2855,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;
@@ -2980,13 +2898,13 @@ var spine = (() => {
     }
   };
   var TransformConstraintTimeline = class extends CurveTimeline {
+    /** The index of the transform constraint slot in {@link Skeleton#transformConstraints} that will be changed. */
+    constraintIndex = 0;
     constructor(frameCount, bezierCount, transformConstraintIndex) {
       super(frameCount, bezierCount, [
         Property.transformConstraint + "|" + transformConstraintIndex
       ]);
-      /** The index of the transform constraint slot in {@link Skeleton#transformConstraints} that will be changed. */
-      this.transformConstraintIndex = 0;
-      this.transformConstraintIndex = transformConstraintIndex;
+      this.constraintIndex = transformConstraintIndex;
     }
     getFrameEntries() {
       return 7;
@@ -3022,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;
@@ -3203,71 +3121,42 @@ var spine = (() => {
     }
   };
   var PathConstraintPositionTimeline = class extends CurveTimeline1 {
+    /** 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);
-      /** The index of the path constraint slot in {@link Skeleton#pathConstraints} that will be changed. */
-      this.pathConstraintIndex = 0;
-      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 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);
-      /** The index of the path constraint slot in {@link Skeleton#getPathConstraints()} that will be changed. */
-      this.pathConstraintIndex = 0;
-      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 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
       ]);
-      /** The index of the path constraint slot in {@link Skeleton#getPathConstraints()} that will be changed. */
-      this.pathConstraintIndex = 0;
-      this.pathConstraintIndex = pathConstraintIndex;
+      this.constraintIndex = pathConstraintIndex;
     }
     getFrameEntries() {
       return 4;
@@ -3290,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;
@@ -3397,7 +3286,199 @@ 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;
     constructor(frameCount, slotIndex, attachment) {
       super(frameCount, [
         Property.sequence + "|" + slotIndex + "|" + attachment.sequence.id
@@ -3482,32 +3563,34 @@ var spine = (() => {
     }
   };
   var SequenceTimeline = _SequenceTimeline;
-  SequenceTimeline.ENTRIES = 3;
-  SequenceTimeline.MODE = 1;
-  SequenceTimeline.DELAY = 2;
+  __publicField(SequenceTimeline, "ENTRIES", 3);
+  __publicField(SequenceTimeline, "MODE", 1);
+  __publicField(SequenceTimeline, "DELAY", 2);
 
   // spine-core/src/AnimationState.ts
   var _AnimationState = class {
-    constructor(data) {
-      /** The list of tracks that currently have animations, which may contain null entries. */
-      this.tracks = new Array();
-      /** Multiplier for the delta time when the animation state is updated, causing time for all animations and mixes to play slower
-       * or faster. Defaults to 1.
-       *
-       * See TrackEntry {@link TrackEntry#timeScale} for affecting a single animation. */
-      this.timeScale = 1;
-      this.unkeyedState = 0;
-      this.events = new Array();
-      this.listeners = new Array();
-      this.queue = new EventQueue(this);
-      this.propertyIDs = new StringSet();
-      this.animationsChanged = false;
-      this.trackEntryPool = new Pool(() => new TrackEntry());
-      this.data = data;
-    }
     static emptyAnimation() {
       return _AnimationState._emptyAnimation;
     }
+    /** The AnimationStateData to look up mix durations. */
+    data;
+    /** The list of tracks that currently have animations, which may contain null entries. */
+    tracks = new Array();
+    /** Multiplier for the delta time when the animation state is updated, causing time for all animations and mixes to play slower
+     * or faster. Defaults to 1.
+     *
+     * See TrackEntry {@link TrackEntry#timeScale} for affecting a single animation. */
+    timeScale = 1;
+    unkeyedState = 0;
+    events = new Array();
+    listeners = new Array();
+    queue = new EventQueue(this);
+    propertyIDs = new StringSet();
+    animationsChanged = false;
+    trackEntryPool = new Pool(() => new TrackEntry());
+    constructor(data) {
+      this.data = data;
+    }
     /** Increments each track entry {@link TrackEntry#trackTime()}, setting queued animations as current if needed. */
     update(delta) {
       delta *= this.timeScale;
@@ -3599,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) {
@@ -3612,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;
@@ -3631,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 */);
             }
           }
         }
@@ -3674,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);
@@ -3729,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 */)
@@ -3789,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 {
@@ -4046,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;
@@ -4159,141 +4246,151 @@ var spine = (() => {
     }
   };
   var AnimationState = _AnimationState;
-  AnimationState._emptyAnimation = new Animation("<empty>", [], 0);
+  __publicField(AnimationState, "_emptyAnimation", new Animation("<empty>", [], 0));
   var TrackEntry = class {
-    constructor() {
-      /** The animation to apply for this track entry. */
-      this.animation = null;
-      this.previous = null;
-      /** The animation queued to start after this animation, or null. `next` makes up a linked list. */
-      this.next = null;
-      /** The track entry for the previous animation when mixing from the previous animation to this animation, or null if no
-       * mixing is currently occuring. When mixing from multiple animations, `mixingFrom` makes up a linked list. */
-      this.mixingFrom = null;
-      /** The track entry for the next animation when mixing from this animation to the next animation, or null if no mixing is
-       * currently occuring. When mixing to multiple animations, `mixingTo` makes up a linked list. */
-      this.mixingTo = null;
-      /** The listener for events generated by this track entry, or null.
-       *
-       * A track entry returned from {@link AnimationState#setAnimation()} is already the current animation
-       * for the track, so the track entry listener {@link AnimationStateListener#start()} will not be called. */
-      this.listener = null;
-      /** The index of the track where this track entry is either current or queued.
-       *
-       * See {@link AnimationState#getCurrent()}. */
-      this.trackIndex = 0;
-      /** If true, the animation will repeat. If false it will not, instead its last frame is applied if played beyond its
-       * duration. */
-      this.loop = false;
-      /** If true, when mixing from the previous animation to this animation, the previous animation is applied as normal instead
-       * of being mixed out.
-       *
-       * When mixing between animations that key the same property, if a lower track also keys that property then the value will
-       * briefly dip toward the lower track value during the mix. This happens because the first animation mixes from 100% to 0%
-       * while the second animation mixes from 0% to 100%. Setting `holdPrevious` to true applies the first animation
-       * at 100% during the mix so the lower track value is overwritten. Such dipping does not occur on the lowest track which
-       * keys the property, only when a higher track also keys the property.
-       *
-       * Snapping will occur if `holdPrevious` is true and this animation does not key all the same properties as the
-       * previous animation. */
-      this.holdPrevious = false;
-      this.reverse = false;
-      this.shortestRotation = false;
-      /** When the mix percentage ({@link #mixTime} / {@link #mixDuration}) is less than the
-       * `eventThreshold`, event timelines are applied while this animation is being mixed out. Defaults to 0, so event
-       * timelines are not applied while this animation is being mixed out. */
-      this.eventThreshold = 0;
-      /** 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. */
-      this.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. */
-      this.drawOrderThreshold = 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
-       * value to prevent timeline keys before the start time from triggering. */
-      this.animationStart = 0;
-      /** Seconds for the last frame of this animation. Non-looping animations won't play past this time. Looping animations will
-       * loop back to {@link #animationStart} at this time. Defaults to the animation {@link Animation#duration}. */
-      this.animationEnd = 0;
-      /** The time in seconds this animation was last applied. Some timelines use this for one-time triggers. Eg, when this
-       * animation is applied, event timelines will fire all events between the `animationLast` time (exclusive) and
-       * `animationTime` (inclusive). Defaults to -1 to ensure triggers on frame 0 happen the first time this animation
-       * is applied. */
-      this.animationLast = 0;
-      this.nextAnimationLast = 0;
-      /** Seconds to postpone playing the animation. When this track entry is the current track entry, `delay`
-       * postpones incrementing the {@link #trackTime}. When this track entry is queued, `delay` is the time from
-       * the start of the previous animation to when this track entry will become the current track entry (ie when the previous
-       * track entry {@link TrackEntry#trackTime} >= this track entry's `delay`).
-       *
-       * {@link #timeScale} affects the delay. */
-      this.delay = 0;
-      /** Current time in seconds this track entry has been the current track entry. The track time determines
-       * {@link #animationTime}. The track time can be set to start the animation at a time other than 0, without affecting
-       * looping. */
-      this.trackTime = 0;
-      this.trackLast = 0;
-      this.nextTrackLast = 0;
-      /** The track time in seconds when this animation will be removed from the track. Defaults to the highest possible float
-       * value, meaning the animation will be applied until a new animation is set or the track is cleared. If the track end time
-       * is reached, no other animations are queued for playback, and mixing from any previous animations is complete, then the
-       * properties keyed by the animation are set to the setup pose and the track is cleared.
-       *
-       * It may be desired to use {@link AnimationState#addEmptyAnimation()} rather than have the animation
-       * abruptly cease being applied. */
-      this.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.
-       *
-       * {@link #mixTime} is not affected by track entry time scale, so {@link #mixDuration} may need to be adjusted to
-       * match the animation speed.
-       *
-       * When using {@link AnimationState#addAnimation()} with a `delay` <= 0, note the
-       * {@link #delay} is set using the mix duration from the {@link AnimationStateData}, assuming time scale to be 1. If
-       * the time scale is not 1, the delay may need to be adjusted.
-       *
-       * See AnimationState {@link AnimationState#timeScale} for affecting all animations. */
-      this.timeScale = 0;
-      /** Values < 1 mix this animation with the skeleton's current pose (usually the pose resulting from lower tracks). Defaults
-       * to 1, which overwrites the skeleton's current pose with this animation.
-       *
-       * Typically track 0 is used to completely pose the skeleton, then alpha is used on higher tracks. It doesn't make sense to
-       * use alpha on track 0 if the skeleton pose is from the last frame render. */
-      this.alpha = 0;
-      /** Seconds from 0 to the {@link #getMixDuration()} when mixing from the previous animation to this animation. May be
-       * slightly more than `mixDuration` when the mix is complete. */
-      this.mixTime = 0;
-      /** Seconds for mixing from the previous animation to this animation. Defaults to the value provided by AnimationStateData
-       * {@link AnimationStateData#getMix()} based on the animation before this animation (if any).
-       *
-       * A mix duration of 0 still mixes out over one frame to provide the track entry being mixed out a chance to revert the
-       * properties it was animating.
-       *
-       * The `mixDuration` can be set manually rather than use the value from
-       * {@link AnimationStateData#getMix()}. In that case, the `mixDuration` can be set for a new
-       * track entry only before {@link AnimationState#update(float)} is first called.
-       *
-       * 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. */
-      this.mixDuration = 0;
-      this.interruptAlpha = 0;
-      this.totalAlpha = 0;
-      /** 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.
-       *
-       * The `mixBlend` can be set for a new track entry only before {@link AnimationState#apply()} is first
-       * called. */
-      this.mixBlend = 2 /* replace */;
-      this.timelineMode = new Array();
-      this.timelineHoldMix = new Array();
-      this.timelinesRotation = new Array();
-    }
+    /** The animation to apply for this track entry. */
+    animation = null;
+    previous = null;
+    /** The animation queued to start after this animation, or null. `next` makes up a linked list. */
+    next = null;
+    /** The track entry for the previous animation when mixing from the previous animation to this animation, or null if no
+     * mixing is currently occuring. When mixing from multiple animations, `mixingFrom` makes up a linked list. */
+    mixingFrom = null;
+    /** The track entry for the next animation when mixing from this animation to the next animation, or null if no mixing is
+     * currently occuring. When mixing to multiple animations, `mixingTo` makes up a linked list. */
+    mixingTo = null;
+    /** The listener for events generated by this track entry, or null.
+     *
+     * A track entry returned from {@link AnimationState#setAnimation()} is already the current animation
+     * for the track, so the track entry listener {@link AnimationStateListener#start()} will not be called. */
+    listener = null;
+    /** The index of the track where this track entry is either current or queued.
+     *
+     * See {@link AnimationState#getCurrent()}. */
+    trackIndex = 0;
+    /** If true, the animation will repeat. If false it will not, instead its last frame is applied if played beyond its
+     * duration. */
+    loop = false;
+    /** If true, when mixing from the previous animation to this animation, the previous animation is applied as normal instead
+     * of being mixed out.
+     *
+     * When mixing between animations that key the same property, if a lower track also keys that property then the value will
+     * briefly dip toward the lower track value during the mix. This happens because the first animation mixes from 100% to 0%
+     * while the second animation mixes from 0% to 100%. Setting `holdPrevious` to true applies the first animation
+     * at 100% during the mix so the lower track value is overwritten. Such dipping does not occur on the lowest track which
+     * keys the property, only when a higher track also keys the property.
+     *
+     * Snapping will occur if `holdPrevious` is true and this animation does not key all the same properties as the
+     * previous animation. */
+    holdPrevious = false;
+    reverse = false;
+    shortestRotation = false;
+    /** When the mix percentage ({@link #mixTime} / {@link #mixDuration}) is less than the
+     * `eventThreshold`, event timelines are applied while this animation is being mixed out. Defaults to 0, so event
+     * timelines are not applied while this animation is being mixed out. */
+    eventThreshold = 0;
+    /** 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. */
+    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
+     * value to prevent timeline keys before the start time from triggering. */
+    animationStart = 0;
+    /** Seconds for the last frame of this animation. Non-looping animations won't play past this time. Looping animations will
+     * loop back to {@link #animationStart} at this time. Defaults to the animation {@link Animation#duration}. */
+    animationEnd = 0;
+    /** The time in seconds this animation was last applied. Some timelines use this for one-time triggers. Eg, when this
+     * animation is applied, event timelines will fire all events between the `animationLast` time (exclusive) and
+     * `animationTime` (inclusive). Defaults to -1 to ensure triggers on frame 0 happen the first time this animation
+     * is applied. */
+    animationLast = 0;
+    nextAnimationLast = 0;
+    /** Seconds to postpone playing the animation. When this track entry is the current track entry, `delay`
+     * postpones incrementing the {@link #trackTime}. When this track entry is queued, `delay` is the time from
+     * the start of the previous animation to when this track entry will become the current track entry (ie when the previous
+     * track entry {@link TrackEntry#trackTime} >= this track entry's `delay`).
+     *
+     * {@link #timeScale} affects the delay. */
+    delay = 0;
+    /** Current time in seconds this track entry has been the current track entry. The track time determines
+     * {@link #animationTime}. The track time can be set to start the animation at a time other than 0, without affecting
+     * looping. */
+    trackTime = 0;
+    trackLast = 0;
+    nextTrackLast = 0;
+    /** The track time in seconds when this animation will be removed from the track. Defaults to the highest possible float
+     * value, meaning the animation will be applied until a new animation is set or the track is cleared. If the track end time
+     * is reached, no other animations are queued for playback, and mixing from any previous animations is complete, then the
+     * properties keyed by the animation are set to the setup pose and the track is cleared.
+     *
+     * It may be desired to use {@link AnimationState#addEmptyAnimation()} rather than have the animation
+     * abruptly cease being applied. */
+    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.
+     *
+     * {@link #mixTime} is not affected by track entry time scale, so {@link #mixDuration} may need to be adjusted to
+     * match the animation speed.
+     *
+     * When using {@link AnimationState#addAnimation()} with a `delay` <= 0, note the
+     * {@link #delay} is set using the mix duration from the {@link AnimationStateData}, assuming time scale to be 1. If
+     * the time scale is not 1, the delay may need to be adjusted.
+     *
+     * See AnimationState {@link AnimationState#timeScale} for affecting all animations. */
+    timeScale = 0;
+    /** Values < 1 mix this animation with the skeleton's current pose (usually the pose resulting from lower tracks). Defaults
+     * to 1, which overwrites the skeleton's current pose with this animation.
+     *
+     * Typically track 0 is used to completely pose the skeleton, then alpha is used on higher tracks. It doesn't make sense to
+     * use alpha on track 0 if the skeleton pose is from the last frame render. */
+    alpha = 0;
+    /** Seconds from 0 to the {@link #getMixDuration()} when mixing from the previous animation to this animation. May be
+     * slightly more than `mixDuration` when the mix is complete. */
+    mixTime = 0;
+    /** Seconds for mixing from the previous animation to this animation. Defaults to the value provided by AnimationStateData
+     * {@link AnimationStateData#getMix()} based on the animation before this animation (if any).
+     *
+     * A mix duration of 0 still mixes out over one frame to provide the track entry being mixed out a chance to revert the
+     * properties it was animating.
+     *
+     * The `mixDuration` can be set manually rather than use the value from
+     * {@link AnimationStateData#getMix()}. In that case, the `mixDuration` can be set for a new
+     * track entry only before {@link AnimationState#update(float)} is first called.
+     *
+     * 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;
+    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.
+     *
+     * The `mixBlend` can be set for a new track entry only before {@link AnimationState#apply()} is first
+     * called. */
+    mixBlend = 2 /* replace */;
+    timelineMode = new Array();
+    timelineHoldMix = new Array();
+    timelinesRotation = new Array();
     reset() {
       this.next = null;
       this.previous = null;
@@ -4347,11 +4444,18 @@ 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 = [];
+    drainDisabled = false;
+    animState;
     constructor(animState) {
-      this.objects = [];
-      this.drainDisabled = false;
       this.animState = animState;
     }
     start(entry) {
@@ -4488,10 +4592,12 @@ var spine = (() => {
 
   // spine-core/src/AnimationStateData.ts
   var AnimationStateData = class {
+    /** The SkeletonData to look up animations when they are specified by name. */
+    skeletonData;
+    animationToMixTime = {};
+    /** The mix duration to use when no mix duration has been defined between two animations. */
+    defaultMix = 0;
     constructor(skeletonData) {
-      this.animationToMixTime = {};
-      /** The mix duration to use when no mix duration has been defined between two animations. */
-      this.defaultMix = 0;
       if (!skeletonData)
         throw new Error("skeletonData cannot be null.");
       this.skeletonData = skeletonData;
@@ -4530,9 +4636,9 @@ var spine = (() => {
 
   // spine-core/src/attachments/BoundingBoxAttachment.ts
   var BoundingBoxAttachment = class extends VertexAttachment {
+    color = new Color(1, 1, 1, 1);
     constructor(name) {
       super(name);
-      this.color = new Color(1, 1, 1, 1);
     }
     copy() {
       let copy = new BoundingBoxAttachment(this.name);
@@ -4544,16 +4650,16 @@ var spine = (() => {
 
   // spine-core/src/attachments/ClippingAttachment.ts
   var ClippingAttachment = class extends VertexAttachment {
+    /** Clipping is performed between the clipping polygon's slot and the end slot. Returns null if clipping is done until the end of
+     * the skeleton's rendering. */
+    endSlot = null;
+    // Nonessential.
+    /** The color of the clipping polygon as it was in Spine. Available only when nonessential data was exported. Clipping polygons
+     * are not usually rendered at runtime. */
+    color = new Color(0.2275, 0.2275, 0.8078, 1);
     // ce3a3aff
     constructor(name) {
       super(name);
-      /** Clipping is performed between the clipping polygon's slot and the end slot. Returns null if clipping is done until the end of
-       * the skeleton's rendering. */
-      this.endSlot = null;
-      // Nonessential.
-      /** The color of the clipping polygon as it was in Spine. Available only when nonessential data was exported. Clipping polygons
-       * are not usually rendered at runtime. */
-      this.color = new Color(0.2275, 0.2275, 0.8078, 1);
     }
     copy() {
       let copy = new ClippingAttachment(this.name);
@@ -4566,6 +4672,7 @@ var spine = (() => {
 
   // spine-core/src/Texture.ts
   var Texture = class {
+    _image;
     constructor(image) {
       this._image = image;
     }
@@ -4590,19 +4697,18 @@ var spine = (() => {
     return TextureWrap3;
   })(TextureWrap || {});
   var TextureRegion = class {
-    constructor() {
-      this.u = 0;
-      this.v = 0;
-      this.u2 = 0;
-      this.v2 = 0;
-      this.width = 0;
-      this.height = 0;
-      this.degrees = 0;
-      this.offsetX = 0;
-      this.offsetY = 0;
-      this.originalWidth = 0;
-      this.originalHeight = 0;
-    }
+    texture;
+    u = 0;
+    v = 0;
+    u2 = 0;
+    v2 = 0;
+    width = 0;
+    height = 0;
+    degrees = 0;
+    offsetX = 0;
+    offsetY = 0;
+    originalWidth = 0;
+    originalHeight = 0;
   };
   var FakeTexture = class extends Texture {
     setFilters(minFilter, magFilter) {
@@ -4615,9 +4721,9 @@ var spine = (() => {
 
   // spine-core/src/TextureAtlas.ts
   var TextureAtlas = class {
+    pages = new Array();
+    regions = new Array();
     constructor(atlasText) {
-      this.pages = new Array();
-      this.regions = new Array();
       let reader = new TextureAtlasReader(atlasText);
       let entry = new Array(4);
       let pageFields = {};
@@ -4765,15 +4871,15 @@ var spine = (() => {
         page.setTexture(assetManager.get(pathPrefix + page.name));
     }
     dispose() {
-      var _a;
       for (let i = 0; i < this.pages.length; i++) {
-        (_a = this.pages[i].texture) == null ? void 0 : _a.dispose();
+        this.pages[i].texture?.dispose();
       }
     }
   };
   var TextureAtlasReader = class {
+    lines;
+    index = 0;
     constructor(text) {
-      this.index = 0;
       this.lines = text.split(/\r\n|\r|\n/);
     }
     readLine() {
@@ -4805,16 +4911,17 @@ var spine = (() => {
     }
   };
   var TextureAtlasPage = class {
+    name;
+    minFilter = 9728 /* Nearest */;
+    magFilter = 9728 /* Nearest */;
+    uWrap = 33071 /* ClampToEdge */;
+    vWrap = 33071 /* ClampToEdge */;
+    texture = null;
+    width = 0;
+    height = 0;
+    pma = false;
+    regions = new Array();
     constructor(name) {
-      this.minFilter = 9728 /* Nearest */;
-      this.magFilter = 9728 /* Nearest */;
-      this.uWrap = 33071 /* ClampToEdge */;
-      this.vWrap = 33071 /* ClampToEdge */;
-      this.texture = null;
-      this.width = 0;
-      this.height = 0;
-      this.pma = false;
-      this.regions = new Array();
       this.name = name;
     }
     setTexture(texture) {
@@ -4826,18 +4933,20 @@ var spine = (() => {
     }
   };
   var TextureAtlasRegion = class extends TextureRegion {
+    page;
+    name;
+    x = 0;
+    y = 0;
+    offsetX = 0;
+    offsetY = 0;
+    originalWidth = 0;
+    originalHeight = 0;
+    index = 0;
+    degrees = 0;
+    names = null;
+    values = null;
     constructor(page, name) {
       super();
-      this.x = 0;
-      this.y = 0;
-      this.offsetX = 0;
-      this.offsetY = 0;
-      this.originalWidth = 0;
-      this.originalHeight = 0;
-      this.index = 0;
-      this.degrees = 0;
-      this.names = null;
-      this.values = null;
       this.page = page;
       this.name = name;
       page.regions.push(this);
@@ -4846,31 +4955,33 @@ var spine = (() => {
 
   // spine-core/src/attachments/MeshAttachment.ts
   var MeshAttachment = class extends VertexAttachment {
+    region = null;
+    /** The name of the texture region for this attachment. */
+    path;
+    /** The UV pair for each vertex, normalized within the texture region. */
+    regionUVs = [];
+    /** The UV pair for each vertex, normalized within the entire texture.
+     *
+     * See {@link #updateUVs}. */
+    uvs = [];
+    /** Triplets of vertex indices which describe the mesh's triangulation. */
+    triangles = [];
+    /** The color to tint the mesh. */
+    color = new Color(1, 1, 1, 1);
+    /** The width of the mesh's image. Available only when nonessential data was exported. */
+    width = 0;
+    /** The height of the mesh's image. Available only when nonessential data was exported. */
+    height = 0;
+    /** The number of entries at the beginning of {@link #vertices} that make up the mesh hull. */
+    hullLength = 0;
+    /** Vertex index pairs describing edges for controling triangulation. Mesh triangles will never cross edges. Only available if
+     * nonessential data was exported. Triangulation is not performed at runtime. */
+    edges = [];
+    parentMesh = null;
+    sequence = null;
+    tempColor = new Color(0, 0, 0, 0);
     constructor(name, path) {
       super(name);
-      this.region = null;
-      /** The UV pair for each vertex, normalized within the texture region. */
-      this.regionUVs = [];
-      /** The UV pair for each vertex, normalized within the entire texture.
-       *
-       * See {@link #updateUVs}. */
-      this.uvs = [];
-      /** Triplets of vertex indices which describe the mesh's triangulation. */
-      this.triangles = [];
-      /** The color to tint the mesh. */
-      this.color = new Color(1, 1, 1, 1);
-      /** The width of the mesh's image. Available only when nonessential data was exported. */
-      this.width = 0;
-      /** The height of the mesh's image. Available only when nonessential data was exported. */
-      this.height = 0;
-      /** The number of entries at the beginning of {@link #vertices} that make up the mesh hull. */
-      this.hullLength = 0;
-      /** Vertex index pairs describing edges for controling triangulation. Mesh triangles will never cross edges. Only available if
-       * nonessential data was exported. Triangulation is not performed at runtime. */
-      this.edges = [];
-      this.parentMesh = null;
-      this.sequence = null;
-      this.tempColor = new Color(0, 0, 0, 0);
       this.path = path;
     }
     /** Calculates {@link #uvs} using the {@link #regionUVs} and region. Must be called if the region, the region's properties, or
@@ -4997,18 +5108,18 @@ var spine = (() => {
 
   // spine-core/src/attachments/PathAttachment.ts
   var PathAttachment = class extends VertexAttachment {
+    /** The lengths along the path in the setup pose from the start of the path to the end of each Bezier curve. */
+    lengths = [];
+    /** If true, the start and end knots are connected. */
+    closed = false;
+    /** If true, additional calculations are performed to make calculating positions along the path more accurate. If false, fewer
+     * calculations are performed but calculating positions along the path is less accurate. */
+    constantSpeed = false;
+    /** The color of the path as it was in Spine. Available only when nonessential data was exported. Paths are not usually
+     * rendered at runtime. */
+    color = new Color(1, 1, 1, 1);
     constructor(name) {
       super(name);
-      /** The lengths along the path in the setup pose from the start of the path to the end of each Bezier curve. */
-      this.lengths = [];
-      /** If true, the start and end knots are connected. */
-      this.closed = false;
-      /** If true, additional calculations are performed to make calculating positions along the path more accurate. If false, fewer
-       * calculations are performed but calculating positions along the path is less accurate. */
-      this.constantSpeed = false;
-      /** The color of the path as it was in Spine. Available only when nonessential data was exported. Paths are not usually
-       * rendered at runtime. */
-      this.color = new Color(1, 1, 1, 1);
     }
     copy() {
       let copy = new PathAttachment(this.name);
@@ -5024,14 +5135,14 @@ var spine = (() => {
 
   // spine-core/src/attachments/PointAttachment.ts
   var PointAttachment = class extends VertexAttachment {
+    x = 0;
+    y = 0;
+    rotation = 0;
+    /** The color of the point attachment as it was in Spine. Available only when nonessential data was exported. Point attachments
+     * are not usually rendered at runtime. */
+    color = new Color(0.38, 0.94, 0, 1);
     constructor(name) {
       super(name);
-      this.x = 0;
-      this.y = 0;
-      this.rotation = 0;
-      /** The color of the point attachment as it was in Spine. Available only when nonessential data was exported. Point attachments
-       * are not usually rendered at runtime. */
-      this.color = new Color(0.38, 0.94, 0, 1);
     }
     computeWorldPosition(bone, point) {
       point.x = this.x * bone.a + this.y * bone.b + bone.worldX;
@@ -5039,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);
@@ -5056,32 +5167,34 @@ var spine = (() => {
 
   // spine-core/src/attachments/RegionAttachment.ts
   var _RegionAttachment = class extends Attachment {
+    /** The local x translation. */
+    x = 0;
+    /** The local y translation. */
+    y = 0;
+    /** The local scaleX. */
+    scaleX = 1;
+    /** The local scaleY. */
+    scaleY = 1;
+    /** The local rotation. */
+    rotation = 0;
+    /** The width of the region attachment in Spine. */
+    width = 0;
+    /** The height of the region attachment in Spine. */
+    height = 0;
+    /** The color to tint the region attachment. */
+    color = new Color(1, 1, 1, 1);
+    /** The name of the texture region for this attachment. */
+    path;
+    region = null;
+    sequence = null;
+    /** For each of the 4 vertices, a pair of <code>x,y</code> values that is the local position of the vertex.
+     *
+     * See {@link #updateOffset()}. */
+    offset = Utils.newFloatArray(8);
+    uvs = Utils.newFloatArray(8);
+    tempColor = new Color(1, 1, 1, 1);
     constructor(name, path) {
       super(name);
-      /** The local x translation. */
-      this.x = 0;
-      /** The local y translation. */
-      this.y = 0;
-      /** The local scaleX. */
-      this.scaleX = 1;
-      /** The local scaleY. */
-      this.scaleY = 1;
-      /** The local rotation. */
-      this.rotation = 0;
-      /** The width of the region attachment in Spine. */
-      this.width = 0;
-      /** The height of the region attachment in Spine. */
-      this.height = 0;
-      /** The color to tint the region attachment. */
-      this.color = new Color(1, 1, 1, 1);
-      this.region = null;
-      this.sequence = null;
-      /** For each of the 4 vertices, a pair of <code>x,y</code> values that is the local position of the vertex.
-       *
-       * See {@link #updateOffset()}. */
-      this.offset = Utils.newFloatArray(8);
-      this.uvs = Utils.newFloatArray(8);
-      this.tempColor = new Color(1, 1, 1, 1);
       this.path = path;
     }
     /** Calculates the {@link #offset} using the region settings. Must be called after changing region settings. */
@@ -5107,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;
@@ -5202,41 +5315,42 @@ var spine = (() => {
     }
   };
   var RegionAttachment = _RegionAttachment;
-  RegionAttachment.X1 = 0;
-  RegionAttachment.Y1 = 1;
-  RegionAttachment.C1R = 2;
-  RegionAttachment.C1G = 3;
-  RegionAttachment.C1B = 4;
-  RegionAttachment.C1A = 5;
-  RegionAttachment.U1 = 6;
-  RegionAttachment.V1 = 7;
-  RegionAttachment.X2 = 8;
-  RegionAttachment.Y2 = 9;
-  RegionAttachment.C2R = 10;
-  RegionAttachment.C2G = 11;
-  RegionAttachment.C2B = 12;
-  RegionAttachment.C2A = 13;
-  RegionAttachment.U2 = 14;
-  RegionAttachment.V2 = 15;
-  RegionAttachment.X3 = 16;
-  RegionAttachment.Y3 = 17;
-  RegionAttachment.C3R = 18;
-  RegionAttachment.C3G = 19;
-  RegionAttachment.C3B = 20;
-  RegionAttachment.C3A = 21;
-  RegionAttachment.U3 = 22;
-  RegionAttachment.V3 = 23;
-  RegionAttachment.X4 = 24;
-  RegionAttachment.Y4 = 25;
-  RegionAttachment.C4R = 26;
-  RegionAttachment.C4G = 27;
-  RegionAttachment.C4B = 28;
-  RegionAttachment.C4A = 29;
-  RegionAttachment.U4 = 30;
-  RegionAttachment.V4 = 31;
+  __publicField(RegionAttachment, "X1", 0);
+  __publicField(RegionAttachment, "Y1", 1);
+  __publicField(RegionAttachment, "C1R", 2);
+  __publicField(RegionAttachment, "C1G", 3);
+  __publicField(RegionAttachment, "C1B", 4);
+  __publicField(RegionAttachment, "C1A", 5);
+  __publicField(RegionAttachment, "U1", 6);
+  __publicField(RegionAttachment, "V1", 7);
+  __publicField(RegionAttachment, "X2", 8);
+  __publicField(RegionAttachment, "Y2", 9);
+  __publicField(RegionAttachment, "C2R", 10);
+  __publicField(RegionAttachment, "C2G", 11);
+  __publicField(RegionAttachment, "C2B", 12);
+  __publicField(RegionAttachment, "C2A", 13);
+  __publicField(RegionAttachment, "U2", 14);
+  __publicField(RegionAttachment, "V2", 15);
+  __publicField(RegionAttachment, "X3", 16);
+  __publicField(RegionAttachment, "Y3", 17);
+  __publicField(RegionAttachment, "C3R", 18);
+  __publicField(RegionAttachment, "C3G", 19);
+  __publicField(RegionAttachment, "C3B", 20);
+  __publicField(RegionAttachment, "C3A", 21);
+  __publicField(RegionAttachment, "U3", 22);
+  __publicField(RegionAttachment, "V3", 23);
+  __publicField(RegionAttachment, "X4", 24);
+  __publicField(RegionAttachment, "Y4", 25);
+  __publicField(RegionAttachment, "C4R", 26);
+  __publicField(RegionAttachment, "C4G", 27);
+  __publicField(RegionAttachment, "C4B", 28);
+  __publicField(RegionAttachment, "C4A", 29);
+  __publicField(RegionAttachment, "U4", 30);
+  __publicField(RegionAttachment, "V4", 31);
 
   // spine-core/src/AtlasAttachmentLoader.ts
   var AtlasAttachmentLoader = class {
+    atlas;
     constructor(atlas) {
       this.atlas = atlas;
     }
@@ -5290,36 +5404,42 @@ var spine = (() => {
 
   // spine-core/src/BoneData.ts
   var BoneData = class {
+    /** The index of the bone in {@link Skeleton#getBones()}. */
+    index = 0;
+    /** The name of the bone, which is unique across all bones in the skeleton. */
+    name;
+    /** @returns May be null. */
+    parent = null;
+    /** The bone's length. */
+    length = 0;
+    /** The local x translation. */
+    x = 0;
+    /** The local y translation. */
+    y = 0;
+    /** The local rotation in degrees, counter clockwise. */
+    rotation = 0;
+    /** The local scaleX. */
+    scaleX = 1;
+    /** The local scaleY. */
+    scaleY = 1;
+    /** The local shearX. */
+    shearX = 0;
+    /** The local shearX. */
+    shearY = 0;
+    /** The transform mode for how parent world transforms affect this bone. */
+    transformMode = TransformMode.Normal;
+    /** When true, {@link Skeleton#updateWorldTransform()} only updates this bone if the {@link Skeleton#skin} contains this
+      * bone.
+      * @see Skin#bones */
+    skinRequired = false;
+    /** 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) {
-      /** The index of the bone in {@link Skeleton#getBones()}. */
-      this.index = 0;
-      /** @returns May be null. */
-      this.parent = null;
-      /** The bone's length. */
-      this.length = 0;
-      /** The local x translation. */
-      this.x = 0;
-      /** The local y translation. */
-      this.y = 0;
-      /** The local rotation. */
-      this.rotation = 0;
-      /** The local scaleX. */
-      this.scaleX = 1;
-      /** The local scaleY. */
-      this.scaleY = 1;
-      /** The local shearX. */
-      this.shearX = 0;
-      /** The local shearX. */
-      this.shearY = 0;
-      /** The transform mode for how parent world transforms affect this bone. */
-      this.transformMode = TransformMode.Normal;
-      /** When true, {@link Skeleton#updateWorldTransform()} only updates this bone if the {@link Skeleton#skin} contains this
-        * bone.
-        * @see Skin#bones */
-      this.skinRequired = false;
-      /** The color of the bone as it was in Spine. Available only when nonessential data was exported. Bones are not usually
-       * rendered at runtime. */
-      this.color = new Color();
       if (index < 0)
         throw new Error("index must be >= 0.");
       if (!name)
@@ -5340,54 +5460,58 @@ var spine = (() => {
 
   // spine-core/src/Bone.ts
   var Bone = class {
+    /** The bone's setup pose data. */
+    data;
+    /** The skeleton this bone belongs to. */
+    skeleton;
+    /** The parent bone, or null if this is the root bone. */
+    parent = null;
+    /** The immediate children of this bone. */
+    children = new Array();
+    /** The local x translation. */
+    x = 0;
+    /** The local y translation. */
+    y = 0;
+    /** The local rotation in degrees, counter clockwise. */
+    rotation = 0;
+    /** The local scaleX. */
+    scaleX = 0;
+    /** The local scaleY. */
+    scaleY = 0;
+    /** The local shearX. */
+    shearX = 0;
+    /** The local shearY. */
+    shearY = 0;
+    /** The applied local x translation. */
+    ax = 0;
+    /** The applied local y translation. */
+    ay = 0;
+    /** The applied local rotation in degrees, counter clockwise. */
+    arotation = 0;
+    /** The applied local scaleX. */
+    ascaleX = 0;
+    /** The applied local scaleY. */
+    ascaleY = 0;
+    /** The applied local shearX. */
+    ashearX = 0;
+    /** The applied local shearY. */
+    ashearY = 0;
+    /** Part of the world transform matrix for the X axis. If changed, {@link #updateAppliedTransform()} should be called. */
+    a = 0;
+    /** Part of the world transform matrix for the Y axis. If changed, {@link #updateAppliedTransform()} should be called. */
+    b = 0;
+    /** Part of the world transform matrix for the X axis. If changed, {@link #updateAppliedTransform()} should be called. */
+    c = 0;
+    /** Part of the world transform matrix for the Y axis. If changed, {@link #updateAppliedTransform()} should be called. */
+    d = 0;
+    /** The world X position. If changed, {@link #updateAppliedTransform()} should be called. */
+    worldY = 0;
+    /** The world Y position. If changed, {@link #updateAppliedTransform()} should be called. */
+    worldX = 0;
+    sorted = false;
+    active = false;
     /** @param parent May be null. */
     constructor(data, skeleton, parent) {
-      /** The parent bone, or null if this is the root bone. */
-      this.parent = null;
-      /** The immediate children of this bone. */
-      this.children = new Array();
-      /** The local x translation. */
-      this.x = 0;
-      /** The local y translation. */
-      this.y = 0;
-      /** The local rotation in degrees, counter clockwise. */
-      this.rotation = 0;
-      /** The local scaleX. */
-      this.scaleX = 0;
-      /** The local scaleY. */
-      this.scaleY = 0;
-      /** The local shearX. */
-      this.shearX = 0;
-      /** The local shearY. */
-      this.shearY = 0;
-      /** The applied local x translation. */
-      this.ax = 0;
-      /** The applied local y translation. */
-      this.ay = 0;
-      /** The applied local rotation in degrees, counter clockwise. */
-      this.arotation = 0;
-      /** The applied local scaleX. */
-      this.ascaleX = 0;
-      /** The applied local scaleY. */
-      this.ascaleY = 0;
-      /** The applied local shearX. */
-      this.ashearX = 0;
-      /** The applied local shearY. */
-      this.ashearY = 0;
-      /** Part of the world transform matrix for the X axis. If changed, {@link #updateAppliedTransform()} should be called. */
-      this.a = 0;
-      /** Part of the world transform matrix for the Y axis. If changed, {@link #updateAppliedTransform()} should be called. */
-      this.b = 0;
-      /** Part of the world transform matrix for the X axis. If changed, {@link #updateAppliedTransform()} should be called. */
-      this.c = 0;
-      /** Part of the world transform matrix for the Y axis. If changed, {@link #updateAppliedTransform()} should be called. */
-      this.d = 0;
-      /** The world X position. If changed, {@link #updateAppliedTransform()} should be called. */
-      this.worldY = 0;
-      /** The world Y position. If changed, {@link #updateAppliedTransform()} should be called. */
-      this.worldX = 0;
-      this.sorted = false;
-      this.active = false;
       if (!data)
         throw new Error("data cannot be null.");
       if (!skeleton)
@@ -5403,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.
@@ -5428,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;
@@ -5444,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;
@@ -5456,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 */: {
@@ -5478,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;
@@ -5492,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);
@@ -5504,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;
@@ -5534,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
@@ -5636,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);
@@ -5651,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);
@@ -5664,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;
     }
   };
 
@@ -5687,12 +5828,14 @@ var spine = (() => {
 
   // spine-core/src/AssetManagerBase.ts
   var AssetManagerBase = class {
+    pathPrefix = "";
+    textureLoader;
+    downloader;
+    assets = {};
+    errors = {};
+    toLoad = 0;
+    loaded = 0;
     constructor(textureLoader, pathPrefix = "", downloader = new Downloader()) {
-      this.pathPrefix = "";
-      this.assets = {};
-      this.errors = {};
-      this.toLoad = 0;
-      this.loaded = 0;
       this.textureLoader = textureLoader;
       this.pathPrefix = pathPrefix;
       this.downloader = downloader;
@@ -5877,10 +6020,8 @@ var spine = (() => {
     }
   };
   var Downloader = class {
-    constructor() {
-      this.callbacks = {};
-      this.rawDataUris = {};
-    }
+    callbacks = {};
+    rawDataUris = {};
     dataUriToString(dataUri) {
       if (!dataUri.startsWith("data:")) {
         throw new Error("Not a data URI.");
@@ -5987,13 +6128,14 @@ var spine = (() => {
 
   // spine-core/src/Event.ts
   var Event = class {
+    data;
+    intValue = 0;
+    floatValue = 0;
+    stringValue = null;
+    time = 0;
+    volume = 0;
+    balance = 0;
     constructor(time, data) {
-      this.intValue = 0;
-      this.floatValue = 0;
-      this.stringValue = null;
-      this.time = 0;
-      this.volume = 0;
-      this.balance = 0;
       if (!data)
         throw new Error("data cannot be null.");
       this.time = time;
@@ -6003,32 +6145,39 @@ var spine = (() => {
 
   // spine-core/src/EventData.ts
   var EventData = class {
+    name;
+    intValue = 0;
+    floatValue = 0;
+    stringValue = null;
+    audioPath = null;
+    volume = 0;
+    balance = 0;
     constructor(name) {
-      this.intValue = 0;
-      this.floatValue = 0;
-      this.stringValue = null;
-      this.audioPath = null;
-      this.volume = 0;
-      this.balance = 0;
       this.name = name;
     }
   };
 
   // spine-core/src/IkConstraint.ts
   var IkConstraint = class {
+    /** The IK constraint's setup pose data. */
+    data;
+    /** The bones that will be modified by this IK constraint. */
+    bones;
+    /** The bone that is the IK target. */
+    target;
+    /** Controls the bend direction of the IK bones, either 1 or -1. */
+    bendDirection = 0;
+    /** When true and only a single bone is being constrained, if the target is too close, the bone is scaled to reach it. */
+    compress = false;
+    /** When true, if the target is out of range, the parent bone is scaled to reach it. If more than one bone is being constrained
+     * and the parent bone has local nonuniform scale, stretch is not applied. */
+    stretch = false;
+    /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
+    mix = 1;
+    /** For two bone IK, the distance from the maximum reach of the bones that rotation will slow. */
+    softness = 0;
+    active = false;
     constructor(data, skeleton) {
-      /** Controls the bend direction of the IK bones, either 1 or -1. */
-      this.bendDirection = 0;
-      /** When true and only a single bone is being constrained, if the target is too close, the bone is scaled to reach it. */
-      this.compress = false;
-      /** When true, if the target is out of range, the parent bone is scaled to reach it. If more than one bone is being constrained
-       * and the parent bone has local nonuniform scale, stretch is not applied. */
-      this.stretch = false;
-      /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
-      this.mix = 1;
-      /** For two bone IK, the distance from the maximum reach of the bones that rotation will slow. */
-      this.softness = 0;
-      this.active = false;
       if (!data)
         throw new Error("data cannot be null.");
       if (!skeleton)
@@ -6054,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;
@@ -6113,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(
@@ -6286,27 +6446,10 @@ var spine = (() => {
 
   // spine-core/src/IkConstraintData.ts
   var IkConstraintData = class extends ConstraintData {
-    constructor(name) {
-      super(name, 0, false);
-      /** The bones that are constrained by this IK constraint. */
-      this.bones = new Array();
-      /** The bone that is the IK target. */
-      this._target = null;
-      /** Controls the bend direction of the IK bones, either 1 or -1. */
-      this.bendDirection = 1;
-      /** When true and only a single bone is being constrained, if the target is too close, the bone is scaled to reach it. */
-      this.compress = false;
-      /** When true, if the target is out of range, the parent bone is scaled to reach it. If more than one bone is being constrained
-       * and the parent bone has local nonuniform scale, stretch is not applied. */
-      this.stretch = false;
-      /** When true, only a single bone is being constrained, and {@link #getCompress()} or {@link #getStretch()} is used, the bone
-       * is scaled on both the X and Y axes. */
-      this.uniform = false;
-      /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
-      this.mix = 1;
-      /** For two bone IK, the distance from the maximum reach of the bones that rotation will slow. */
-      this.softness = 0;
-    }
+    /** The bones that are constrained by this IK constraint. */
+    bones = new Array();
+    /** The bone that is the IK target. */
+    _target = null;
     set target(boneData) {
       this._target = boneData;
     }
@@ -6316,32 +6459,31 @@ var spine = (() => {
       else
         return this._target;
     }
+    /** Controls the bend direction of the IK bones, either 1 or -1. */
+    bendDirection = 1;
+    /** When true and only a single bone is being constrained, if the target is too close, the bone is scaled to reach it. */
+    compress = false;
+    /** When true, if the target is out of range, the parent bone is scaled to reach it. If more than one bone is being constrained
+     * and the parent bone has local nonuniform scale, stretch is not applied. */
+    stretch = false;
+    /** When true, only a single bone is being constrained, and {@link #getCompress()} or {@link #getStretch()} is used, the bone
+     * is scaled on both the X and Y axes. */
+    uniform = false;
+    /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
+    mix = 1;
+    /** For two bone IK, the distance from the maximum reach of the bones that rotation will slow. */
+    softness = 0;
+    constructor(name) {
+      super(name, 0, false);
+    }
   };
 
   // spine-core/src/PathConstraintData.ts
   var PathConstraintData = class extends ConstraintData {
-    constructor(name) {
-      super(name, 0, false);
-      /** The bones that will be modified by this path constraint. */
-      this.bones = new Array();
-      /** The slot whose path attachment will be used to constrained the bones. */
-      this._target = null;
-      /** The mode for positioning the first bone on the path. */
-      this.positionMode = PositionMode.Fixed;
-      /** The mode for positioning the bones after the first bone on the path. */
-      this.spacingMode = SpacingMode.Fixed;
-      /** The mode for adjusting the rotation of the bones. */
-      this.rotateMode = RotateMode.Chain;
-      /** An offset added to the constrained bone rotation. */
-      this.offsetRotation = 0;
-      /** The position along the path. */
-      this.position = 0;
-      /** The spacing between bones. */
-      this.spacing = 0;
-      this.mixRotate = 0;
-      this.mixX = 0;
-      this.mixY = 0;
-    }
+    /** The bones that will be modified by this path constraint. */
+    bones = new Array();
+    /** The slot whose path attachment will be used to constrained the bones. */
+    _target = null;
     set target(slotData) {
       this._target = slotData;
     }
@@ -6351,6 +6493,24 @@ var spine = (() => {
       else
         return this._target;
     }
+    /** The mode for positioning the first bone on the path. */
+    positionMode = PositionMode.Fixed;
+    /** The mode for positioning the bones after the first bone on the path. */
+    spacingMode = SpacingMode.Fixed;
+    /** The mode for adjusting the rotation of the bones. */
+    rotateMode = RotateMode.Chain;
+    /** An offset added to the constrained bone rotation. */
+    offsetRotation = 0;
+    /** The position along the path. */
+    position = 0;
+    /** The spacing between bones. */
+    spacing = 0;
+    mixRotate = 0;
+    mixX = 0;
+    mixY = 0;
+    constructor(name) {
+      super(name, 0, false);
+    }
   };
   var PositionMode = /* @__PURE__ */ ((PositionMode2) => {
     PositionMode2[PositionMode2["Fixed"] = 0] = "Fixed";
@@ -6373,21 +6533,27 @@ var spine = (() => {
 
   // spine-core/src/PathConstraint.ts
   var _PathConstraint = class {
+    /** The path constraint's setup pose data. */
+    data;
+    /** The bones that will be modified by this path constraint. */
+    bones;
+    /** The slot whose path attachment will be used to constrained the bones. */
+    target;
+    /** The position along the path. */
+    position = 0;
+    /** The spacing between bones. */
+    spacing = 0;
+    mixRotate = 0;
+    mixX = 0;
+    mixY = 0;
+    spaces = new Array();
+    positions = new Array();
+    world = new Array();
+    curves = new Array();
+    lengths = new Array();
+    segments = new Array();
+    active = false;
     constructor(data, skeleton) {
-      /** The position along the path. */
-      this.position = 0;
-      /** The spacing between bones. */
-      this.spacing = 0;
-      this.mixRotate = 0;
-      this.mixX = 0;
-      this.mixY = 0;
-      this.spaces = new Array();
-      this.positions = new Array();
-      this.world = new Array();
-      this.curves = new Array();
-      this.lengths = new Array();
-      this.segments = new Array();
-      this.active = false;
       if (!data)
         throw new Error("data cannot be null.");
       if (!skeleton)
@@ -6413,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;
@@ -6432,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);
@@ -6807,27 +6977,266 @@ var spine = (() => {
     }
   };
   var PathConstraint = _PathConstraint;
-  PathConstraint.NONE = -1;
-  PathConstraint.BEFORE = -2;
-  PathConstraint.AFTER = -3;
-  PathConstraint.epsilon = 1e-5;
+  __publicField(PathConstraint, "NONE", -1);
+  __publicField(PathConstraint, "BEFORE", -2);
+  __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. */
+    data;
+    /** The bone this slot belongs to. */
+    bone;
+    /** The color used to tint the slot's attachment. If {@link #getDarkColor()} is set, this is used as the light color for two
+     * color tinting. */
+    color;
+    /** The dark color used to tint the slot's attachment for two color tinting, or null if two color tinting is not used. The dark
+     * color's alpha is not used. */
+    darkColor = null;
+    attachment = null;
+    attachmentState = 0;
+    /** The index of the texture region to display when the slot's attachment has a {@link Sequence}. -1 represents the
+     * {@link Sequence#getSetupIndex()}. */
+    sequenceIndex = -1;
+    /** Values to deform the slot's attachment. For an unweighted mesh, the entries are local positions for each vertex. For a
+     * weighted mesh, the entries are an offset for each vertex which will be added to the mesh's local vertex positions.
+     *
+     * See {@link VertexAttachment#computeWorldVertices()} and {@link DeformTimeline}. */
+    deform = new Array();
     constructor(data, bone) {
-      /** The dark color used to tint the slot's attachment for two color tinting, or null if two color tinting is not used. The dark
-       * color's alpha is not used. */
-      this.darkColor = null;
-      this.attachment = null;
-      this.attachmentState = 0;
-      /** The index of the texture region to display when the slot's attachment has a {@link Sequence}. -1 represents the
-       * {@link Sequence#getSetupIndex()}. */
-      this.sequenceIndex = -1;
-      /** Values to deform the slot's attachment. For an unweighted mesh, the entries are local positions for each vertex. For a
-       * weighted mesh, the entries are an offset for each vertex which will be added to the mesh's local vertex positions.
-       *
-       * See {@link VertexAttachment#computeWorldVertices()} and {@link DeformTimeline}. */
-      this.deform = new Array();
       if (!data)
         throw new Error("data cannot be null.");
       if (!bone)
@@ -6874,15 +7283,21 @@ var spine = (() => {
 
   // spine-core/src/TransformConstraint.ts
   var TransformConstraint = class {
+    /** The transform constraint's setup pose data. */
+    data;
+    /** The bones that will be modified by this transform constraint. */
+    bones;
+    /** The target bone whose world transform will be copied to the constrained bones. */
+    target;
+    mixRotate = 0;
+    mixX = 0;
+    mixY = 0;
+    mixScaleX = 0;
+    mixScaleY = 0;
+    mixShearY = 0;
+    temp = new Vector2();
+    active = false;
     constructor(data, skeleton) {
-      this.mixRotate = 0;
-      this.mixX = 0;
-      this.mixY = 0;
-      this.mixScaleX = 0;
-      this.mixScaleY = 0;
-      this.mixShearY = 0;
-      this.temp = new Vector2();
-      this.active = false;
       if (!data)
         throw new Error("data cannot be null.");
       if (!skeleton)
@@ -6909,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) {
@@ -7049,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;
@@ -7063,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);
@@ -7088,21 +7512,49 @@ var spine = (() => {
 
   // spine-core/src/Skeleton.ts
   var _Skeleton = class {
+    /** The skeleton's setup pose data. */
+    data;
+    /** The skeleton's bones, sorted parent first. The root bone is always the first bone. */
+    bones;
+    /** The skeleton's slots. */
+    slots;
+    /** The skeleton's slots in the order they should be drawn. The returned array may be modified to change the draw order. */
+    drawOrder;
+    /** The skeleton's IK constraints. */
+    ikConstraints;
+    /** The skeleton's transform constraints. */
+    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. */
+    skin = null;
+    /** The color to tint all the skeleton's attachments. */
+    color;
+    /** Scales the entire skeleton on the X axis. This affects all bones, even if the bone's transform mode disallows scale
+      * inheritance. */
+    scaleX = 1;
+    /** Scales the entire skeleton on the Y axis. This affects all bones, even if the bone's transform mode disallows scale
+      * inheritance. */
+    _scaleY = 1;
+    get scaleY() {
+      return _Skeleton.yDown ? -this._scaleY : this._scaleY;
+    }
+    set scaleY(scaleY) {
+      this._scaleY = scaleY;
+    }
+    /** Sets the skeleton X position, which is added to the root bone worldX position. */
+    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) {
-      /** The list of bones and constraints, sorted in the order they should be updated, as computed by {@link #updateCache()}. */
-      this._updateCache = new Array();
-      /** The skeleton's current skin. May be null. */
-      this.skin = null;
-      /** Scales the entire skeleton on the X axis. This affects all bones, even if the bone's transform mode disallows scale
-        * inheritance. */
-      this.scaleX = 1;
-      /** Scales the entire skeleton on the Y axis. This affects all bones, even if the bone's transform mode disallows scale
-        * inheritance. */
-      this._scaleY = 1;
-      /** Sets the skeleton X position, which is added to the root bone worldX position. */
-      this.x = 0;
-      /** Sets the skeleton Y position, which is added to the root bone worldY position. */
-      this.y = 0;
       if (!data)
         throw new Error("data cannot be null.");
       this.data = data;
@@ -7143,15 +7595,14 @@ 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();
     }
-    get scaleY() {
-      return _Skeleton.yDown ? -this._scaleY : this._scaleY;
-    }
-    set scaleY(scaleY) {
-      this._scaleY = scaleY;
-    }
     /** Caches information about bones and constraints. Must be called if the {@link #getSkin()} is modified or if bones,
      * constraints, or weighted path attachments are added or removed. */
     updateCache() {
@@ -7177,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++) {
@@ -7202,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]);
@@ -7300,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;
@@ -7325,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];
@@ -7339,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;
@@ -7361,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. */
@@ -7371,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() {
@@ -7541,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.
@@ -7555,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.
@@ -7569,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. */
@@ -7626,57 +8064,68 @@ 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;
-  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 {
-    constructor() {
-      /** The skeleton's name, which by default is the name of the skeleton data file, if possible. May be null. */
-      this.name = null;
-      /** The skeleton's bones, sorted parent first. The root bone is always the first bone. */
-      this.bones = new Array();
-      // Ordered parents first.
-      /** The skeleton's slots. */
-      this.slots = new Array();
-      // Setup pose draw order.
-      this.skins = new Array();
-      /** The skeleton's default skin. By default this skin contains all attachments that were not in a skin in Spine.
-       *
-       * See {@link Skeleton#getAttachmentByName()}.
-       * May be null. */
-      this.defaultSkin = null;
-      /** The skeleton's events. */
-      this.events = new Array();
-      /** The skeleton's animations. */
-      this.animations = new Array();
-      /** The skeleton's IK constraints. */
-      this.ikConstraints = new Array();
-      /** The skeleton's transform constraints. */
-      this.transformConstraints = new Array();
-      /** The skeleton's path constraints. */
-      this.pathConstraints = new Array();
-      /** The X coordinate of the skeleton's axis aligned bounding box in the setup pose. */
-      this.x = 0;
-      /** The Y coordinate of the skeleton's axis aligned bounding box in the setup pose. */
-      this.y = 0;
-      /** The width of the skeleton's axis aligned bounding box in the setup pose. */
-      this.width = 0;
-      /** The height of the skeleton's axis aligned bounding box in the setup pose. */
-      this.height = 0;
-      /** The Spine version used to export the skeleton data, or null. */
-      this.version = null;
-      /** The skeleton data hash. This value will change if any of the skeleton data has changed. May be null. */
-      this.hash = null;
-      // Nonessential
-      /** The dopesheet FPS in Spine. Available only when nonessential data was exported. */
-      this.fps = 0;
-      /** The path to the images directory as defined in Spine. Available only when nonessential data was exported. May be null. */
-      this.imagesPath = null;
-      /** The path to the audio directory as defined in Spine. Available only when nonessential data was exported. May be null. */
-      this.audioPath = null;
-    }
+    /** The skeleton's name, which by default is the name of the skeleton data file, if possible. May be null. */
+    name = null;
+    /** The skeleton's bones, sorted parent first. The root bone is always the first bone. */
+    bones = new Array();
+    // Ordered parents first.
+    /** The skeleton's slots. */
+    slots = new Array();
+    // Setup pose draw order.
+    skins = new Array();
+    /** The skeleton's default skin. By default this skin contains all attachments that were not in a skin in Spine.
+     *
+     * See {@link Skeleton#getAttachmentByName()}.
+     * May be null. */
+    defaultSkin = null;
+    /** The skeleton's events. */
+    events = new Array();
+    /** The skeleton's animations. */
+    animations = new Array();
+    /** The skeleton's IK constraints. */
+    ikConstraints = new Array();
+    /** The skeleton's transform constraints. */
+    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. */
+    y = 0;
+    /** The width of the skeleton's axis aligned bounding box in the setup pose. */
+    width = 0;
+    /** The height of the skeleton's axis aligned bounding box in the setup pose. */
+    height = 0;
+    /** The Spine version used to export the skeleton data, or null. */
+    version = null;
+    /** The skeleton data hash. This value will change if any of the skeleton data has changed. May be null. */
+    hash = null;
+    // Nonessential
+    /** The dopesheet FPS in Spine. Available only when nonessential data was exported. */
+    fps = 0;
+    /** The path to the images directory as defined in Spine. Available only when nonessential data was exported. May be null. */
+    imagesPath = null;
+    /** The path to the audio directory as defined in Spine. Available only when nonessential data was exported. May be null. */
+    audioPath = null;
     /** Finds a bone by comparing each bone's name. It is more efficient to cache the results of this method than to call it
      * multiple times.
      * @returns May be null. */
@@ -7753,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;
       }
@@ -7767,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;
       }
@@ -7781,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;
       }
@@ -7800,10 +8263,15 @@ var spine = (() => {
     }
   };
   var Skin = class {
+    /** The skin's name, which is unique across all skins in the skeleton. */
+    name;
+    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) {
-      this.attachments = new Array();
-      this.bones = Array();
-      this.constraints = new Array();
       if (!name)
         throw new Error("name cannot be null.");
       this.name = name;
@@ -7960,19 +8428,25 @@ var spine = (() => {
 
   // spine-core/src/SlotData.ts
   var SlotData = class {
+    /** The index of the slot in {@link Skeleton#getSlots()}. */
+    index = 0;
+    /** The name of the slot, which is unique across all slots in the skeleton. */
+    name;
+    /** The bone this slot belongs to. */
+    boneData;
+    /** The color used to tint the slot's attachment. If {@link #getDarkColor()} is set, this is used as the light color for two
+     * color tinting. */
+    color = new Color(1, 1, 1, 1);
+    /** The dark color used to tint the slot's attachment for two color tinting, or null if two color tinting is not used. The dark
+     * color's alpha is not used. */
+    darkColor = null;
+    /** The name of the attachment that is visible for this slot in the setup pose, or null if no attachment is visible. */
+    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) {
-      /** The index of the slot in {@link Skeleton#getSlots()}. */
-      this.index = 0;
-      /** The color used to tint the slot's attachment. If {@link #getDarkColor()} is set, this is used as the light color for two
-       * color tinting. */
-      this.color = new Color(1, 1, 1, 1);
-      /** The dark color used to tint the slot's attachment for two color tinting, or null if two color tinting is not used. The dark
-       * color's alpha is not used. */
-      this.darkColor = null;
-      /** The name of the attachment that is visible for this slot in the setup pose, or null if no attachment is visible. */
-      this.attachmentName = null;
-      /** The blend mode for drawing the slot's attachment. */
-      this.blendMode = BlendMode.Normal;
       if (index < 0)
         throw new Error("index must be >= 0.");
       if (!name)
@@ -7994,33 +8468,10 @@ var spine = (() => {
 
   // spine-core/src/TransformConstraintData.ts
   var TransformConstraintData = class extends ConstraintData {
-    constructor(name) {
-      super(name, 0, false);
-      /** The bones that will be modified by this transform constraint. */
-      this.bones = new Array();
-      /** The target bone whose world transform will be copied to the constrained bones. */
-      this._target = null;
-      this.mixRotate = 0;
-      this.mixX = 0;
-      this.mixY = 0;
-      this.mixScaleX = 0;
-      this.mixScaleY = 0;
-      this.mixShearY = 0;
-      /** An offset added to the constrained bone rotation. */
-      this.offsetRotation = 0;
-      /** An offset added to the constrained bone X translation. */
-      this.offsetX = 0;
-      /** An offset added to the constrained bone Y translation. */
-      this.offsetY = 0;
-      /** An offset added to the constrained bone scaleX. */
-      this.offsetScaleX = 0;
-      /** An offset added to the constrained bone scaleY. */
-      this.offsetScaleY = 0;
-      /** An offset added to the constrained bone shearY. */
-      this.offsetShearY = 0;
-      this.relative = false;
-      this.local = false;
-    }
+    /** The bones that will be modified by this transform constraint. */
+    bones = new Array();
+    /** The target bone whose world transform will be copied to the constrained bones. */
+    _target = null;
     set target(boneData) {
       this._target = boneData;
     }
@@ -8030,17 +8481,41 @@ var spine = (() => {
       else
         return this._target;
     }
+    mixRotate = 0;
+    mixX = 0;
+    mixY = 0;
+    mixScaleX = 0;
+    mixScaleY = 0;
+    mixShearY = 0;
+    /** An offset added to the constrained bone rotation. */
+    offsetRotation = 0;
+    /** An offset added to the constrained bone X translation. */
+    offsetX = 0;
+    /** An offset added to the constrained bone Y translation. */
+    offsetY = 0;
+    /** An offset added to the constrained bone scaleX. */
+    offsetScaleX = 0;
+    /** An offset added to the constrained bone scaleY. */
+    offsetScaleY = 0;
+    /** An offset added to the constrained bone shearY. */
+    offsetShearY = 0;
+    relative = false;
+    local = false;
+    constructor(name) {
+      super(name, 0, false);
+    }
   };
 
   // spine-core/src/SkeletonBinary.ts
   var SkeletonBinary = class {
+    /** Scales bone positions, image sizes, and translations as they are loaded. This allows different size images to be used at
+     * runtime than were used in Spine.
+     *
+     * See [Scaling](http://esotericsoftware.com/spine-loading-skeleton-data#Scaling) in the Spine Runtimes Guide. */
+    scale = 1;
+    attachmentLoader;
+    linkedMeshes = new Array();
     constructor(attachmentLoader) {
-      /** Scales bone positions, image sizes, and translations as they are loaded. This allows different size images to be used at
-       * runtime than were used in Spine.
-       *
-       * See [Scaling](http://esotericsoftware.com/spine-loading-skeleton-data#Scaling) in the Spine Runtimes Guide. */
-      this.scale = 1;
-      this.linkedMeshes = new Array();
       this.attachmentLoader = attachmentLoader;
     }
     readSkeletonData(binary) {
@@ -9054,6 +9529,11 @@ var spine = (() => {
     }
   };
   var LinkedMesh = class {
+    parent;
+    skin;
+    slotIndex;
+    mesh;
+    inheritTimeline;
     constructor(mesh, skin, slotIndex, parent, inheritDeform) {
       this.mesh = mesh;
       this.skin = skin;
@@ -9147,23 +9627,21 @@ var spine = (() => {
 
   // spine-core/src/SkeletonBounds.ts
   var SkeletonBounds = class {
-    constructor() {
-      /** The left edge of the axis aligned bounding box. */
-      this.minX = 0;
-      /** The bottom edge of the axis aligned bounding box. */
-      this.minY = 0;
-      /** The right edge of the axis aligned bounding box. */
-      this.maxX = 0;
-      /** The top edge of the axis aligned bounding box. */
-      this.maxY = 0;
-      /** The visible bounding boxes. */
-      this.boundingBoxes = new Array();
-      /** The world vertices for the bounding box polygons. */
-      this.polygons = new Array();
-      this.polygonPool = new Pool(() => {
-        return Utils.newFloatArray(16);
-      });
-    }
+    /** The left edge of the axis aligned bounding box. */
+    minX = 0;
+    /** The bottom edge of the axis aligned bounding box. */
+    minY = 0;
+    /** The right edge of the axis aligned bounding box. */
+    maxX = 0;
+    /** The top edge of the axis aligned bounding box. */
+    maxY = 0;
+    /** The visible bounding boxes. */
+    boundingBoxes = new Array();
+    /** The world vertices for the bounding box polygons. */
+    polygons = new Array();
+    polygonPool = new Pool(() => {
+      return Utils.newFloatArray(16);
+    });
     /** Clears any previous polygons, finds all visible bounding box attachments, and computes the world vertices for each bounding
      * box's polygon.
      * @param updateAabb If true, the axis aligned bounding box containing all the polygons is computed. If false, the
@@ -9334,19 +9812,17 @@ var spine = (() => {
 
   // spine-core/src/Triangulator.ts
   var Triangulator = class {
-    constructor() {
-      this.convexPolygons = new Array();
-      this.convexPolygonsIndices = new Array();
-      this.indicesArray = new Array();
-      this.isConcaveArray = new Array();
-      this.triangles = new Array();
-      this.polygonPool = new Pool(() => {
-        return new Array();
-      });
-      this.polygonIndicesPool = new Pool(() => {
-        return new Array();
-      });
-    }
+    convexPolygons = new Array();
+    convexPolygonsIndices = new Array();
+    indicesArray = new Array();
+    isConcaveArray = new Array();
+    triangles = new Array();
+    polygonPool = new Pool(() => {
+      return new Array();
+    });
+    polygonIndicesPool = new Pool(() => {
+      return new Array();
+    });
     triangulate(verticesArray) {
       let vertices = verticesArray;
       let vertexCount = verticesArray.length >> 1;
@@ -9550,16 +10026,14 @@ var spine = (() => {
 
   // spine-core/src/SkeletonClipping.ts
   var SkeletonClipping = class {
-    constructor() {
-      this.triangulator = new Triangulator();
-      this.clippingPolygon = new Array();
-      this.clipOutput = new Array();
-      this.clippedVertices = new Array();
-      this.clippedTriangles = new Array();
-      this.scratch = new Array();
-      this.clipAttachment = null;
-      this.clippingPolygons = null;
-    }
+    triangulator = new Triangulator();
+    clippingPolygon = new Array();
+    clipOutput = new Array();
+    clippedVertices = new Array();
+    clippedTriangles = new Array();
+    scratch = new Array();
+    clipAttachment = null;
+    clippingPolygons = null;
     clipStart(slot, clip) {
       if (this.clipAttachment)
         return 0;
@@ -9839,13 +10313,14 @@ var spine = (() => {
 
   // spine-core/src/SkeletonJson.ts
   var SkeletonJson = class {
+    attachmentLoader;
+    /** Scales bone positions, image sizes, and translations as they are loaded. This allows different size images to be used at
+     * runtime than were used in Spine.
+     *
+     * See [Scaling](http://esotericsoftware.com/spine-loading-skeleton-data#Scaling) in the Spine Runtimes Guide. */
+    scale = 1;
+    linkedMeshes = new Array();
     constructor(attachmentLoader) {
-      /** Scales bone positions, image sizes, and translations as they are loaded. This allows different size images to be used at
-       * runtime than were used in Spine.
-       *
-       * See [Scaling](http://esotericsoftware.com/spine-loading-skeleton-data#Scaling) in the Spine Runtimes Guide. */
-      this.scale = 1;
-      this.linkedMeshes = new Array();
       this.attachmentLoader = attachmentLoader;
     }
     readSkeletonData(json) {
@@ -10707,6 +11182,11 @@ var spine = (() => {
     }
   };
   var LinkedMesh2 = class {
+    parent;
+    skin;
+    slotIndex;
+    mesh;
+    inheritTimeline;
     constructor(mesh, skin, slotIndex, parent, inheritDeform) {
       this.mesh = mesh;
       this.skin = skin;
@@ -10793,8 +11273,10 @@ var spine = (() => {
 
   // spine-webgl/src/WebGL.ts
   var ManagedWebGLRenderingContext = class {
+    canvas;
+    gl;
+    restorables = new Array();
     constructor(canvasOrContext, contextConfig = { alpha: "true" }) {
-      this.restorables = new Array();
       if (!(canvasOrContext instanceof WebGLRenderingContext || typeof WebGL2RenderingContext !== "undefined" && canvasOrContext instanceof WebGL2RenderingContext)) {
         let canvas = canvasOrContext;
         this.gl = canvas.getContext("webgl2", contextConfig) || canvas.getContext("webgl", contextConfig);
@@ -10825,11 +11307,12 @@ var spine = (() => {
 
   // spine-webgl/src/GLTexture.ts
   var _GLTexture = class extends Texture {
+    context;
+    texture = null;
+    boundUnit = 0;
+    useMipMaps = false;
     constructor(context, image, useMipMaps = false) {
       super(image);
-      this.texture = null;
-      this.boundUnit = 0;
-      this.useMipMaps = false;
       this.context = context instanceof ManagedWebGLRenderingContext ? context : new ManagedWebGLRenderingContext(context);
       this.useMipMaps = useMipMaps;
       this.restore();
@@ -10909,7 +11392,7 @@ var spine = (() => {
     }
   };
   var GLTexture = _GLTexture;
-  GLTexture.DISABLE_UNPACK_PREMULTIPLIED_ALPHA_WEBGL = false;
+  __publicField(GLTexture, "DISABLE_UNPACK_PREMULTIPLIED_ALPHA_WEBGL", false);
 
   // spine-webgl/src/AssetManager.ts
   var AssetManager = class extends AssetManagerBase {
@@ -10922,10 +11405,10 @@ var spine = (() => {
 
   // spine-webgl/src/Vector3.ts
   var Vector3 = class {
+    x = 0;
+    y = 0;
+    z = 0;
     constructor(x = 0, y = 0, z = 0) {
-      this.x = 0;
-      this.y = 0;
-      this.z = 0;
       this.x = x;
       this.y = y;
       this.z = z;
@@ -11022,9 +11505,9 @@ var spine = (() => {
   var M32 = 11;
   var M33 = 15;
   var _Matrix4 = class {
+    temp = new Float32Array(16);
+    values = new Float32Array(16);
     constructor() {
-      this.temp = new Float32Array(16);
-      this.values = new Float32Array(16);
       let v = this.values;
       v[M00] = 1;
       v[M11] = 1;
@@ -11255,26 +11738,26 @@ var spine = (() => {
     }
   };
   var Matrix42 = _Matrix4;
-  Matrix42.xAxis = new Vector3();
-  Matrix42.yAxis = new Vector3();
-  Matrix42.zAxis = new Vector3();
-  Matrix42.tmpMatrix = new _Matrix4();
+  __publicField(Matrix42, "xAxis", new Vector3());
+  __publicField(Matrix42, "yAxis", new Vector3());
+  __publicField(Matrix42, "zAxis", new Vector3());
+  __publicField(Matrix42, "tmpMatrix", new _Matrix4());
 
   // spine-webgl/src/Camera.ts
   var OrthoCamera = class {
+    position = new Vector3(0, 0, 0);
+    direction = new Vector3(0, 0, -1);
+    up = new Vector3(0, 1, 0);
+    near = 0;
+    far = 100;
+    zoom = 1;
+    viewportWidth = 0;
+    viewportHeight = 0;
+    projectionView = new Matrix42();
+    inverseProjectionView = new Matrix42();
+    projection = new Matrix42();
+    view = new Matrix42();
     constructor(viewportWidth, viewportHeight) {
-      this.position = new Vector3(0, 0, 0);
-      this.direction = new Vector3(0, 0, -1);
-      this.up = new Vector3(0, 1, 0);
-      this.near = 0;
-      this.far = 100;
-      this.zoom = 1;
-      this.viewportWidth = 0;
-      this.viewportHeight = 0;
-      this.projectionView = new Matrix42();
-      this.inverseProjectionView = new Matrix42();
-      this.projection = new Matrix42();
-      this.view = new Matrix42();
       this.viewportWidth = viewportWidth;
       this.viewportHeight = viewportHeight;
       this.update();
@@ -11321,15 +11804,16 @@ var spine = (() => {
 
   // spine-webgl/src/Input.ts
   var Input = class {
+    element;
+    mouseX = 0;
+    mouseY = 0;
+    buttonDown = false;
+    touch0 = null;
+    touch1 = null;
+    initialPinchDistance = 0;
+    listeners = new Array();
+    eventListeners = [];
     constructor(element) {
-      this.mouseX = 0;
-      this.mouseY = 0;
-      this.buttonDown = false;
-      this.touch0 = null;
-      this.touch1 = null;
-      this.initialPinchDistance = 0;
-      this.listeners = new Array();
-      this.eventListeners = [];
       this.element = element;
       this.setupCallbacks(element);
     }
@@ -11592,18 +12076,21 @@ var spine = (() => {
     constructor(context, vertexShader, fragmentShader) {
       this.vertexShader = vertexShader;
       this.fragmentShader = fragmentShader;
-      this.vs = null;
-      this.fs = null;
-      this.program = null;
-      this.tmp2x2 = new Float32Array(2 * 2);
-      this.tmp3x3 = new Float32Array(3 * 3);
-      this.tmp4x4 = new Float32Array(4 * 4);
       this.vsSource = vertexShader;
       this.fsSource = fragmentShader;
       this.context = context instanceof ManagedWebGLRenderingContext ? context : new ManagedWebGLRenderingContext(context);
       this.context.addRestorable(this);
       this.compile();
     }
+    context;
+    vs = null;
+    vsSource;
+    fs = null;
+    fsSource;
+    program = null;
+    tmp2x2 = new Float32Array(2 * 2);
+    tmp3x3 = new Float32Array(3 * 3);
+    tmp4x4 = new Float32Array(4 * 4);
     getProgram() {
       return this.program;
     }
@@ -11837,24 +12324,17 @@ void main () {
     }
   };
   var Shader = _Shader;
-  Shader.MVP_MATRIX = "u_projTrans";
-  Shader.POSITION = "a_position";
-  Shader.COLOR = "a_color";
-  Shader.COLOR2 = "a_color2";
-  Shader.TEXCOORDS = "a_texCoords";
-  Shader.SAMPLER = "u_texture";
+  __publicField(Shader, "MVP_MATRIX", "u_projTrans");
+  __publicField(Shader, "POSITION", "a_position");
+  __publicField(Shader, "COLOR", "a_color");
+  __publicField(Shader, "COLOR2", "a_color2");
+  __publicField(Shader, "TEXCOORDS", "a_texCoords");
+  __publicField(Shader, "SAMPLER", "u_texture");
 
   // spine-webgl/src/Mesh.ts
   var Mesh = class {
     constructor(context, attributes, maxVertices, maxIndices) {
       this.attributes = attributes;
-      this.verticesBuffer = null;
-      this.verticesLength = 0;
-      this.dirtyVertices = false;
-      this.indicesBuffer = null;
-      this.indicesLength = 0;
-      this.dirtyIndices = false;
-      this.elementsPerVertex = 0;
       this.context = context instanceof ManagedWebGLRenderingContext ? context : new ManagedWebGLRenderingContext(context);
       this.elementsPerVertex = 0;
       for (let i = 0; i < attributes.length; i++) {
@@ -11864,6 +12344,16 @@ void main () {
       this.indices = new Uint16Array(maxIndices);
       this.context.addRestorable(this);
     }
+    context;
+    vertices;
+    verticesBuffer = null;
+    verticesLength = 0;
+    dirtyVertices = false;
+    indices;
+    indicesBuffer = null;
+    indicesLength = 0;
+    dirtyIndices = false;
+    elementsPerVertex = 0;
     getAttributes() {
       return this.attributes;
     }
@@ -12030,14 +12520,19 @@ void main () {
   var GL_ONE_MINUS_SRC_ALPHA = 771;
   var GL_DST_COLOR = 774;
   var _PolygonBatcher = class {
+    context;
+    drawCalls = 0;
+    isDrawing = false;
+    mesh;
+    shader = null;
+    lastTexture = null;
+    verticesLength = 0;
+    indicesLength = 0;
+    srcColorBlend;
+    srcAlphaBlend;
+    dstBlend;
+    cullWasEnabled = false;
     constructor(context, twoColorTint = true, maxVertices = 10920) {
-      this.drawCalls = 0;
-      this.isDrawing = false;
-      this.shader = null;
-      this.lastTexture = null;
-      this.verticesLength = 0;
-      this.indicesLength = 0;
-      this.cullWasEnabled = false;
       if (maxVertices > 10920)
         throw new Error("Can't have more than 10920 triangles per batch: " + maxVertices);
       this.context = context instanceof ManagedWebGLRenderingContext ? context : new ManagedWebGLRenderingContext(context);
@@ -12141,24 +12636,29 @@ void main () {
     }
   };
   var PolygonBatcher = _PolygonBatcher;
-  PolygonBatcher.disableCulling = false;
-  PolygonBatcher.globalDrawCalls = 0;
-  PolygonBatcher.blendModesGL = [
+  __publicField(PolygonBatcher, "disableCulling", false);
+  __publicField(PolygonBatcher, "globalDrawCalls", 0);
+  __publicField(PolygonBatcher, "blendModesGL", [
     { srcRgb: GL_SRC_ALPHA, srcRgbPma: GL_ONE, dstRgb: GL_ONE_MINUS_SRC_ALPHA, srcAlpha: GL_ONE },
     { srcRgb: GL_SRC_ALPHA, srcRgbPma: GL_ONE, dstRgb: GL_ONE, srcAlpha: GL_ONE },
     { srcRgb: GL_DST_COLOR, srcRgbPma: GL_DST_COLOR, dstRgb: GL_ONE_MINUS_SRC_ALPHA, srcAlpha: GL_ONE },
     { srcRgb: GL_ONE, srcRgbPma: GL_ONE, dstRgb: GL_ONE_MINUS_SRC_COLOR, srcAlpha: GL_ONE }
-  ];
+  ]);
 
   // spine-webgl/src/ShapeRenderer.ts
   var ShapeRenderer = class {
+    context;
+    isDrawing = false;
+    mesh;
+    shapeType = ShapeType.Filled;
+    color = new Color(1, 1, 1, 1);
+    shader = null;
+    vertexIndex = 0;
+    tmp = new Vector2();
+    srcColorBlend;
+    srcAlphaBlend;
+    dstBlend;
     constructor(context, maxVertices = 10920) {
-      this.isDrawing = false;
-      this.shapeType = ShapeType.Filled;
-      this.color = new Color(1, 1, 1, 1);
-      this.shader = null;
-      this.vertexIndex = 0;
-      this.tmp = new Vector2();
       if (maxVertices > 10920)
         throw new Error("Can't have more than 10920 triangles per batch: " + maxVertices);
       this.context = context instanceof ManagedWebGLRenderingContext ? context : new ManagedWebGLRenderingContext(context);
@@ -12455,28 +12955,29 @@ void main () {
 
   // spine-webgl/src/SkeletonDebugRenderer.ts
   var _SkeletonDebugRenderer = class {
+    boneLineColor = new Color(1, 0, 0, 1);
+    boneOriginColor = new Color(0, 1, 0, 1);
+    attachmentLineColor = new Color(0, 0, 1, 0.5);
+    triangleLineColor = new Color(1, 0.64, 0, 0.5);
+    pathColor = new Color().setFromString("FF7F00");
+    clipColor = new Color(0.8, 0, 0, 2);
+    aabbColor = new Color(0, 1, 0, 0.5);
+    drawBones = true;
+    drawRegionAttachments = true;
+    drawBoundingBoxes = true;
+    drawMeshHull = true;
+    drawMeshTriangles = true;
+    drawPaths = true;
+    drawSkeletonXY = false;
+    drawClipping = true;
+    premultipliedAlpha = false;
+    scale = 1;
+    boneWidth = 2;
+    context;
+    bounds = new SkeletonBounds();
+    temp = new Array();
+    vertices = Utils.newFloatArray(2 * 1024);
     constructor(context) {
-      this.boneLineColor = new Color(1, 0, 0, 1);
-      this.boneOriginColor = new Color(0, 1, 0, 1);
-      this.attachmentLineColor = new Color(0, 0, 1, 0.5);
-      this.triangleLineColor = new Color(1, 0.64, 0, 0.5);
-      this.pathColor = new Color().setFromString("FF7F00");
-      this.clipColor = new Color(0.8, 0, 0, 2);
-      this.aabbColor = new Color(0, 1, 0, 0.5);
-      this.drawBones = true;
-      this.drawRegionAttachments = true;
-      this.drawBoundingBoxes = true;
-      this.drawMeshHull = true;
-      this.drawMeshTriangles = true;
-      this.drawPaths = true;
-      this.drawSkeletonXY = false;
-      this.drawClipping = true;
-      this.premultipliedAlpha = false;
-      this.scale = 1;
-      this.boneWidth = 2;
-      this.bounds = new SkeletonBounds();
-      this.temp = new Array();
-      this.vertices = Utils.newFloatArray(2 * 1024);
       this.context = context instanceof ManagedWebGLRenderingContext ? context : new ManagedWebGLRenderingContext(context);
     }
     draw(shapes, skeleton, ignoredBones) {
@@ -12653,8 +13154,8 @@ void main () {
     }
   };
   var SkeletonDebugRenderer = _SkeletonDebugRenderer;
-  SkeletonDebugRenderer.LIGHT_GRAY = new Color(192 / 255, 192 / 255, 192 / 255, 1);
-  SkeletonDebugRenderer.GREEN = new Color(0, 1, 0, 1);
+  __publicField(SkeletonDebugRenderer, "LIGHT_GRAY", new Color(192 / 255, 192 / 255, 192 / 255, 1));
+  __publicField(SkeletonDebugRenderer, "GREEN", new Color(0, 1, 0, 1));
 
   // spine-webgl/src/SkeletonRenderer.ts
   var Renderable = class {
@@ -12665,18 +13166,19 @@ void main () {
     }
   };
   var _SkeletonRenderer = class {
+    premultipliedAlpha = false;
+    tempColor = new Color();
+    tempColor2 = new Color();
+    vertices;
+    vertexSize = 2 + 2 + 4;
+    twoColorTint = false;
+    renderable = new Renderable([], 0, 0);
+    clipper = new SkeletonClipping();
+    temp = new Vector2();
+    temp2 = new Vector2();
+    temp3 = new Color();
+    temp4 = new Color();
     constructor(context, twoColorTint = true) {
-      this.premultipliedAlpha = false;
-      this.tempColor = new Color();
-      this.tempColor2 = new Color();
-      this.vertexSize = 2 + 2 + 4;
-      this.twoColorTint = false;
-      this.renderable = new Renderable([], 0, 0);
-      this.clipper = new SkeletonClipping();
-      this.temp = new Vector2();
-      this.temp2 = new Vector2();
-      this.temp3 = new Color();
-      this.temp4 = new Color();
       this.twoColorTint = twoColorTint;
       if (twoColorTint)
         this.vertexSize += 4;
@@ -12821,7 +13323,7 @@ void main () {
     }
   };
   var SkeletonRenderer = _SkeletonRenderer;
-  SkeletonRenderer.QUAD_TRIANGLES = [0, 1, 2, 2, 3, 0];
+  __publicField(SkeletonRenderer, "QUAD_TRIANGLES", [0, 1, 2, 2, 3, 0]);
 
   // spine-webgl/src/SceneRenderer.ts
   var quad = [
@@ -12861,9 +13363,18 @@ void main () {
   var QUAD_TRIANGLES = [0, 1, 2, 2, 3, 0];
   var WHITE = new Color(1, 1, 1, 1);
   var SceneRenderer = class {
+    context;
+    canvas;
+    camera;
+    batcher;
+    twoColorTint = false;
+    batcherShader;
+    shapes;
+    shapesShader;
+    activeRenderer = null;
+    skeletonRenderer;
+    skeletonDebugRenderer;
     constructor(canvas, context, twoColorTint = true) {
-      this.twoColorTint = false;
-      this.activeRenderer = null;
       this.canvas = canvas;
       this.context = context instanceof ManagedWebGLRenderingContext ? context : new ManagedWebGLRenderingContext(context);
       this.twoColorTint = twoColorTint;
@@ -13296,15 +13807,16 @@ void main () {
   var logoHeight = 108;
   var spinnerSize = 163;
   var LoadingScreen = class {
+    renderer;
+    logo = null;
+    spinner = null;
+    angle = 0;
+    fadeOut = 0;
+    fadeIn = 0;
+    timeKeeper = new TimeKeeper();
+    backgroundColor = new Color(0.135, 0.135, 0.135, 1);
+    tempColor = new Color();
     constructor(renderer) {
-      this.logo = null;
-      this.spinner = null;
-      this.angle = 0;
-      this.fadeOut = 0;
-      this.fadeIn = 0;
-      this.timeKeeper = new TimeKeeper();
-      this.backgroundColor = new Color(0.135, 0.135, 0.135, 1);
-      this.tempColor = new Color();
       this.renderer = renderer;
       this.timeKeeper.maxDelta = 9;
       if (!logoImage) {
@@ -13323,9 +13835,8 @@ void main () {
       }
     }
     dispose() {
-      var _a, _b;
-      (_a = this.logo) == null ? void 0 : _a.dispose();
-      (_b = this.spinner) == null ? void 0 : _b.dispose();
+      this.logo?.dispose();
+      this.spinner?.dispose();
     }
     draw(complete = false) {
       if (loaded < 2 || complete && this.fadeOut > FADE_OUT)
@@ -13398,9 +13909,6 @@ void main () {
     /** Constructs a new spine canvas, rendering to the provided HTML canvas. */
     constructor(canvas, config) {
       this.config = config;
-      /** Tracks the current time, delta, and other time related statistics. */
-      this.time = new TimeKeeper();
-      this.disposed = false;
       if (!config.pathPrefix)
         config.pathPrefix = "";
       if (!config.app)
@@ -13456,6 +13964,20 @@ void main () {
       };
       requestAnimationFrame(waitForAssets);
     }
+    context;
+    /** Tracks the current time, delta, and other time related statistics. */
+    time = new TimeKeeper();
+    /** The HTML canvas to render to. */
+    htmlCanvas;
+    /** The WebGL rendering context. */
+    gl;
+    /** The scene renderer for easy drawing of skeletons, shapes, and images. */
+    renderer;
+    /** The asset manager to load assets with. */
+    assetManager;
+    /** The input processor used to listen to mouse, touch, and keyboard events. */
+    input;
+    disposed = false;
     /** Clears the canvas with the given color. The color values are given in the range [0,1]. */
     clear(r, g, b, a) {
       this.gl.clearColor(r, g, b, a);