@esotericsoftware/spine-canvas 4.2.10 → 4.2.14

package/dist/iife/spine-canvas.js

@@ -1,11 +1,22 @@
+"use strict";
 var spine = (() => {
   var __defProp = Object.defineProperty;
-  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __export = (target, all) => {
-    __markAsModule(target);
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
   };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
   // spine-canvas/src/index.ts
   var src_exports = {};
@@ -372,6 +383,7 @@ var spine = (() => {
     static toSinglePrecision(value) {
       return _Utils.SUPPORTS_TYPED_ARRAYS ? Math.fround(value) : value;
     }
+    // This function is used to fix WebKit 602 specific issue described at http://esotericsoftware.com/forum/iOS-10-disappearing-graphics-10109
     static webkit602BugfixHelper(alpha, blend) {
     }
     static contains(array, element, identity = true) {
@@ -510,12 +522,34 @@ var spine = (() => {
   var _VertexAttachment = class extends Attachment {
     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.
+     *
+     * See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine
+     * Runtimes Guide.
+     * @param start The index of the first {@link #vertices} value to transform. Each vertex has 2 values, x and y.
+     * @param count The number of world vertex values to output. Must be <= {@link #worldVerticesLength} - `start`.
+     * @param worldVertices The output world vertices. Must have a length >= `offset` + `count` *
+     *           `stride` / 2.
+     * @param offset The `worldVertices` index to begin writing values.
+     * @param stride The number of `worldVertices` entries between the value pairs written. */
     computeWorldVertices(slot, start, count, worldVertices2, offset, stride) {
       count = offset + (count >> 1) * stride;
       let skeleton = slot.bone.skeleton;
@@ -574,6 +608,7 @@ var spine = (() => {
         }
       }
     }
+    /** Does not copy id (generated) or name (set on construction). **/
     copyTo(attachment) {
       if (this.bones) {
         attachment.bones = new Array(this.bones.length);
@@ -597,6 +632,7 @@ var spine = (() => {
       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);
     }
@@ -634,8 +670,7 @@ var spine = (() => {
   };
   var Sequence = _Sequence;
   Sequence._nextID = 0;
-  var SequenceMode;
-  (function(SequenceMode2) {
+  var SequenceMode = /* @__PURE__ */ ((SequenceMode2) => {
     SequenceMode2[SequenceMode2["hold"] = 0] = "hold";
     SequenceMode2[SequenceMode2["once"] = 1] = "once";
     SequenceMode2[SequenceMode2["loop"] = 2] = "loop";
@@ -643,15 +678,16 @@ var spine = (() => {
     SequenceMode2[SequenceMode2["onceReverse"] = 4] = "onceReverse";
     SequenceMode2[SequenceMode2["loopReverse"] = 5] = "loopReverse";
     SequenceMode2[SequenceMode2["pingpongReverse"] = 6] = "pingpongReverse";
-  })(SequenceMode || (SequenceMode = {}));
+    return SequenceMode2;
+  })(SequenceMode || {});
   var SequenceModeValues = [
-    0,
-    1,
-    2,
-    3,
-    4,
-    5,
-    6
+    0 /* hold */,
+    1 /* once */,
+    2 /* loop */,
+    3 /* pingpong */,
+    4 /* onceReverse */,
+    5 /* loopReverse */,
+    6 /* pingpongReverse */
   ];
 
   // spine-core/src/Animation.ts
@@ -679,6 +715,11 @@ var spine = (() => {
           return true;
       return false;
     }
+    /** Applies all the animation's timelines to the specified skeleton.
+     *
+     * See Timeline {@link Timeline#apply(Skeleton, float, float, Array, float, MixBlend, MixDirection)}.
+     * @param loop If true, the animation repeats after {@link #getDuration()}.
+     * @param events May be null to ignore fired events. */
     apply(skeleton, lastTime, time, loop, events, alpha, blend, direction) {
       if (!skeleton)
         throw new Error("skeleton cannot be null.");
@@ -692,18 +733,18 @@ var spine = (() => {
         timelines[i].apply(skeleton, lastTime, time, events, alpha, blend, direction);
     }
   };
-  var MixBlend;
-  (function(MixBlend2) {
+  var MixBlend = /* @__PURE__ */ ((MixBlend2) => {
     MixBlend2[MixBlend2["setup"] = 0] = "setup";
     MixBlend2[MixBlend2["first"] = 1] = "first";
     MixBlend2[MixBlend2["replace"] = 2] = "replace";
     MixBlend2[MixBlend2["add"] = 3] = "add";
-  })(MixBlend || (MixBlend = {}));
-  var MixDirection;
-  (function(MixDirection2) {
+    return MixBlend2;
+  })(MixBlend || {});
+  var MixDirection = /* @__PURE__ */ ((MixDirection2) => {
     MixDirection2[MixDirection2["mixIn"] = 0] = "mixIn";
     MixDirection2[MixDirection2["mixOut"] = 1] = "mixOut";
-  })(MixDirection || (MixDirection = {}));
+    return MixDirection2;
+  })(MixDirection || {});
   var Property = {
     rotate: 0,
     x: 1,
@@ -759,17 +800,25 @@ var spine = (() => {
     }
   };
   var CurveTimeline = class extends Timeline {
+    // type, x, y, ...
     constructor(frameCount, bezierCount, propertyIds) {
       super(frameCount, propertyIds);
-      this.curves = Utils.newFloatArray(frameCount + bezierCount * 18);
+      this.curves = Utils.newFloatArray(
+        frameCount + bezierCount * 18
+        /*BEZIER_SIZE*/
+      );
       this.curves[frameCount - 1] = 1;
     }
+    /** Sets the specified key frame to linear interpolation. */
     setLinear(frame) {
       this.curves[frame] = 0;
     }
+    /** Sets the specified key frame to stepped interpolation. */
     setStepped(frame) {
       this.curves[frame] = 1;
     }
+    /** Shrinks the storage for Bezier curves, for use when <code>bezierCount</code> (specified in the constructor) was larger
+     * than the actual number of Bezier curves. */
     shrink(bezierCount) {
       let size = this.getFrameCount() + bezierCount * 18;
       if (this.curves.length > size) {
@@ -778,6 +827,20 @@ var spine = (() => {
         this.curves = newCurves;
       }
     }
+    /** Stores the segments for the specified Bezier curve. For timelines that modify multiple values, there may be more than
+     * one curve per frame.
+     * @param bezier The ordinal of this Bezier curve for this timeline, between 0 and <code>bezierCount - 1</code> (specified
+     *           in the constructor), inclusive.
+     * @param frame Between 0 and <code>frameCount - 1</code>, inclusive.
+     * @param value The index of the value for this frame that this curve is used for.
+     * @param time1 The time for the first key.
+     * @param value1 The value for the first key.
+     * @param cx1 The time for the first Bezier handle.
+     * @param cy1 The value for the first Bezier handle.
+     * @param cx2 The time of the second Bezier handle.
+     * @param cy2 The value for the second Bezier handle.
+     * @param time2 The time for the second key.
+     * @param value2 The value for the second key. */
     setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2) {
       let curves = this.curves;
       let i = this.getFrameCount() + bezier * 18;
@@ -799,6 +862,10 @@ var spine = (() => {
         y += dy;
       }
     }
+    /** Returns the Bezier interpolated value for the specified time.
+     * @param frameIndex The index into {@link #getFrames()} for the values of the frame before <code>time</code>.
+     * @param valueOffset The offset from <code>frameIndex</code> to the value this curve is used for.
+     * @param i The index of the Bezier segments. See {@link #getCurveType(int)}. */
     getBezierValue(time, frameIndex, valueOffset, i) {
       let curves = this.curves;
       if (curves[i] > time) {
@@ -824,11 +891,18 @@ var spine = (() => {
     getFrameEntries() {
       return 2;
     }
+    /** Sets the time and value for the specified frame.
+     * @param frame Between 0 and <code>frameCount</code>, inclusive.
+     * @param time The frame time in seconds. */
     setFrame(frame, time, value) {
       frame <<= 1;
       this.frames[frame] = time;
-      this.frames[frame + 1] = value;
+      this.frames[
+        frame + 1
+        /*VALUE*/
+      ] = value;
     }
+    /** Returns the interpolated value for the specified time. */
     getCurveValue(time) {
       let frames = this.frames;
       let i = frames.length - 2;
@@ -841,26 +915,55 @@ var spine = (() => {
       let curveType = this.curves[i >> 1];
       switch (curveType) {
         case 0:
-          let before = frames[i], value = frames[i + 1];
-          return value + (time - before) / (frames[i + 2] - before) * (frames[i + 2 + 1] - value);
+          let before = frames[i], value = frames[
+            i + 1
+            /*VALUE*/
+          ];
+          return value + (time - before) / (frames[
+            i + 2
+            /*ENTRIES*/
+          ] - before) * (frames[
+            i + 2 + 1
+            /*VALUE*/
+          ] - value);
         case 1:
-          return frames[i + 1];
-      }
-      return this.getBezierValue(time, i, 1, curveType - 2);
+          return frames[
+            i + 1
+            /*VALUE*/
+          ];
+      }
+      return this.getBezierValue(
+        time,
+        i,
+        1,
+        curveType - 2
+        /*BEZIER*/
+      );
     }
   };
   var CurveTimeline2 = class extends CurveTimeline {
+    /** @param bezierCount The maximum number of Bezier curves. See {@link #shrink(int)}.
+     * @param propertyIds Unique identifiers for the properties the timeline modifies. */
     constructor(frameCount, bezierCount, propertyId1, propertyId2) {
       super(frameCount, bezierCount, [propertyId1, propertyId2]);
     }
     getFrameEntries() {
       return 3;
     }
+    /** Sets the time and values for the specified frame.
+     * @param frame Between 0 and <code>frameCount</code>, inclusive.
+     * @param time The frame time in seconds. */
     setFrame(frame, time, value1, value2) {
       frame *= 3;
       this.frames[frame] = time;
-      this.frames[frame + 1] = value1;
-      this.frames[frame + 2] = value2;
+      this.frames[
+        frame + 1
+        /*VALUE1*/
+      ] = value1;
+      this.frames[
+        frame + 2
+        /*VALUE2*/
+      ] = value2;
     }
   };
   var RotateTimeline = class extends CurveTimeline1 {
@@ -876,30 +979,35 @@ var spine = (() => {
       let frames = this.frames;
       if (time < frames[0]) {
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             bone.rotation = bone.data.rotation;
             return;
-          case 1:
+          case 1 /* first */:
             bone.rotation += (bone.data.rotation - bone.rotation) * alpha;
         }
         return;
       }
       let r = this.getCurveValue(time);
       switch (blend) {
-        case 0:
+        case 0 /* setup */:
           bone.rotation = bone.data.rotation + r * alpha;
           break;
-        case 1:
-        case 2:
+        case 1 /* first */:
+        case 2 /* replace */:
           r += bone.data.rotation - bone.rotation;
-        case 3:
+        case 3 /* add */:
           bone.rotation += r * alpha;
       }
     }
   };
   var TranslateTimeline = class extends CurveTimeline2 {
     constructor(frameCount, bezierCount, boneIndex) {
-      super(frameCount, bezierCount, Property.x + "|" + boneIndex, Property.y + "|" + boneIndex);
+      super(
+        frameCount,
+        bezierCount,
+        Property.x + "|" + boneIndex,
+        Property.y + "|" + boneIndex
+      );
       this.boneIndex = 0;
       this.boneIndex = boneIndex;
     }
@@ -910,47 +1018,88 @@ var spine = (() => {
       let frames = this.frames;
       if (time < frames[0]) {
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             bone.x = bone.data.x;
             bone.y = bone.data.y;
             return;
-          case 1:
+          case 1 /* first */:
             bone.x += (bone.data.x - bone.x) * alpha;
             bone.y += (bone.data.y - bone.y) * alpha;
         }
         return;
       }
       let x = 0, y = 0;
-      let i = Timeline.search(frames, time, 3);
-      let curveType = this.curves[i / 3];
+      let i = Timeline.search(
+        frames,
+        time,
+        3
+        /*ENTRIES*/
+      );
+      let curveType = this.curves[
+        i / 3
+        /*ENTRIES*/
+      ];
       switch (curveType) {
         case 0:
           let before = frames[i];
-          x = frames[i + 1];
-          y = frames[i + 2];
-          let t = (time - before) / (frames[i + 3] - before);
-          x += (frames[i + 3 + 1] - x) * t;
-          y += (frames[i + 3 + 2] - y) * t;
+          x = frames[
+            i + 1
+            /*VALUE1*/
+          ];
+          y = frames[
+            i + 2
+            /*VALUE2*/
+          ];
+          let t = (time - before) / (frames[
+            i + 3
+            /*ENTRIES*/
+          ] - before);
+          x += (frames[
+            i + 3 + 1
+            /*VALUE1*/
+          ] - x) * t;
+          y += (frames[
+            i + 3 + 2
+            /*VALUE2*/
+          ] - y) * t;
           break;
         case 1:
-          x = frames[i + 1];
-          y = frames[i + 2];
+          x = frames[
+            i + 1
+            /*VALUE1*/
+          ];
+          y = frames[
+            i + 2
+            /*VALUE2*/
+          ];
           break;
         default:
-          x = this.getBezierValue(time, i, 1, curveType - 2);
-          y = this.getBezierValue(time, i, 2, curveType + 18 - 2);
+          x = this.getBezierValue(
+            time,
+            i,
+            1,
+            curveType - 2
+            /*BEZIER*/
+          );
+          y = this.getBezierValue(
+            time,
+            i,
+            2,
+            curveType + 18 - 2
+            /*BEZIER*/
+          );
       }
       switch (blend) {
-        case 0:
+        case 0 /* setup */:
           bone.x = bone.data.x + x * alpha;
           bone.y = bone.data.y + y * alpha;
           break;
-        case 1:
-        case 2:
+        case 1 /* first */:
+        case 2 /* replace */:
           bone.x += (bone.data.x + x - bone.x) * alpha;
           bone.y += (bone.data.y + y - bone.y) * alpha;
           break;
-        case 3:
+        case 3 /* add */:
           bone.x += x * alpha;
           bone.y += y * alpha;
       }
@@ -969,24 +1118,24 @@ var spine = (() => {
       let frames = this.frames;
       if (time < frames[0]) {
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             bone.x = bone.data.x;
             return;
-          case 1:
+          case 1 /* first */:
             bone.x += (bone.data.x - bone.x) * alpha;
         }
         return;
       }
       let x = this.getCurveValue(time);
       switch (blend) {
-        case 0:
+        case 0 /* setup */:
           bone.x = bone.data.x + x * alpha;
           break;
-        case 1:
-        case 2:
+        case 1 /* first */:
+        case 2 /* replace */:
           bone.x += (bone.data.x + x - bone.x) * alpha;
           break;
-        case 3:
+        case 3 /* add */:
           bone.x += x * alpha;
       }
     }
@@ -1004,31 +1153,36 @@ var spine = (() => {
       let frames = this.frames;
       if (time < frames[0]) {
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             bone.y = bone.data.y;
             return;
-          case 1:
+          case 1 /* first */:
             bone.y += (bone.data.y - bone.y) * alpha;
         }
         return;
       }
       let y = this.getCurveValue(time);
       switch (blend) {
-        case 0:
+        case 0 /* setup */:
           bone.y = bone.data.y + y * alpha;
           break;
-        case 1:
-        case 2:
+        case 1 /* first */:
+        case 2 /* replace */:
           bone.y += (bone.data.y + y - bone.y) * alpha;
           break;
-        case 3:
+        case 3 /* add */:
           bone.y += y * alpha;
       }
     }
   };
   var ScaleTimeline = class extends CurveTimeline2 {
     constructor(frameCount, bezierCount, boneIndex) {
-      super(frameCount, bezierCount, Property.scaleX + "|" + boneIndex, Property.scaleY + "|" + boneIndex);
+      super(
+        frameCount,
+        bezierCount,
+        Property.scaleX + "|" + boneIndex,
+        Property.scaleY + "|" + boneIndex
+      );
       this.boneIndex = 0;
       this.boneIndex = boneIndex;
     }
@@ -1039,40 +1193,81 @@ var spine = (() => {
       let frames = this.frames;
       if (time < frames[0]) {
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             bone.scaleX = bone.data.scaleX;
             bone.scaleY = bone.data.scaleY;
             return;
-          case 1:
+          case 1 /* first */:
             bone.scaleX += (bone.data.scaleX - bone.scaleX) * alpha;
             bone.scaleY += (bone.data.scaleY - bone.scaleY) * alpha;
         }
         return;
       }
       let x, y;
-      let i = Timeline.search(frames, time, 3);
-      let curveType = this.curves[i / 3];
+      let i = Timeline.search(
+        frames,
+        time,
+        3
+        /*ENTRIES*/
+      );
+      let curveType = this.curves[
+        i / 3
+        /*ENTRIES*/
+      ];
       switch (curveType) {
         case 0:
           let before = frames[i];
-          x = frames[i + 1];
-          y = frames[i + 2];
-          let t = (time - before) / (frames[i + 3] - before);
-          x += (frames[i + 3 + 1] - x) * t;
-          y += (frames[i + 3 + 2] - y) * t;
+          x = frames[
+            i + 1
+            /*VALUE1*/
+          ];
+          y = frames[
+            i + 2
+            /*VALUE2*/
+          ];
+          let t = (time - before) / (frames[
+            i + 3
+            /*ENTRIES*/
+          ] - before);
+          x += (frames[
+            i + 3 + 1
+            /*VALUE1*/
+          ] - x) * t;
+          y += (frames[
+            i + 3 + 2
+            /*VALUE2*/
+          ] - y) * t;
           break;
         case 1:
-          x = frames[i + 1];
-          y = frames[i + 2];
+          x = frames[
+            i + 1
+            /*VALUE1*/
+          ];
+          y = frames[
+            i + 2
+            /*VALUE2*/
+          ];
           break;
         default:
-          x = this.getBezierValue(time, i, 1, curveType - 2);
-          y = this.getBezierValue(time, i, 2, curveType + 18 - 2);
+          x = this.getBezierValue(
+            time,
+            i,
+            1,
+            curveType - 2
+            /*BEZIER*/
+          );
+          y = this.getBezierValue(
+            time,
+            i,
+            2,
+            curveType + 18 - 2
+            /*BEZIER*/
+          );
       }
       x *= bone.data.scaleX;
       y *= bone.data.scaleY;
       if (alpha == 1) {
-        if (blend == 3) {
+        if (blend == 3 /* add */) {
           bone.scaleX += x - bone.data.scaleX;
           bone.scaleY += y - bone.data.scaleY;
         } else {
@@ -1081,41 +1276,41 @@ var spine = (() => {
         }
       } else {
         let bx = 0, by = 0;
-        if (direction == 1) {
+        if (direction == 1 /* mixOut */) {
           switch (blend) {
-            case 0:
+            case 0 /* setup */:
               bx = bone.data.scaleX;
               by = bone.data.scaleY;
               bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
               bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
               break;
-            case 1:
-            case 2:
+            case 1 /* first */:
+            case 2 /* replace */:
               bx = bone.scaleX;
               by = bone.scaleY;
               bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
               bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
               break;
-            case 3:
+            case 3 /* add */:
               bone.scaleX += (x - bone.data.scaleX) * alpha;
               bone.scaleY += (y - bone.data.scaleY) * alpha;
           }
         } else {
           switch (blend) {
-            case 0:
+            case 0 /* setup */:
               bx = Math.abs(bone.data.scaleX) * MathUtils.signum(x);
               by = Math.abs(bone.data.scaleY) * MathUtils.signum(y);
               bone.scaleX = bx + (x - bx) * alpha;
               bone.scaleY = by + (y - by) * alpha;
               break;
-            case 1:
-            case 2:
+            case 1 /* first */:
+            case 2 /* replace */:
               bx = Math.abs(bone.scaleX) * MathUtils.signum(x);
               by = Math.abs(bone.scaleY) * MathUtils.signum(y);
               bone.scaleX = bx + (x - bx) * alpha;
               bone.scaleY = by + (y - by) * alpha;
               break;
-            case 3:
+            case 3 /* add */:
               bone.scaleX += (x - bone.data.scaleX) * alpha;
               bone.scaleY += (y - bone.data.scaleY) * alpha;
           }
@@ -1136,48 +1331,48 @@ var spine = (() => {
       let frames = this.frames;
       if (time < frames[0]) {
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             bone.scaleX = bone.data.scaleX;
             return;
-          case 1:
+          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)
+        if (blend == 3 /* add */)
           bone.scaleX += x - bone.data.scaleX;
         else
           bone.scaleX = x;
       } else {
         let bx = 0;
-        if (direction == 1) {
+        if (direction == 1 /* mixOut */) {
           switch (blend) {
-            case 0:
+            case 0 /* setup */:
               bx = bone.data.scaleX;
               bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
               break;
-            case 1:
-            case 2:
+            case 1 /* first */:
+            case 2 /* replace */:
               bx = bone.scaleX;
               bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
               break;
-            case 3:
+            case 3 /* add */:
               bone.scaleX += (x - bone.data.scaleX) * alpha;
           }
         } else {
           switch (blend) {
-            case 0:
+            case 0 /* setup */:
               bx = Math.abs(bone.data.scaleX) * MathUtils.signum(x);
               bone.scaleX = bx + (x - bx) * alpha;
               break;
-            case 1:
-            case 2:
+            case 1 /* first */:
+            case 2 /* replace */:
               bx = Math.abs(bone.scaleX) * MathUtils.signum(x);
               bone.scaleX = bx + (x - bx) * alpha;
               break;
-            case 3:
+            case 3 /* add */:
               bone.scaleX += (x - bone.data.scaleX) * alpha;
           }
         }
@@ -1197,48 +1392,48 @@ var spine = (() => {
       let frames = this.frames;
       if (time < frames[0]) {
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             bone.scaleY = bone.data.scaleY;
             return;
-          case 1:
+          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)
+        if (blend == 3 /* add */)
           bone.scaleY += y - bone.data.scaleY;
         else
           bone.scaleY = y;
       } else {
         let by = 0;
-        if (direction == 1) {
+        if (direction == 1 /* mixOut */) {
           switch (blend) {
-            case 0:
+            case 0 /* setup */:
               by = bone.data.scaleY;
               bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
               break;
-            case 1:
-            case 2:
+            case 1 /* first */:
+            case 2 /* replace */:
               by = bone.scaleY;
               bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
               break;
-            case 3:
+            case 3 /* add */:
               bone.scaleY += (y - bone.data.scaleY) * alpha;
           }
         } else {
           switch (blend) {
-            case 0:
+            case 0 /* setup */:
               by = Math.abs(bone.data.scaleY) * MathUtils.signum(y);
               bone.scaleY = by + (y - by) * alpha;
               break;
-            case 1:
-            case 2:
+            case 1 /* first */:
+            case 2 /* replace */:
               by = Math.abs(bone.scaleY) * MathUtils.signum(y);
               bone.scaleY = by + (y - by) * alpha;
               break;
-            case 3:
+            case 3 /* add */:
               bone.scaleY += (y - bone.data.scaleY) * alpha;
           }
         }
@@ -1247,7 +1442,12 @@ var spine = (() => {
   };
   var ShearTimeline = class extends CurveTimeline2 {
     constructor(frameCount, bezierCount, boneIndex) {
-      super(frameCount, bezierCount, Property.shearX + "|" + boneIndex, Property.shearY + "|" + boneIndex);
+      super(
+        frameCount,
+        bezierCount,
+        Property.shearX + "|" + boneIndex,
+        Property.shearY + "|" + boneIndex
+      );
       this.boneIndex = 0;
       this.boneIndex = boneIndex;
     }
@@ -1258,47 +1458,88 @@ var spine = (() => {
       let frames = this.frames;
       if (time < frames[0]) {
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             bone.shearX = bone.data.shearX;
             bone.shearY = bone.data.shearY;
             return;
-          case 1:
+          case 1 /* first */:
             bone.shearX += (bone.data.shearX - bone.shearX) * alpha;
             bone.shearY += (bone.data.shearY - bone.shearY) * alpha;
         }
         return;
       }
       let x = 0, y = 0;
-      let i = Timeline.search(frames, time, 3);
-      let curveType = this.curves[i / 3];
+      let i = Timeline.search(
+        frames,
+        time,
+        3
+        /*ENTRIES*/
+      );
+      let curveType = this.curves[
+        i / 3
+        /*ENTRIES*/
+      ];
       switch (curveType) {
         case 0:
           let before = frames[i];
-          x = frames[i + 1];
-          y = frames[i + 2];
-          let t = (time - before) / (frames[i + 3] - before);
-          x += (frames[i + 3 + 1] - x) * t;
-          y += (frames[i + 3 + 2] - y) * t;
+          x = frames[
+            i + 1
+            /*VALUE1*/
+          ];
+          y = frames[
+            i + 2
+            /*VALUE2*/
+          ];
+          let t = (time - before) / (frames[
+            i + 3
+            /*ENTRIES*/
+          ] - before);
+          x += (frames[
+            i + 3 + 1
+            /*VALUE1*/
+          ] - x) * t;
+          y += (frames[
+            i + 3 + 2
+            /*VALUE2*/
+          ] - y) * t;
           break;
         case 1:
-          x = frames[i + 1];
-          y = frames[i + 2];
+          x = frames[
+            i + 1
+            /*VALUE1*/
+          ];
+          y = frames[
+            i + 2
+            /*VALUE2*/
+          ];
           break;
         default:
-          x = this.getBezierValue(time, i, 1, curveType - 2);
-          y = this.getBezierValue(time, i, 2, curveType + 18 - 2);
+          x = this.getBezierValue(
+            time,
+            i,
+            1,
+            curveType - 2
+            /*BEZIER*/
+          );
+          y = this.getBezierValue(
+            time,
+            i,
+            2,
+            curveType + 18 - 2
+            /*BEZIER*/
+          );
       }
       switch (blend) {
-        case 0:
+        case 0 /* setup */:
           bone.shearX = bone.data.shearX + x * alpha;
           bone.shearY = bone.data.shearY + y * alpha;
           break;
-        case 1:
-        case 2:
+        case 1 /* first */:
+        case 2 /* replace */:
           bone.shearX += (bone.data.shearX + x - bone.shearX) * alpha;
           bone.shearY += (bone.data.shearY + y - bone.shearY) * alpha;
           break;
-        case 3:
+        case 3 /* add */:
           bone.shearX += x * alpha;
           bone.shearY += y * alpha;
       }
@@ -1317,24 +1558,24 @@ var spine = (() => {
       let frames = this.frames;
       if (time < frames[0]) {
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             bone.shearX = bone.data.shearX;
             return;
-          case 1:
+          case 1 /* first */:
             bone.shearX += (bone.data.shearX - bone.shearX) * alpha;
         }
         return;
       }
       let x = this.getCurveValue(time);
       switch (blend) {
-        case 0:
+        case 0 /* setup */:
           bone.shearX = bone.data.shearX + x * alpha;
           break;
-        case 1:
-        case 2:
+        case 1 /* first */:
+        case 2 /* replace */:
           bone.shearX += (bone.data.shearX + x - bone.shearX) * alpha;
           break;
-        case 3:
+        case 3 /* add */:
           bone.shearX += x * alpha;
       }
     }
@@ -1352,24 +1593,24 @@ var spine = (() => {
       let frames = this.frames;
       if (time < frames[0]) {
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             bone.shearY = bone.data.shearY;
             return;
-          case 1:
+          case 1 /* first */:
             bone.shearY += (bone.data.shearY - bone.shearY) * alpha;
         }
         return;
       }
       let y = this.getCurveValue(time);
       switch (blend) {
-        case 0:
+        case 0 /* setup */:
           bone.shearY = bone.data.shearY + y * alpha;
           break;
-        case 1:
-        case 2:
+        case 1 /* first */:
+        case 2 /* replace */:
           bone.shearY += (bone.data.shearY + y - bone.shearY) * alpha;
           break;
-        case 3:
+        case 3 /* add */:
           bone.shearY += y * alpha;
       }
     }
@@ -1386,13 +1627,26 @@ var spine = (() => {
     getFrameEntries() {
       return 5;
     }
+    /** Sets the time in seconds, red, green, blue, and alpha for the specified key frame. */
     setFrame(frame, time, r, g, b, a) {
       frame *= 5;
       this.frames[frame] = time;
-      this.frames[frame + 1] = r;
-      this.frames[frame + 2] = g;
-      this.frames[frame + 3] = b;
-      this.frames[frame + 4] = a;
+      this.frames[
+        frame + 1
+        /*R*/
+      ] = r;
+      this.frames[
+        frame + 2
+        /*G*/
+      ] = g;
+      this.frames[
+        frame + 3
+        /*B*/
+      ] = b;
+      this.frames[
+        frame + 4
+        /*A*/
+      ] = a;
     }
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
       let slot = skeleton.slots[this.slotIndex];
@@ -1403,46 +1657,122 @@ var spine = (() => {
       if (time < frames[0]) {
         let setup = slot.data.color;
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             color.setFromColor(setup);
             return;
-          case 1:
-            color.add((setup.r - color.r) * alpha, (setup.g - color.g) * alpha, (setup.b - color.b) * alpha, (setup.a - color.a) * alpha);
+          case 1 /* first */:
+            color.add(
+              (setup.r - color.r) * alpha,
+              (setup.g - color.g) * alpha,
+              (setup.b - color.b) * alpha,
+              (setup.a - color.a) * alpha
+            );
         }
         return;
       }
       let r = 0, g = 0, b = 0, a = 0;
-      let i = Timeline.search(frames, time, 5);
-      let curveType = this.curves[i / 5];
+      let i = Timeline.search(
+        frames,
+        time,
+        5
+        /*ENTRIES*/
+      );
+      let curveType = this.curves[
+        i / 5
+        /*ENTRIES*/
+      ];
       switch (curveType) {
         case 0:
           let before = frames[i];
-          r = frames[i + 1];
-          g = frames[i + 2];
-          b = frames[i + 3];
-          a = frames[i + 4];
-          let t = (time - before) / (frames[i + 5] - before);
-          r += (frames[i + 5 + 1] - r) * t;
-          g += (frames[i + 5 + 2] - g) * t;
-          b += (frames[i + 5 + 3] - b) * t;
-          a += (frames[i + 5 + 4] - a) * t;
+          r = frames[
+            i + 1
+            /*R*/
+          ];
+          g = frames[
+            i + 2
+            /*G*/
+          ];
+          b = frames[
+            i + 3
+            /*B*/
+          ];
+          a = frames[
+            i + 4
+            /*A*/
+          ];
+          let t = (time - before) / (frames[
+            i + 5
+            /*ENTRIES*/
+          ] - before);
+          r += (frames[
+            i + 5 + 1
+            /*R*/
+          ] - r) * t;
+          g += (frames[
+            i + 5 + 2
+            /*G*/
+          ] - g) * t;
+          b += (frames[
+            i + 5 + 3
+            /*B*/
+          ] - b) * t;
+          a += (frames[
+            i + 5 + 4
+            /*A*/
+          ] - a) * t;
           break;
         case 1:
-          r = frames[i + 1];
-          g = frames[i + 2];
-          b = frames[i + 3];
-          a = frames[i + 4];
+          r = frames[
+            i + 1
+            /*R*/
+          ];
+          g = frames[
+            i + 2
+            /*G*/
+          ];
+          b = frames[
+            i + 3
+            /*B*/
+          ];
+          a = frames[
+            i + 4
+            /*A*/
+          ];
           break;
         default:
-          r = this.getBezierValue(time, i, 1, curveType - 2);
-          g = this.getBezierValue(time, i, 2, curveType + 18 - 2);
-          b = this.getBezierValue(time, i, 3, curveType + 18 * 2 - 2);
-          a = this.getBezierValue(time, i, 4, curveType + 18 * 3 - 2);
+          r = this.getBezierValue(
+            time,
+            i,
+            1,
+            curveType - 2
+            /*BEZIER*/
+          );
+          g = this.getBezierValue(
+            time,
+            i,
+            2,
+            curveType + 18 - 2
+            /*BEZIER*/
+          );
+          b = this.getBezierValue(
+            time,
+            i,
+            3,
+            curveType + 18 * 2 - 2
+            /*BEZIER*/
+          );
+          a = this.getBezierValue(
+            time,
+            i,
+            4,
+            curveType + 18 * 3 - 2
+            /*BEZIER*/
+          );
       }
       if (alpha == 1)
         color.set(r, g, b, a);
       else {
-        if (blend == 0)
+        if (blend == 0 /* setup */)
           color.setFromColor(slot.data.color);
         color.add((r - color.r) * alpha, (g - color.g) * alpha, (b - color.b) * alpha, (a - color.a) * alpha);
       }
@@ -1459,12 +1789,22 @@ var spine = (() => {
     getFrameEntries() {
       return 4;
     }
+    /** Sets the time in seconds, red, green, blue, and alpha for the specified key frame. */
     setFrame(frame, time, r, g, b) {
       frame <<= 2;
       this.frames[frame] = time;
-      this.frames[frame + 1] = r;
-      this.frames[frame + 2] = g;
-      this.frames[frame + 3] = b;
+      this.frames[
+        frame + 1
+        /*R*/
+      ] = r;
+      this.frames[
+        frame + 2
+        /*G*/
+      ] = g;
+      this.frames[
+        frame + 3
+        /*B*/
+      ] = b;
     }
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
       let slot = skeleton.slots[this.slotIndex];
@@ -1475,12 +1815,12 @@ var spine = (() => {
       if (time < frames[0]) {
         let setup = slot.data.color;
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             color.r = setup.r;
             color.g = setup.g;
             color.b = setup.b;
             return;
-          case 1:
+          case 1 /* first */:
             color.r += (setup.r - color.r) * alpha;
             color.g += (setup.g - color.g) * alpha;
             color.b += (setup.b - color.b) * alpha;
@@ -1488,35 +1828,88 @@ var spine = (() => {
         return;
       }
       let r = 0, g = 0, b = 0;
-      let i = Timeline.search(frames, time, 4);
+      let i = Timeline.search(
+        frames,
+        time,
+        4
+        /*ENTRIES*/
+      );
       let curveType = this.curves[i >> 2];
       switch (curveType) {
         case 0:
           let before = frames[i];
-          r = frames[i + 1];
-          g = frames[i + 2];
-          b = frames[i + 3];
-          let t = (time - before) / (frames[i + 4] - before);
-          r += (frames[i + 4 + 1] - r) * t;
-          g += (frames[i + 4 + 2] - g) * t;
-          b += (frames[i + 4 + 3] - b) * t;
+          r = frames[
+            i + 1
+            /*R*/
+          ];
+          g = frames[
+            i + 2
+            /*G*/
+          ];
+          b = frames[
+            i + 3
+            /*B*/
+          ];
+          let t = (time - before) / (frames[
+            i + 4
+            /*ENTRIES*/
+          ] - before);
+          r += (frames[
+            i + 4 + 1
+            /*R*/
+          ] - r) * t;
+          g += (frames[
+            i + 4 + 2
+            /*G*/
+          ] - g) * t;
+          b += (frames[
+            i + 4 + 3
+            /*B*/
+          ] - b) * t;
           break;
         case 1:
-          r = frames[i + 1];
-          g = frames[i + 2];
-          b = frames[i + 3];
+          r = frames[
+            i + 1
+            /*R*/
+          ];
+          g = frames[
+            i + 2
+            /*G*/
+          ];
+          b = frames[
+            i + 3
+            /*B*/
+          ];
           break;
         default:
-          r = this.getBezierValue(time, i, 1, curveType - 2);
-          g = this.getBezierValue(time, i, 2, curveType + 18 - 2);
-          b = this.getBezierValue(time, i, 3, curveType + 18 * 2 - 2);
+          r = this.getBezierValue(
+            time,
+            i,
+            1,
+            curveType - 2
+            /*BEZIER*/
+          );
+          g = this.getBezierValue(
+            time,
+            i,
+            2,
+            curveType + 18 - 2
+            /*BEZIER*/
+          );
+          b = this.getBezierValue(
+            time,
+            i,
+            3,
+            curveType + 18 * 2 - 2
+            /*BEZIER*/
+          );
       }
       if (alpha == 1) {
         color.r = r;
         color.g = g;
         color.b = b;
       } else {
-        if (blend == 0) {
+        if (blend == 0 /* setup */) {
           let setup = slot.data.color;
           color.r = setup.r;
           color.g = setup.g;
@@ -1542,10 +1935,10 @@ var spine = (() => {
       if (time < this.frames[0]) {
         let setup = slot.data.color;
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             color.a = setup.a;
             return;
-          case 1:
+          case 1 /* first */:
             color.a += (setup.a - color.a) * alpha;
         }
         return;
@@ -1554,7 +1947,7 @@ var spine = (() => {
       if (alpha == 1)
         color.a = a;
       else {
-        if (blend == 0)
+        if (blend == 0 /* setup */)
           color.a = slot.data.color.a;
         color.a += (a - color.a) * alpha;
       }
@@ -1573,16 +1966,38 @@ var spine = (() => {
     getFrameEntries() {
       return 8;
     }
+    /** Sets the time in seconds, light, and dark colors for the specified key frame. */
     setFrame(frame, time, r, g, b, a, r2, g2, b2) {
       frame <<= 3;
       this.frames[frame] = time;
-      this.frames[frame + 1] = r;
-      this.frames[frame + 2] = g;
-      this.frames[frame + 3] = b;
-      this.frames[frame + 4] = a;
-      this.frames[frame + 5] = r2;
-      this.frames[frame + 6] = g2;
-      this.frames[frame + 7] = b2;
+      this.frames[
+        frame + 1
+        /*R*/
+      ] = r;
+      this.frames[
+        frame + 2
+        /*G*/
+      ] = g;
+      this.frames[
+        frame + 3
+        /*B*/
+      ] = b;
+      this.frames[
+        frame + 4
+        /*A*/
+      ] = a;
+      this.frames[
+        frame + 5
+        /*R2*/
+      ] = r2;
+      this.frames[
+        frame + 6
+        /*G2*/
+      ] = g2;
+      this.frames[
+        frame + 7
+        /*B2*/
+      ] = b2;
     }
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
       let slot = skeleton.slots[this.slotIndex];
@@ -1593,14 +2008,19 @@ var spine = (() => {
       if (time < frames[0]) {
         let setupLight = slot.data.color, setupDark = slot.data.darkColor;
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             light.setFromColor(setupLight);
             dark.r = setupDark.r;
             dark.g = setupDark.g;
             dark.b = setupDark.b;
             return;
-          case 1:
-            light.add((setupLight.r - light.r) * alpha, (setupLight.g - light.g) * alpha, (setupLight.b - light.b) * alpha, (setupLight.a - light.a) * alpha);
+          case 1 /* first */:
+            light.add(
+              (setupLight.r - light.r) * alpha,
+              (setupLight.g - light.g) * alpha,
+              (setupLight.b - light.b) * alpha,
+              (setupLight.a - light.a) * alpha
+            );
             dark.r += (setupDark.r - dark.r) * alpha;
             dark.g += (setupDark.g - dark.g) * alpha;
             dark.b += (setupDark.b - dark.b) * alpha;
@@ -1608,44 +2028,157 @@ var spine = (() => {
         return;
       }
       let r = 0, g = 0, b = 0, a = 0, r2 = 0, g2 = 0, b2 = 0;
-      let i = Timeline.search(frames, time, 8);
+      let i = Timeline.search(
+        frames,
+        time,
+        8
+        /*ENTRIES*/
+      );
       let curveType = this.curves[i >> 3];
       switch (curveType) {
         case 0:
           let before = frames[i];
-          r = frames[i + 1];
-          g = frames[i + 2];
-          b = frames[i + 3];
-          a = frames[i + 4];
-          r2 = frames[i + 5];
-          g2 = frames[i + 6];
-          b2 = frames[i + 7];
-          let t = (time - before) / (frames[i + 8] - before);
-          r += (frames[i + 8 + 1] - r) * t;
-          g += (frames[i + 8 + 2] - g) * t;
-          b += (frames[i + 8 + 3] - b) * t;
-          a += (frames[i + 8 + 4] - a) * t;
-          r2 += (frames[i + 8 + 5] - r2) * t;
-          g2 += (frames[i + 8 + 6] - g2) * t;
-          b2 += (frames[i + 8 + 7] - b2) * t;
+          r = frames[
+            i + 1
+            /*R*/
+          ];
+          g = frames[
+            i + 2
+            /*G*/
+          ];
+          b = frames[
+            i + 3
+            /*B*/
+          ];
+          a = frames[
+            i + 4
+            /*A*/
+          ];
+          r2 = frames[
+            i + 5
+            /*R2*/
+          ];
+          g2 = frames[
+            i + 6
+            /*G2*/
+          ];
+          b2 = frames[
+            i + 7
+            /*B2*/
+          ];
+          let t = (time - before) / (frames[
+            i + 8
+            /*ENTRIES*/
+          ] - before);
+          r += (frames[
+            i + 8 + 1
+            /*R*/
+          ] - r) * t;
+          g += (frames[
+            i + 8 + 2
+            /*G*/
+          ] - g) * t;
+          b += (frames[
+            i + 8 + 3
+            /*B*/
+          ] - b) * t;
+          a += (frames[
+            i + 8 + 4
+            /*A*/
+          ] - a) * t;
+          r2 += (frames[
+            i + 8 + 5
+            /*R2*/
+          ] - r2) * t;
+          g2 += (frames[
+            i + 8 + 6
+            /*G2*/
+          ] - g2) * t;
+          b2 += (frames[
+            i + 8 + 7
+            /*B2*/
+          ] - b2) * t;
           break;
         case 1:
-          r = frames[i + 1];
-          g = frames[i + 2];
-          b = frames[i + 3];
-          a = frames[i + 4];
-          r2 = frames[i + 5];
-          g2 = frames[i + 6];
-          b2 = frames[i + 7];
+          r = frames[
+            i + 1
+            /*R*/
+          ];
+          g = frames[
+            i + 2
+            /*G*/
+          ];
+          b = frames[
+            i + 3
+            /*B*/
+          ];
+          a = frames[
+            i + 4
+            /*A*/
+          ];
+          r2 = frames[
+            i + 5
+            /*R2*/
+          ];
+          g2 = frames[
+            i + 6
+            /*G2*/
+          ];
+          b2 = frames[
+            i + 7
+            /*B2*/
+          ];
           break;
         default:
-          r = this.getBezierValue(time, i, 1, curveType - 2);
-          g = this.getBezierValue(time, i, 2, curveType + 18 - 2);
-          b = this.getBezierValue(time, i, 3, curveType + 18 * 2 - 2);
-          a = this.getBezierValue(time, i, 4, curveType + 18 * 3 - 2);
-          r2 = this.getBezierValue(time, i, 5, curveType + 18 * 4 - 2);
-          g2 = this.getBezierValue(time, i, 6, curveType + 18 * 5 - 2);
-          b2 = this.getBezierValue(time, i, 7, curveType + 18 * 6 - 2);
+          r = this.getBezierValue(
+            time,
+            i,
+            1,
+            curveType - 2
+            /*BEZIER*/
+          );
+          g = this.getBezierValue(
+            time,
+            i,
+            2,
+            curveType + 18 - 2
+            /*BEZIER*/
+          );
+          b = this.getBezierValue(
+            time,
+            i,
+            3,
+            curveType + 18 * 2 - 2
+            /*BEZIER*/
+          );
+          a = this.getBezierValue(
+            time,
+            i,
+            4,
+            curveType + 18 * 3 - 2
+            /*BEZIER*/
+          );
+          r2 = this.getBezierValue(
+            time,
+            i,
+            5,
+            curveType + 18 * 4 - 2
+            /*BEZIER*/
+          );
+          g2 = this.getBezierValue(
+            time,
+            i,
+            6,
+            curveType + 18 * 5 - 2
+            /*BEZIER*/
+          );
+          b2 = this.getBezierValue(
+            time,
+            i,
+            7,
+            curveType + 18 * 6 - 2
+            /*BEZIER*/
+          );
       }
       if (alpha == 1) {
         light.set(r, g, b, a);
@@ -1653,7 +2186,7 @@ var spine = (() => {
         dark.g = g2;
         dark.b = b2;
       } else {
-        if (blend == 0) {
+        if (blend == 0 /* setup */) {
           light.setFromColor(slot.data.color);
           let setupDark = slot.data.darkColor;
           dark.r = setupDark.r;
@@ -1679,15 +2212,34 @@ var spine = (() => {
     getFrameEntries() {
       return 7;
     }
+    /** Sets the time in seconds, light, and dark colors for the specified key frame. */
     setFrame(frame, time, r, g, b, r2, g2, b2) {
       frame *= 7;
       this.frames[frame] = time;
-      this.frames[frame + 1] = r;
-      this.frames[frame + 2] = g;
-      this.frames[frame + 3] = b;
-      this.frames[frame + 4] = r2;
-      this.frames[frame + 5] = g2;
-      this.frames[frame + 6] = b2;
+      this.frames[
+        frame + 1
+        /*R*/
+      ] = r;
+      this.frames[
+        frame + 2
+        /*G*/
+      ] = g;
+      this.frames[
+        frame + 3
+        /*B*/
+      ] = b;
+      this.frames[
+        frame + 4
+        /*R2*/
+      ] = r2;
+      this.frames[
+        frame + 5
+        /*G2*/
+      ] = g2;
+      this.frames[
+        frame + 6
+        /*B2*/
+      ] = b2;
     }
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
       let slot = skeleton.slots[this.slotIndex];
@@ -1698,7 +2250,7 @@ var spine = (() => {
       if (time < frames[0]) {
         let setupLight = slot.data.color, setupDark = slot.data.darkColor;
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             light.r = setupLight.r;
             light.g = setupLight.g;
             light.b = setupLight.b;
@@ -1706,7 +2258,7 @@ var spine = (() => {
             dark.g = setupDark.g;
             dark.b = setupDark.b;
             return;
-          case 1:
+          case 1 /* first */:
             light.r += (setupLight.r - light.r) * alpha;
             light.g += (setupLight.g - light.g) * alpha;
             light.b += (setupLight.b - light.b) * alpha;
@@ -1717,40 +2269,141 @@ var spine = (() => {
         return;
       }
       let r = 0, g = 0, b = 0, a = 0, r2 = 0, g2 = 0, b2 = 0;
-      let i = Timeline.search(frames, time, 7);
-      let curveType = this.curves[i / 7];
+      let i = Timeline.search(
+        frames,
+        time,
+        7
+        /*ENTRIES*/
+      );
+      let curveType = this.curves[
+        i / 7
+        /*ENTRIES*/
+      ];
       switch (curveType) {
         case 0:
           let before = frames[i];
-          r = frames[i + 1];
-          g = frames[i + 2];
-          b = frames[i + 3];
-          r2 = frames[i + 4];
-          g2 = frames[i + 5];
-          b2 = frames[i + 6];
-          let t = (time - before) / (frames[i + 7] - before);
-          r += (frames[i + 7 + 1] - r) * t;
-          g += (frames[i + 7 + 2] - g) * t;
-          b += (frames[i + 7 + 3] - b) * t;
-          r2 += (frames[i + 7 + 4] - r2) * t;
-          g2 += (frames[i + 7 + 5] - g2) * t;
-          b2 += (frames[i + 7 + 6] - b2) * t;
+          r = frames[
+            i + 1
+            /*R*/
+          ];
+          g = frames[
+            i + 2
+            /*G*/
+          ];
+          b = frames[
+            i + 3
+            /*B*/
+          ];
+          r2 = frames[
+            i + 4
+            /*R2*/
+          ];
+          g2 = frames[
+            i + 5
+            /*G2*/
+          ];
+          b2 = frames[
+            i + 6
+            /*B2*/
+          ];
+          let t = (time - before) / (frames[
+            i + 7
+            /*ENTRIES*/
+          ] - before);
+          r += (frames[
+            i + 7 + 1
+            /*R*/
+          ] - r) * t;
+          g += (frames[
+            i + 7 + 2
+            /*G*/
+          ] - g) * t;
+          b += (frames[
+            i + 7 + 3
+            /*B*/
+          ] - b) * t;
+          r2 += (frames[
+            i + 7 + 4
+            /*R2*/
+          ] - r2) * t;
+          g2 += (frames[
+            i + 7 + 5
+            /*G2*/
+          ] - g2) * t;
+          b2 += (frames[
+            i + 7 + 6
+            /*B2*/
+          ] - b2) * t;
           break;
         case 1:
-          r = frames[i + 1];
-          g = frames[i + 2];
-          b = frames[i + 3];
-          r2 = frames[i + 4];
-          g2 = frames[i + 5];
-          b2 = frames[i + 6];
+          r = frames[
+            i + 1
+            /*R*/
+          ];
+          g = frames[
+            i + 2
+            /*G*/
+          ];
+          b = frames[
+            i + 3
+            /*B*/
+          ];
+          r2 = frames[
+            i + 4
+            /*R2*/
+          ];
+          g2 = frames[
+            i + 5
+            /*G2*/
+          ];
+          b2 = frames[
+            i + 6
+            /*B2*/
+          ];
           break;
         default:
-          r = this.getBezierValue(time, i, 1, curveType - 2);
-          g = this.getBezierValue(time, i, 2, curveType + 18 - 2);
-          b = this.getBezierValue(time, i, 3, curveType + 18 * 2 - 2);
-          r2 = this.getBezierValue(time, i, 4, curveType + 18 * 3 - 2);
-          g2 = this.getBezierValue(time, i, 5, curveType + 18 * 4 - 2);
-          b2 = this.getBezierValue(time, i, 6, curveType + 18 * 5 - 2);
+          r = this.getBezierValue(
+            time,
+            i,
+            1,
+            curveType - 2
+            /*BEZIER*/
+          );
+          g = this.getBezierValue(
+            time,
+            i,
+            2,
+            curveType + 18 - 2
+            /*BEZIER*/
+          );
+          b = this.getBezierValue(
+            time,
+            i,
+            3,
+            curveType + 18 * 2 - 2
+            /*BEZIER*/
+          );
+          r2 = this.getBezierValue(
+            time,
+            i,
+            4,
+            curveType + 18 * 3 - 2
+            /*BEZIER*/
+          );
+          g2 = this.getBezierValue(
+            time,
+            i,
+            5,
+            curveType + 18 * 4 - 2
+            /*BEZIER*/
+          );
+          b2 = this.getBezierValue(
+            time,
+            i,
+            6,
+            curveType + 18 * 5 - 2
+            /*BEZIER*/
+          );
       }
       if (alpha == 1) {
         light.r = r;
@@ -1760,7 +2413,7 @@ var spine = (() => {
         dark.g = g2;
         dark.b = b2;
       } else {
-        if (blend == 0) {
+        if (blend == 0 /* setup */) {
           let setupLight = slot.data.color, setupDark = slot.data.darkColor;
           light.r = setupLight.r;
           light.g = setupLight.g;
@@ -1790,6 +2443,7 @@ var spine = (() => {
     getFrameCount() {
       return this.frames.length;
     }
+    /** Sets the time in seconds and the attachment name for the specified key frame. */
     setFrame(frame, time, attachmentName) {
       this.frames[frame] = time;
       this.attachmentNames[frame] = attachmentName;
@@ -1798,13 +2452,13 @@ var spine = (() => {
       let slot = skeleton.slots[this.slotIndex];
       if (!slot.bone.active)
         return;
-      if (direction == 1) {
-        if (blend == 0)
+      if (direction == 1 /* mixOut */) {
+        if (blend == 0 /* setup */)
           this.setAttachment(skeleton, slot, slot.data.attachmentName);
         return;
       }
       if (time < this.frames[0]) {
-        if (blend == 0 || blend == 1)
+        if (blend == 0 /* setup */ || blend == 1 /* first */)
           this.setAttachment(skeleton, slot, slot.data.attachmentName);
         return;
       }
@@ -1827,10 +2481,14 @@ var spine = (() => {
     getFrameCount() {
       return this.frames.length;
     }
+    /** Sets the time in seconds and the vertices for the specified key frame.
+     * @param vertices Vertex positions for an unweighted VertexAttachment, or deform offsets if it has weights. */
     setFrame(frame, time, vertices) {
       this.frames[frame] = time;
       this.vertices[frame] = vertices;
     }
+    /** @param value1 Ignored (0 is used for a deform timeline).
+     * @param value2 Ignored (1 is used for a deform timeline). */
     setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2) {
       let curves = this.curves;
       let i = this.getFrameCount() + bezier * 18;
@@ -1888,16 +2546,16 @@ var spine = (() => {
         return;
       let deform = slot.deform;
       if (deform.length == 0)
-        blend = 0;
+        blend = 0 /* setup */;
       let vertices = this.vertices;
       let vertexCount = vertices[0].length;
       let frames = this.frames;
       if (time < frames[0]) {
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             deform.length = 0;
             return;
-          case 1:
+          case 1 /* first */:
             if (alpha == 1) {
               deform.length = 0;
               return;
@@ -1920,7 +2578,7 @@ var spine = (() => {
       if (time >= frames[frames.length - 1]) {
         let lastVertices = vertices[frames.length - 1];
         if (alpha == 1) {
-          if (blend == 3) {
+          if (blend == 3 /* add */) {
             let vertexAttachment = slotAttachment;
             if (!vertexAttachment.bones) {
               let setupVertices = vertexAttachment.vertices;
@@ -1934,7 +2592,7 @@ var spine = (() => {
             Utils.arrayCopy(lastVertices, 0, deform, 0, vertexCount);
         } else {
           switch (blend) {
-            case 0: {
+            case 0 /* setup */: {
               let vertexAttachment2 = slotAttachment;
               if (!vertexAttachment2.bones) {
                 let setupVertices = vertexAttachment2.vertices;
@@ -1948,12 +2606,12 @@ var spine = (() => {
               }
               break;
             }
-            case 1:
-            case 2:
+            case 1 /* first */:
+            case 2 /* replace */:
               for (let i2 = 0; i2 < vertexCount; i2++)
                 deform[i2] += (lastVertices[i2] - deform[i2]) * alpha;
               break;
-            case 3:
+            case 3 /* add */:
               let vertexAttachment = slotAttachment;
               if (!vertexAttachment.bones) {
                 let setupVertices = vertexAttachment.vertices;
@@ -1972,7 +2630,7 @@ var spine = (() => {
       let prevVertices = vertices[frame];
       let nextVertices = vertices[frame + 1];
       if (alpha == 1) {
-        if (blend == 3) {
+        if (blend == 3 /* add */) {
           let vertexAttachment = slotAttachment;
           if (!vertexAttachment.bones) {
             let setupVertices = vertexAttachment.vertices;
@@ -1994,7 +2652,7 @@ var spine = (() => {
         }
       } else {
         switch (blend) {
-          case 0: {
+          case 0 /* setup */: {
             let vertexAttachment2 = slotAttachment;
             if (!vertexAttachment2.bones) {
               let setupVertices = vertexAttachment2.vertices;
@@ -2010,14 +2668,14 @@ var spine = (() => {
             }
             break;
           }
-          case 1:
-          case 2:
+          case 1 /* first */:
+          case 2 /* replace */:
             for (let i2 = 0; i2 < vertexCount; i2++) {
               let prev = prevVertices[i2];
               deform[i2] += (prev + (nextVertices[i2] - prev) * percent - deform[i2]) * alpha;
             }
             break;
-          case 3:
+          case 3 /* add */:
             let vertexAttachment = slotAttachment;
             if (!vertexAttachment.bones) {
               let setupVertices = vertexAttachment.vertices;
@@ -2043,10 +2701,12 @@ var spine = (() => {
     getFrameCount() {
       return this.frames.length;
     }
+    /** Sets the time in seconds and the event for the specified key frame. */
     setFrame(frame, event) {
       this.frames[frame] = event.time;
       this.events[frame] = event;
     }
+    /** Fires events for frames > `lastTime` and <= `time`. */
     apply(skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
       if (!firedEvents)
         return;
@@ -2085,18 +2745,21 @@ var spine = (() => {
     getFrameCount() {
       return this.frames.length;
     }
+    /** Sets the time in seconds and the draw order for the specified key frame.
+     * @param drawOrder For each slot in {@link Skeleton#slots}, the index of the new draw order. May be null to use setup pose
+     *           draw order. */
     setFrame(frame, time, drawOrder) {
       this.frames[frame] = time;
       this.drawOrders[frame] = drawOrder;
     }
     apply(skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
-      if (direction == 1) {
-        if (blend == 0)
+      if (direction == 1 /* mixOut */) {
+        if (blend == 0 /* setup */)
           Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
         return;
       }
       if (time < this.frames[0]) {
-        if (blend == 0 || blend == 1)
+        if (blend == 0 /* setup */ || blend == 1 /* first */)
           Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
         return;
       }
@@ -2119,20 +2782,37 @@ var spine = (() => {
       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;
     }
     getFrameEntries() {
       return 6;
     }
+    /** Sets the time in seconds, mix, softness, bend direction, compress, and stretch for the specified key frame. */
     setFrame(frame, time, mix, softness, bendDirection, compress, stretch) {
       frame *= 6;
       this.frames[frame] = time;
-      this.frames[frame + 1] = mix;
-      this.frames[frame + 2] = softness;
-      this.frames[frame + 3] = bendDirection;
-      this.frames[frame + 4] = compress ? 1 : 0;
-      this.frames[frame + 5] = stretch ? 1 : 0;
+      this.frames[
+        frame + 1
+        /*MIX*/
+      ] = mix;
+      this.frames[
+        frame + 2
+        /*SOFTNESS*/
+      ] = softness;
+      this.frames[
+        frame + 3
+        /*BEND_DIRECTION*/
+      ] = bendDirection;
+      this.frames[
+        frame + 4
+        /*COMPRESS*/
+      ] = compress ? 1 : 0;
+      this.frames[
+        frame + 5
+        /*STRETCH*/
+      ] = stretch ? 1 : 0;
     }
     apply(skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
       let constraint = skeleton.ikConstraints[this.ikConstraintIndex];
@@ -2141,14 +2821,14 @@ var spine = (() => {
       let frames = this.frames;
       if (time < frames[0]) {
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             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;
             return;
-          case 1:
+          case 1 /* first */:
             constraint.mix += (constraint.data.mix - constraint.mix) * alpha;
             constraint.softness += (constraint.data.softness - constraint.softness) * alpha;
             constraint.bendDirection = constraint.data.bendDirection;
@@ -2158,44 +2838,103 @@ var spine = (() => {
         return;
       }
       let mix = 0, softness = 0;
-      let i = Timeline.search(frames, time, 6);
-      let curveType = this.curves[i / 6];
+      let i = Timeline.search(
+        frames,
+        time,
+        6
+        /*ENTRIES*/
+      );
+      let curveType = this.curves[
+        i / 6
+        /*ENTRIES*/
+      ];
       switch (curveType) {
         case 0:
           let before = frames[i];
-          mix = frames[i + 1];
-          softness = frames[i + 2];
-          let t = (time - before) / (frames[i + 6] - before);
-          mix += (frames[i + 6 + 1] - mix) * t;
-          softness += (frames[i + 6 + 2] - softness) * t;
+          mix = frames[
+            i + 1
+            /*MIX*/
+          ];
+          softness = frames[
+            i + 2
+            /*SOFTNESS*/
+          ];
+          let t = (time - before) / (frames[
+            i + 6
+            /*ENTRIES*/
+          ] - before);
+          mix += (frames[
+            i + 6 + 1
+            /*MIX*/
+          ] - mix) * t;
+          softness += (frames[
+            i + 6 + 2
+            /*SOFTNESS*/
+          ] - softness) * t;
           break;
         case 1:
-          mix = frames[i + 1];
-          softness = frames[i + 2];
+          mix = frames[
+            i + 1
+            /*MIX*/
+          ];
+          softness = frames[
+            i + 2
+            /*SOFTNESS*/
+          ];
           break;
         default:
-          mix = this.getBezierValue(time, i, 1, curveType - 2);
-          softness = this.getBezierValue(time, i, 2, curveType + 18 - 2);
-      }
-      if (blend == 0) {
+          mix = this.getBezierValue(
+            time,
+            i,
+            1,
+            curveType - 2
+            /*BEZIER*/
+          );
+          softness = this.getBezierValue(
+            time,
+            i,
+            2,
+            curveType + 18 - 2
+            /*BEZIER*/
+          );
+      }
+      if (blend == 0 /* setup */) {
         constraint.mix = constraint.data.mix + (mix - constraint.data.mix) * alpha;
         constraint.softness = constraint.data.softness + (softness - constraint.data.softness) * alpha;
-        if (direction == 1) {
+        if (direction == 1 /* mixOut */) {
           constraint.bendDirection = constraint.data.bendDirection;
           constraint.compress = constraint.data.compress;
           constraint.stretch = constraint.data.stretch;
         } else {
-          constraint.bendDirection = frames[i + 3];
-          constraint.compress = frames[i + 4] != 0;
-          constraint.stretch = frames[i + 5] != 0;
+          constraint.bendDirection = frames[
+            i + 3
+            /*BEND_DIRECTION*/
+          ];
+          constraint.compress = frames[
+            i + 4
+            /*COMPRESS*/
+          ] != 0;
+          constraint.stretch = frames[
+            i + 5
+            /*STRETCH*/
+          ] != 0;
         }
       } else {
         constraint.mix += (mix - constraint.mix) * alpha;
         constraint.softness += (softness - constraint.softness) * alpha;
-        if (direction == 0) {
-          constraint.bendDirection = frames[i + 3];
-          constraint.compress = frames[i + 4] != 0;
-          constraint.stretch = frames[i + 5] != 0;
+        if (direction == 0 /* mixIn */) {
+          constraint.bendDirection = frames[
+            i + 3
+            /*BEND_DIRECTION*/
+          ];
+          constraint.compress = frames[
+            i + 4
+            /*COMPRESS*/
+          ] != 0;
+          constraint.stretch = frames[
+            i + 5
+            /*STRETCH*/
+          ] != 0;
         }
       }
     }
@@ -2205,22 +2944,42 @@ var spine = (() => {
       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;
     }
     getFrameEntries() {
       return 7;
     }
+    /** The time in seconds, rotate mix, translate mix, scale mix, and shear mix for the specified key frame. */
     setFrame(frame, time, mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY) {
       let frames = this.frames;
       frame *= 7;
       frames[frame] = time;
-      frames[frame + 1] = mixRotate;
-      frames[frame + 2] = mixX;
-      frames[frame + 3] = mixY;
-      frames[frame + 4] = mixScaleX;
-      frames[frame + 5] = mixScaleY;
-      frames[frame + 6] = mixShearY;
+      frames[
+        frame + 1
+        /*ROTATE*/
+      ] = mixRotate;
+      frames[
+        frame + 2
+        /*X*/
+      ] = mixX;
+      frames[
+        frame + 3
+        /*Y*/
+      ] = mixY;
+      frames[
+        frame + 4
+        /*SCALEX*/
+      ] = mixScaleX;
+      frames[
+        frame + 5
+        /*SCALEY*/
+      ] = mixScaleY;
+      frames[
+        frame + 6
+        /*SHEARY*/
+      ] = mixShearY;
     }
     apply(skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
       let constraint = skeleton.transformConstraints[this.transformConstraintIndex];
@@ -2230,7 +2989,7 @@ var spine = (() => {
       if (time < frames[0]) {
         let data = constraint.data;
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             constraint.mixRotate = data.mixRotate;
             constraint.mixX = data.mixX;
             constraint.mixY = data.mixY;
@@ -2238,7 +2997,7 @@ var spine = (() => {
             constraint.mixScaleY = data.mixScaleY;
             constraint.mixShearY = data.mixShearY;
             return;
-          case 1:
+          case 1 /* first */:
             constraint.mixRotate += (data.mixRotate - constraint.mixRotate) * alpha;
             constraint.mixX += (data.mixX - constraint.mixX) * alpha;
             constraint.mixY += (data.mixY - constraint.mixY) * alpha;
@@ -2249,42 +3008,143 @@ var spine = (() => {
         return;
       }
       let rotate, x, y, scaleX, scaleY, shearY;
-      let i = Timeline.search(frames, time, 7);
-      let curveType = this.curves[i / 7];
+      let i = Timeline.search(
+        frames,
+        time,
+        7
+        /*ENTRIES*/
+      );
+      let curveType = this.curves[
+        i / 7
+        /*ENTRIES*/
+      ];
       switch (curveType) {
         case 0:
           let before = frames[i];
-          rotate = frames[i + 1];
-          x = frames[i + 2];
-          y = frames[i + 3];
-          scaleX = frames[i + 4];
-          scaleY = frames[i + 5];
-          shearY = frames[i + 6];
-          let t = (time - before) / (frames[i + 7] - before);
-          rotate += (frames[i + 7 + 1] - rotate) * t;
-          x += (frames[i + 7 + 2] - x) * t;
-          y += (frames[i + 7 + 3] - y) * t;
-          scaleX += (frames[i + 7 + 4] - scaleX) * t;
-          scaleY += (frames[i + 7 + 5] - scaleY) * t;
-          shearY += (frames[i + 7 + 6] - shearY) * t;
+          rotate = frames[
+            i + 1
+            /*ROTATE*/
+          ];
+          x = frames[
+            i + 2
+            /*X*/
+          ];
+          y = frames[
+            i + 3
+            /*Y*/
+          ];
+          scaleX = frames[
+            i + 4
+            /*SCALEX*/
+          ];
+          scaleY = frames[
+            i + 5
+            /*SCALEY*/
+          ];
+          shearY = frames[
+            i + 6
+            /*SHEARY*/
+          ];
+          let t = (time - before) / (frames[
+            i + 7
+            /*ENTRIES*/
+          ] - before);
+          rotate += (frames[
+            i + 7 + 1
+            /*ROTATE*/
+          ] - rotate) * t;
+          x += (frames[
+            i + 7 + 2
+            /*X*/
+          ] - x) * t;
+          y += (frames[
+            i + 7 + 3
+            /*Y*/
+          ] - y) * t;
+          scaleX += (frames[
+            i + 7 + 4
+            /*SCALEX*/
+          ] - scaleX) * t;
+          scaleY += (frames[
+            i + 7 + 5
+            /*SCALEY*/
+          ] - scaleY) * t;
+          shearY += (frames[
+            i + 7 + 6
+            /*SHEARY*/
+          ] - shearY) * t;
           break;
         case 1:
-          rotate = frames[i + 1];
-          x = frames[i + 2];
-          y = frames[i + 3];
-          scaleX = frames[i + 4];
-          scaleY = frames[i + 5];
-          shearY = frames[i + 6];
+          rotate = frames[
+            i + 1
+            /*ROTATE*/
+          ];
+          x = frames[
+            i + 2
+            /*X*/
+          ];
+          y = frames[
+            i + 3
+            /*Y*/
+          ];
+          scaleX = frames[
+            i + 4
+            /*SCALEX*/
+          ];
+          scaleY = frames[
+            i + 5
+            /*SCALEY*/
+          ];
+          shearY = frames[
+            i + 6
+            /*SHEARY*/
+          ];
           break;
         default:
-          rotate = this.getBezierValue(time, i, 1, curveType - 2);
-          x = this.getBezierValue(time, i, 2, curveType + 18 - 2);
-          y = this.getBezierValue(time, i, 3, curveType + 18 * 2 - 2);
-          scaleX = this.getBezierValue(time, i, 4, curveType + 18 * 3 - 2);
-          scaleY = this.getBezierValue(time, i, 5, curveType + 18 * 4 - 2);
-          shearY = this.getBezierValue(time, i, 6, curveType + 18 * 5 - 2);
-      }
-      if (blend == 0) {
+          rotate = this.getBezierValue(
+            time,
+            i,
+            1,
+            curveType - 2
+            /*BEZIER*/
+          );
+          x = this.getBezierValue(
+            time,
+            i,
+            2,
+            curveType + 18 - 2
+            /*BEZIER*/
+          );
+          y = this.getBezierValue(
+            time,
+            i,
+            3,
+            curveType + 18 * 2 - 2
+            /*BEZIER*/
+          );
+          scaleX = this.getBezierValue(
+            time,
+            i,
+            4,
+            curveType + 18 * 3 - 2
+            /*BEZIER*/
+          );
+          scaleY = this.getBezierValue(
+            time,
+            i,
+            5,
+            curveType + 18 * 4 - 2
+            /*BEZIER*/
+          );
+          shearY = this.getBezierValue(
+            time,
+            i,
+            6,
+            curveType + 18 * 5 - 2
+            /*BEZIER*/
+          );
+      }
+      if (blend == 0 /* setup */) {
         let data = constraint.data;
         constraint.mixRotate = data.mixRotate + (rotate - data.mixRotate) * alpha;
         constraint.mixX = data.mixX + (x - data.mixX) * alpha;
@@ -2305,6 +3165,7 @@ var spine = (() => {
   var PathConstraintPositionTimeline = class extends CurveTimeline1 {
     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;
     }
@@ -2315,16 +3176,16 @@ var spine = (() => {
       let frames = this.frames;
       if (time < frames[0]) {
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             constraint.position = constraint.data.position;
             return;
-          case 1:
+          case 1 /* first */:
             constraint.position += (constraint.data.position - constraint.position) * alpha;
         }
         return;
       }
       let position = this.getCurveValue(time);
-      if (blend == 0)
+      if (blend == 0 /* setup */)
         constraint.position = constraint.data.position + (position - constraint.data.position) * alpha;
       else
         constraint.position += (position - constraint.position) * alpha;
@@ -2333,6 +3194,7 @@ var spine = (() => {
   var PathConstraintSpacingTimeline = class extends CurveTimeline1 {
     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;
     }
@@ -2343,16 +3205,16 @@ var spine = (() => {
       let frames = this.frames;
       if (time < frames[0]) {
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             constraint.spacing = constraint.data.spacing;
             return;
-          case 1:
+          case 1 /* first */:
             constraint.spacing += (constraint.data.spacing - constraint.spacing) * alpha;
         }
         return;
       }
       let spacing = this.getCurveValue(time);
-      if (blend == 0)
+      if (blend == 0 /* setup */)
         constraint.spacing = constraint.data.spacing + (spacing - constraint.data.spacing) * alpha;
       else
         constraint.spacing += (spacing - constraint.spacing) * alpha;
@@ -2363,6 +3225,7 @@ var spine = (() => {
       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;
     }
@@ -2373,9 +3236,18 @@ var spine = (() => {
       let frames = this.frames;
       frame <<= 2;
       frames[frame] = time;
-      frames[frame + 1] = mixRotate;
-      frames[frame + 2] = mixX;
-      frames[frame + 3] = mixY;
+      frames[
+        frame + 1
+        /*ROTATE*/
+      ] = mixRotate;
+      frames[
+        frame + 2
+        /*X*/
+      ] = mixX;
+      frames[
+        frame + 3
+        /*Y*/
+      ] = mixY;
     }
     apply(skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
       let constraint = skeleton.pathConstraints[this.pathConstraintIndex];
@@ -2384,12 +3256,12 @@ var spine = (() => {
       let frames = this.frames;
       if (time < frames[0]) {
         switch (blend) {
-          case 0:
+          case 0 /* setup */:
             constraint.mixRotate = constraint.data.mixRotate;
             constraint.mixX = constraint.data.mixX;
             constraint.mixY = constraint.data.mixY;
             return;
-          case 1:
+          case 1 /* first */:
             constraint.mixRotate += (constraint.data.mixRotate - constraint.mixRotate) * alpha;
             constraint.mixX += (constraint.data.mixX - constraint.mixX) * alpha;
             constraint.mixY += (constraint.data.mixY - constraint.mixY) * alpha;
@@ -2397,30 +3269,83 @@ var spine = (() => {
         return;
       }
       let rotate, x, y;
-      let i = Timeline.search(frames, time, 4);
+      let i = Timeline.search(
+        frames,
+        time,
+        4
+        /*ENTRIES*/
+      );
       let curveType = this.curves[i >> 2];
       switch (curveType) {
         case 0:
           let before = frames[i];
-          rotate = frames[i + 1];
-          x = frames[i + 2];
-          y = frames[i + 3];
-          let t = (time - before) / (frames[i + 4] - before);
-          rotate += (frames[i + 4 + 1] - rotate) * t;
-          x += (frames[i + 4 + 2] - x) * t;
-          y += (frames[i + 4 + 3] - y) * t;
+          rotate = frames[
+            i + 1
+            /*ROTATE*/
+          ];
+          x = frames[
+            i + 2
+            /*X*/
+          ];
+          y = frames[
+            i + 3
+            /*Y*/
+          ];
+          let t = (time - before) / (frames[
+            i + 4
+            /*ENTRIES*/
+          ] - before);
+          rotate += (frames[
+            i + 4 + 1
+            /*ROTATE*/
+          ] - rotate) * t;
+          x += (frames[
+            i + 4 + 2
+            /*X*/
+          ] - x) * t;
+          y += (frames[
+            i + 4 + 3
+            /*Y*/
+          ] - y) * t;
           break;
         case 1:
-          rotate = frames[i + 1];
-          x = frames[i + 2];
-          y = frames[i + 3];
+          rotate = frames[
+            i + 1
+            /*ROTATE*/
+          ];
+          x = frames[
+            i + 2
+            /*X*/
+          ];
+          y = frames[
+            i + 3
+            /*Y*/
+          ];
           break;
         default:
-          rotate = this.getBezierValue(time, i, 1, curveType - 2);
-          x = this.getBezierValue(time, i, 2, curveType + 18 - 2);
-          y = this.getBezierValue(time, i, 3, curveType + 18 * 2 - 2);
-      }
-      if (blend == 0) {
+          rotate = this.getBezierValue(
+            time,
+            i,
+            1,
+            curveType - 2
+            /*BEZIER*/
+          );
+          x = this.getBezierValue(
+            time,
+            i,
+            2,
+            curveType + 18 - 2
+            /*BEZIER*/
+          );
+          y = this.getBezierValue(
+            time,
+            i,
+            3,
+            curveType + 18 * 2 - 2
+            /*BEZIER*/
+          );
+      }
+      if (blend == 0 /* setup */) {
         let data = constraint.data;
         constraint.mixRotate = data.mixRotate + (rotate - data.mixRotate) * alpha;
         constraint.mixX = data.mixX + (x - data.mixX) * alpha;
@@ -2449,6 +3374,9 @@ var spine = (() => {
     getAttachment() {
       return this.attachment;
     }
+    /** Sets the time, mode, index, and frame time for the specified frame.
+     * @param frame Between 0 and <code>frameCount</code>, inclusive.
+     * @param time Seconds between frames. */
     setFrame(frame, time, mode, index, delay) {
       let frames = this.frames;
       frame *= _SequenceTimeline.ENTRIES;
@@ -2468,7 +3396,7 @@ var spine = (() => {
       }
       let frames = this.frames;
       if (time < frames[0]) {
-        if (blend == 0 || blend == 1)
+        if (blend == 0 /* setup */ || blend == 1 /* first */)
           slot.sequenceIndex = -1;
         return;
       }
@@ -2480,29 +3408,29 @@ var spine = (() => {
         return;
       let index = modeAndIndex >> 4, count = this.attachment.sequence.regions.length;
       let mode = SequenceModeValues[modeAndIndex & 15];
-      if (mode != SequenceMode.hold) {
+      if (mode != 0 /* hold */) {
         index += (time - before) / delay + 1e-5 | 0;
         switch (mode) {
-          case SequenceMode.once:
+          case 1 /* once */:
             index = Math.min(count - 1, index);
             break;
-          case SequenceMode.loop:
+          case 2 /* loop */:
             index %= count;
             break;
-          case SequenceMode.pingpong: {
+          case 3 /* pingpong */: {
             let n = (count << 1) - 2;
             index = n == 0 ? 0 : index % n;
             if (index >= count)
               index = n - index;
             break;
           }
-          case SequenceMode.onceReverse:
+          case 4 /* onceReverse */:
             index = Math.max(count - 1 - index, 0);
             break;
-          case SequenceMode.loopReverse:
+          case 5 /* loopReverse */:
             index = count - 1 - index % count;
             break;
-          case SequenceMode.pingpongReverse: {
+          case 6 /* pingpongReverse */: {
             let n = (count << 1) - 2;
             index = n == 0 ? 0 : (index + count - 1) % n;
             if (index >= count)
@@ -2521,7 +3449,12 @@ var spine = (() => {
   // 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();
@@ -2535,6 +3468,7 @@ var spine = (() => {
     static emptyAnimation() {
       return _AnimationState._emptyAnimation;
     }
+    /** Increments each track entry {@link TrackEntry#trackTime()}, setting queued animations as current if needed. */
     update(delta) {
       delta *= this.timeScale;
       let tracks = this.tracks;
@@ -2586,6 +3520,7 @@ var spine = (() => {
       }
       this.queue.drain();
     }
+    /** Returns true when all mixing from entries are complete. */
     updateMixingFrom(to, delta) {
       let from = to.mixingFrom;
       if (!from)
@@ -2607,6 +3542,9 @@ var spine = (() => {
       to.mixTime += delta;
       return false;
     }
+    /** Poses the skeleton using the track entry animations. There are no side effects other than invoking listeners, so the
+     * animation state can be applied to multiple skeletons to pose them identically.
+     * @returns True if any animations were applied. */
     apply(skeleton) {
       if (!skeleton)
         throw new Error("skeleton cannot be null.");
@@ -2620,7 +3558,7 @@ var spine = (() => {
         if (!current || current.delay > 0)
           continue;
         applied = true;
-        let blend = i2 == 0 ? MixBlend.first : current.mixBlend;
+        let blend = i2 == 0 ? 1 /* first */ : current.mixBlend;
         let mix = current.alpha;
         if (current.mixingFrom)
           mix *= this.applyMixingFrom(current, skeleton, blend);
@@ -2634,14 +3572,14 @@ var spine = (() => {
         }
         let timelines = current.animation.timelines;
         let timelineCount = timelines.length;
-        if (i2 == 0 && mix == 1 || blend == MixBlend.add) {
+        if (i2 == 0 && mix == 1 || blend == 3 /* add */) {
           for (let ii = 0; ii < timelineCount; ii++) {
             Utils.webkit602BugfixHelper(mix, blend);
             var timeline = timelines[ii];
             if (timeline instanceof AttachmentTimeline)
               this.applyAttachmentTimeline(timeline, skeleton, applyTime, blend, true);
             else
-              timeline.apply(skeleton, animationLast, applyTime, applyEvents, mix, blend, MixDirection.mixIn);
+              timeline.apply(skeleton, animationLast, applyTime, applyEvents, mix, blend, 0 /* mixIn */);
           }
         } else {
           let timelineMode = current.timelineMode;
@@ -2651,14 +3589,14 @@ var spine = (() => {
             current.timelinesRotation.length = timelineCount << 1;
           for (let ii = 0; ii < timelineCount; ii++) {
             let timeline2 = timelines[ii];
-            let timelineBlend = timelineMode[ii] == SUBSEQUENT ? blend : MixBlend.setup;
+            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);
             } else if (timeline2 instanceof AttachmentTimeline) {
               this.applyAttachmentTimeline(timeline2, skeleton, applyTime, blend, true);
             } else {
               Utils.webkit602BugfixHelper(mix, blend);
-              timeline2.apply(skeleton, animationLast, applyTime, applyEvents, mix, timelineBlend, MixDirection.mixIn);
+              timeline2.apply(skeleton, animationLast, applyTime, applyEvents, mix, timelineBlend, 0 /* mixIn */);
             }
           }
         }
@@ -2687,13 +3625,13 @@ var spine = (() => {
       let mix = 0;
       if (to.mixDuration == 0) {
         mix = 1;
-        if (blend == MixBlend.first)
-          blend = MixBlend.setup;
+        if (blend == 1 /* first */)
+          blend = 0 /* setup */;
       } else {
         mix = to.mixTime / to.mixDuration;
         if (mix > 1)
           mix = 1;
-        if (blend != MixBlend.first)
+        if (blend != 1 /* first */)
           blend = from.mixBlend;
       }
       let attachments = mix < from.attachmentThreshold, drawOrder = mix < from.drawOrderThreshold;
@@ -2706,9 +3644,9 @@ var spine = (() => {
         applyTime = from.animation.duration - applyTime;
       else if (mix < from.eventThreshold)
         events = this.events;
-      if (blend == MixBlend.add) {
+      if (blend == 3 /* add */) {
         for (let i = 0; i < timelineCount; i++)
-          timelines[i].apply(skeleton, animationLast, applyTime, events, alphaMix, blend, MixDirection.mixOut);
+          timelines[i].apply(skeleton, animationLast, applyTime, events, alphaMix, blend, 1 /* mixOut */);
       } else {
         let timelineMode = from.timelineMode;
         let timelineHoldMix = from.timelineHoldMix;
@@ -2719,7 +3657,7 @@ var spine = (() => {
         from.totalAlpha = 0;
         for (let i = 0; i < timelineCount; i++) {
           let timeline = timelines[i];
-          let direction = MixDirection.mixOut;
+          let direction = 1 /* mixOut */;
           let timelineBlend;
           let alpha = 0;
           switch (timelineMode[i]) {
@@ -2730,7 +3668,7 @@ var spine = (() => {
               alpha = alphaMix;
               break;
             case FIRST:
-              timelineBlend = MixBlend.setup;
+              timelineBlend = 0 /* setup */;
               alpha = alphaMix;
               break;
             case HOLD_SUBSEQUENT:
@@ -2738,11 +3676,11 @@ var spine = (() => {
               alpha = alphaHold;
               break;
             case HOLD_FIRST:
-              timelineBlend = MixBlend.setup;
+              timelineBlend = 0 /* setup */;
               alpha = alphaHold;
               break;
             default:
-              timelineBlend = MixBlend.setup;
+              timelineBlend = 0 /* setup */;
               let holdMix = timelineHoldMix[i];
               alpha = alphaHold * Math.max(0, 1 - holdMix.mixTime / holdMix.mixDuration);
               break;
@@ -2754,8 +3692,8 @@ var spine = (() => {
             this.applyAttachmentTimeline(timeline, skeleton, applyTime, timelineBlend, attachments);
           else {
             Utils.webkit602BugfixHelper(alpha, blend);
-            if (drawOrder && timeline instanceof DrawOrderTimeline && timelineBlend == MixBlend.setup)
-              direction = MixDirection.mixIn;
+            if (drawOrder && timeline instanceof DrawOrderTimeline && timelineBlend == 0 /* setup */)
+              direction = 0 /* mixIn */;
             timeline.apply(skeleton, animationLast, applyTime, events, alpha, timelineBlend, direction);
           }
         }
@@ -2772,7 +3710,7 @@ var spine = (() => {
       if (!slot.bone.active)
         return;
       if (time < timeline.frames[0]) {
-        if (blend == MixBlend.setup || blend == MixBlend.first)
+        if (blend == 0 /* setup */ || blend == 1 /* first */)
           this.setAttachment(skeleton, slot, slot.data.attachmentName, attachments);
       } else
         this.setAttachment(skeleton, slot, timeline.attachmentNames[Timeline.search1(timeline.frames, time)], attachments);
@@ -2788,7 +3726,7 @@ var spine = (() => {
       if (firstFrame)
         timelinesRotation[i] = 0;
       if (alpha == 1) {
-        timeline.apply(skeleton, 0, time, null, 1, blend, MixDirection.mixIn);
+        timeline.apply(skeleton, 0, time, null, 1, blend, 0 /* mixIn */);
         return;
       }
       let bone = skeleton.bones[timeline.boneIndex];
@@ -2798,16 +3736,16 @@ var spine = (() => {
       let r1 = 0, r2 = 0;
       if (time < frames[0]) {
         switch (blend) {
-          case MixBlend.setup:
+          case 0 /* setup */:
             bone.rotation = bone.data.rotation;
           default:
             return;
-          case MixBlend.first:
+          case 1 /* first */:
             r1 = bone.rotation;
             r2 = bone.data.rotation;
         }
       } else {
-        r1 = blend == MixBlend.setup ? bone.data.rotation : bone.rotation;
+        r1 = blend == 0 /* setup */ ? bone.data.rotation : bone.rotation;
         r2 = bone.data.rotation + timeline.getCurveValue(time);
       }
       let total = 0, diff = r2 - r1;
@@ -2870,6 +3808,10 @@ var spine = (() => {
         this.queue.event(entry, event);
       }
     }
+    /** Removes all animations from all tracks, leaving skeletons in their current pose.
+     *
+     * It may be desired to use {@link AnimationState#setEmptyAnimation()} to mix the skeletons back to the setup pose,
+     * rather than leaving them in their current pose. */
     clearTracks() {
       let oldDrainDisabled = this.queue.drainDisabled;
       this.queue.drainDisabled = true;
@@ -2879,6 +3821,10 @@ var spine = (() => {
       this.queue.drainDisabled = oldDrainDisabled;
       this.queue.drain();
     }
+    /** Removes all animations from the track, leaving skeletons in their current pose.
+     *
+     * It may be desired to use {@link AnimationState#setEmptyAnimation()} to mix the skeletons back to the setup pose,
+     * rather than leaving them in their current pose. */
     clearTrack(trackIndex) {
       if (trackIndex >= this.tracks.length)
         return;
@@ -2916,12 +3862,21 @@ var spine = (() => {
       }
       this.queue.start(current);
     }
+    /** Sets an animation by name.
+      *
+      * See {@link #setAnimationWith()}. */
     setAnimation(trackIndex, animationName, loop = false) {
       let animation = this.data.skeletonData.findAnimation(animationName);
       if (!animation)
         throw new Error("Animation not found: " + animationName);
       return this.setAnimationWith(trackIndex, animation, loop);
     }
+    /** Sets the current animation for a track, discarding any queued animations. If the formerly current track entry was never
+     * applied to a skeleton, it is replaced (not mixed from).
+     * @param loop If true, the animation will repeat. If false it will not, instead its last frame is applied if played beyond its
+     *           duration. In either case {@link TrackEntry#trackEnd} determines when the track is cleared.
+     * @returns A track entry to allow further customization of animation playback. References to the track entry must not be kept
+     *         after the {@link AnimationStateListener#dispose()} event occurs. */
     setAnimationWith(trackIndex, animation, loop = false) {
       if (!animation)
         throw new Error("animation cannot be null.");
@@ -2943,12 +3898,23 @@ var spine = (() => {
       this.queue.drain();
       return entry;
     }
+    /** Queues an animation by name.
+     *
+     * See {@link #addAnimationWith()}. */
     addAnimation(trackIndex, animationName, loop = false, delay = 0) {
       let animation = this.data.skeletonData.findAnimation(animationName);
       if (!animation)
         throw new Error("Animation not found: " + animationName);
       return this.addAnimationWith(trackIndex, animation, loop, delay);
     }
+    /** Adds an animation to be played after the current or last queued animation for a track. If the track is empty, it is
+     * equivalent to calling {@link #setAnimationWith()}.
+     * @param delay If > 0, sets {@link TrackEntry#delay}. If <= 0, the delay set is the duration of the previous track entry
+     *           minus any mix duration (from the {@link AnimationStateData}) plus the specified `delay` (ie the mix
+     *           ends at (`delay` = 0) or before (`delay` < 0) the previous track entry duration). If the
+     *           previous entry is looping, its next loop completion is used instead of its duration.
+     * @returns A track entry to allow further customization of animation playback. References to the track entry must not be kept
+     *         after the {@link AnimationStateListener#dispose()} event occurs. */
     addAnimationWith(trackIndex, animation, loop = false, delay = 0) {
       if (!animation)
         throw new Error("animation cannot be null.");
@@ -2970,12 +3936,37 @@ var spine = (() => {
       entry.delay = delay;
       return entry;
     }
+    /** Sets an empty animation for a track, discarding any queued animations, and sets the track entry's
+     * {@link TrackEntry#mixduration}. An empty animation has no timelines and serves as a placeholder for mixing in or out.
+     *
+     * Mixing out is done by setting an empty animation with a mix duration using either {@link #setEmptyAnimation()},
+     * {@link #setEmptyAnimations()}, or {@link #addEmptyAnimation()}. Mixing to an empty animation causes
+     * the previous animation to be applied less and less over the mix duration. Properties keyed in the previous animation
+     * transition to the value from lower tracks or to the setup pose value if no lower tracks key the property. A mix duration of
+     * 0 still mixes out over one frame.
+     *
+     * Mixing in is done by first setting an empty animation, then adding an animation using
+     * {@link #addAnimation()} and on the returned track entry, set the
+     * {@link TrackEntry#setMixDuration()}. Mixing from an empty animation causes the new animation to be applied more and
+     * more over the mix duration. Properties keyed in the new animation transition from the value from lower tracks or from the
+     * setup pose value if no lower tracks key the property to the value keyed in the new animation. */
     setEmptyAnimation(trackIndex, mixDuration = 0) {
       let entry = this.setAnimationWith(trackIndex, _AnimationState.emptyAnimation(), false);
       entry.mixDuration = mixDuration;
       entry.trackEnd = mixDuration;
       return entry;
     }
+    /** Adds an empty animation to be played after the current or last queued animation for a track, and sets the track entry's
+     * {@link TrackEntry#mixDuration}. If the track is empty, it is equivalent to calling
+     * {@link #setEmptyAnimation()}.
+     *
+     * See {@link #setEmptyAnimation()}.
+     * @param delay If > 0, sets {@link TrackEntry#delay}. If <= 0, the delay set is the duration of the previous track entry
+     *           minus any mix duration plus the specified `delay` (ie the mix ends at (`delay` = 0) or
+     *           before (`delay` < 0) the previous track entry duration). If the previous entry is looping, its next
+     *           loop completion is used instead of its duration.
+     * @return A track entry to allow further customization of animation playback. References to the track entry must not be kept
+     *         after the {@link AnimationStateListener#dispose()} event occurs. */
     addEmptyAnimation(trackIndex, mixDuration = 0, delay = 0) {
       let entry = this.addAnimationWith(trackIndex, _AnimationState.emptyAnimation(), false, delay);
       if (delay <= 0)
@@ -2984,6 +3975,8 @@ var spine = (() => {
       entry.trackEnd = mixDuration;
       return entry;
     }
+    /** Sets an empty animation for every track, discarding any queued animations, and mixes to it over the specified mix
+      * duration. */
     setEmptyAnimations(mixDuration = 0) {
       let oldDrainDisabled = this.queue.drainDisabled;
       this.queue.drainDisabled = true;
@@ -3002,6 +3995,7 @@ var spine = (() => {
       this.tracks.length = index + 1;
       return null;
     }
+    /** @param last May be null. */
     trackEntry(trackIndex, animation, loop, last) {
       let entry = this.trackEntryPool.obtain();
       entry.reset();
@@ -3029,9 +4023,10 @@ var spine = (() => {
       entry.mixDuration = !last ? 0 : this.data.getMix(last.animation, animation);
       entry.interruptAlpha = 1;
       entry.totalAlpha = 0;
-      entry.mixBlend = MixBlend.replace;
+      entry.mixBlend = 2 /* replace */;
       return entry;
     }
+    /** Removes the {@link TrackEntry#getNext() next entry} and all entries after it for the specified entry. */
     clearNext(entry) {
       let next = entry.next;
       while (next) {
@@ -3051,7 +4046,7 @@ var spine = (() => {
         while (entry.mixingFrom)
           entry = entry.mixingFrom;
         do {
-          if (!entry.mixingTo || entry.mixBlend != MixBlend.add)
+          if (!entry.mixingTo || entry.mixBlend != 3 /* add */)
             this.computeHold(entry);
           entry = entry.mixingTo;
         } while (entry);
@@ -3094,24 +4089,31 @@ var spine = (() => {
           }
         }
     }
+    /** Returns the track entry for the animation currently playing on the track, or null if no animation is currently playing. */
     getCurrent(trackIndex) {
       if (trackIndex >= this.tracks.length)
         return null;
       return this.tracks[trackIndex];
     }
+    /** Adds a listener to receive events for all track entries. */
     addListener(listener) {
       if (!listener)
         throw new Error("listener cannot be null.");
       this.listeners.push(listener);
     }
+    /** Removes the listener added with {@link #addListener()}. */
     removeListener(listener) {
       let index = this.listeners.indexOf(listener);
       if (index >= 0)
         this.listeners.splice(index, 1);
     }
+    /** Removes all listeners added with {@link #addListener()}. */
     clearListeners() {
       this.listeners.length = 0;
     }
+    /** Discards all listener notifications that have not yet been delivered. This can be useful to call from an
+     * {@link AnimationStateListener} when it is known that further notifications that may have been already queued for delivery
+     * are not wanted because new animations are being set. */
     clearListenerNotifications() {
       this.queue.clear();
     }
@@ -3120,36 +4122,134 @@ var spine = (() => {
   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;
-      this.mixBlend = MixBlend.replace;
+      /** 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();
@@ -3165,6 +4265,9 @@ var spine = (() => {
       this.timelineHoldMix.length = 0;
       this.timelinesRotation.length = 0;
     }
+    /** Uses {@link #trackTime} to compute the `animationTime`, which is between {@link #animationStart}
+     * and {@link #animationEnd}. When the `trackTime` is 0, the `animationTime` is equal to the
+     * `animationStart` time. */
     getAnimationTime() {
       if (this.loop) {
         let duration = this.animationEnd - this.animationStart;
@@ -3178,9 +4281,19 @@ var spine = (() => {
       this.animationLast = animationLast;
       this.nextAnimationLast = animationLast;
     }
+    /** Returns true if at least one loop has been completed.
+     *
+     * See {@link AnimationStateListener#complete()}. */
     isComplete() {
       return this.trackTime >= this.animationEnd - this.animationStart;
     }
+    /** Resets the rotation directions for mixing this entry's rotate timelines. This can be useful to avoid bones rotating the
+     * long way around when using {@link #alpha} and starting animations on other tracks.
+     *
+     * Mixing with {@link MixBlend#replace} involves finding a rotation between two others, which has two possible solutions:
+     * the short way or the long way around. The two rotations likely change over time, so which direction is the short or long
+     * way also changes. If the short way was always chosen, bones would flip to the other side when that direction became the
+     * long way. TrackEntry chooses the short way the first time it is applied and remembers that direction. */
     resetRotationDirections() {
       this.timelinesRotation.length = 0;
     }
@@ -3302,15 +4415,15 @@ var spine = (() => {
       this.objects.length = 0;
     }
   };
-  var EventType;
-  (function(EventType2) {
+  var EventType = /* @__PURE__ */ ((EventType2) => {
     EventType2[EventType2["start"] = 0] = "start";
     EventType2[EventType2["interrupt"] = 1] = "interrupt";
     EventType2[EventType2["end"] = 2] = "end";
     EventType2[EventType2["dispose"] = 3] = "dispose";
     EventType2[EventType2["complete"] = 4] = "complete";
     EventType2[EventType2["event"] = 5] = "event";
-  })(EventType || (EventType = {}));
+    return EventType2;
+  })(EventType || {});
   var AnimationStateAdapter = class {
     start(entry) {
     }
@@ -3337,11 +4450,15 @@ var spine = (() => {
   var AnimationStateData = class {
     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;
     }
+    /** Sets a mix duration by animation name.
+     *
+     * See {@link #setMixWith()}. */
     setMix(fromName, toName, duration) {
       let from = this.skeletonData.findAnimation(fromName);
       if (!from)
@@ -3351,6 +4468,9 @@ var spine = (() => {
         throw new Error("Animation not found: " + toName);
       this.setMixWith(from, to, duration);
     }
+    /** Sets the mix duration when changing from the specified animation to the other.
+     *
+     * See {@link TrackEntry#mixDuration}. */
     setMixWith(from, to, duration) {
       if (!from)
         throw new Error("from cannot be null.");
@@ -3359,6 +4479,8 @@ var spine = (() => {
       let key = from.name + "." + to.name;
       this.animationToMixTime[key] = duration;
     }
+    /** Returns the mix duration to use when changing from the specified animation to the other, or the {@link #defaultMix} if
+      * no mix duration has been set. */
     getMix(from, to) {
       let key = from.name + "." + to.name;
       let value = this.animationToMixTime[key];
@@ -3382,9 +4504,15 @@ var spine = (() => {
 
   // spine-core/src/attachments/ClippingAttachment.ts
   var ClippingAttachment = class extends VertexAttachment {
+    // 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() {
@@ -3405,8 +4533,7 @@ var spine = (() => {
       return this._image;
     }
   };
-  var TextureFilter;
-  (function(TextureFilter3) {
+  var TextureFilter = /* @__PURE__ */ ((TextureFilter3) => {
     TextureFilter3[TextureFilter3["Nearest"] = 9728] = "Nearest";
     TextureFilter3[TextureFilter3["Linear"] = 9729] = "Linear";
     TextureFilter3[TextureFilter3["MipMap"] = 9987] = "MipMap";
@@ -3414,13 +4541,14 @@ var spine = (() => {
     TextureFilter3[TextureFilter3["MipMapLinearNearest"] = 9985] = "MipMapLinearNearest";
     TextureFilter3[TextureFilter3["MipMapNearestLinear"] = 9986] = "MipMapNearestLinear";
     TextureFilter3[TextureFilter3["MipMapLinearLinear"] = 9987] = "MipMapLinearLinear";
-  })(TextureFilter || (TextureFilter = {}));
-  var TextureWrap;
-  (function(TextureWrap3) {
+    return TextureFilter3;
+  })(TextureFilter || {});
+  var TextureWrap = /* @__PURE__ */ ((TextureWrap3) => {
     TextureWrap3[TextureWrap3["MirroredRepeat"] = 33648] = "MirroredRepeat";
     TextureWrap3[TextureWrap3["ClampToEdge"] = 33071] = "ClampToEdge";
     TextureWrap3[TextureWrap3["Repeat"] = 10497] = "Repeat";
-  })(TextureWrap || (TextureWrap = {}));
+    return TextureWrap3;
+  })(TextureWrap || {});
   var TextureRegion = class {
     constructor() {
       this.u = 0;
@@ -3465,9 +4593,9 @@ var spine = (() => {
       };
       pageFields["repeat"] = (page2) => {
         if (entry[1].indexOf("x") != -1)
-          page2.uWrap = TextureWrap.Repeat;
+          page2.uWrap = 10497 /* Repeat */;
         if (entry[1].indexOf("y") != -1)
-          page2.vWrap = TextureWrap.Repeat;
+          page2.vWrap = 10497 /* Repeat */;
       };
       pageFields["pma"] = (page2) => {
         page2.pma = entry[1] == "true";
@@ -3638,20 +4766,23 @@ var spine = (() => {
   };
   var TextureAtlasPage = class {
     constructor(name) {
-      this.minFilter = TextureFilter.Nearest;
-      this.magFilter = TextureFilter.Nearest;
-      this.uWrap = TextureWrap.ClampToEdge;
-      this.vWrap = TextureWrap.ClampToEdge;
+      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) {
       this.texture = texture;
       texture.setFilters(this.minFilter, this.magFilter);
       texture.setWraps(this.uWrap, this.vWrap);
+      for (let region of this.regions)
+        region.texture = texture;
     }
   };
   var TextureAtlasRegion = class extends TextureRegion {
@@ -3669,6 +4800,7 @@ var spine = (() => {
       this.values = null;
       this.page = page;
       this.name = name;
+      page.regions.push(this);
     }
   };
 
@@ -3677,19 +4809,32 @@ var spine = (() => {
     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
+     * the {@link #regionUVs} are changed. */
     updateRegion() {
       if (!this.region)
         throw new Error("Region not set.");
@@ -3700,8 +4845,8 @@ var spine = (() => {
       let n = this.uvs.length;
       let u = this.region.u, v = this.region.v, width = 0, height = 0;
       if (this.region instanceof TextureAtlasRegion) {
-        let region = this.region, image = region.page.texture.getImage();
-        let textureWidth = image.width, textureHeight = image.height;
+        let region = this.region, page = region.page;
+        let textureWidth = page.width, textureHeight = page.height;
         switch (region.degrees) {
           case 90:
             u -= (region.originalHeight - region.offsetY - region.height) / textureWidth;
@@ -3750,9 +4895,13 @@ var spine = (() => {
         uvs[i + 1] = v + regionUVs[i + 1] * height;
       }
     }
+    /** The parent mesh if this is a linked mesh, else null. A linked mesh shares the {@link #bones}, {@link #vertices},
+     * {@link #regionUVs}, {@link #triangles}, {@link #hullLength}, {@link #edges}, {@link #width}, and {@link #height} with the
+     * parent mesh, but may have a different {@link #name} or {@link #path} (and therefore a different texture). */
     getParentMesh() {
       return this.parentMesh;
     }
+    /** @param parentMesh May be null. */
     setParentMesh(parentMesh) {
       this.parentMesh = parentMesh;
       if (parentMesh) {
@@ -3793,6 +4942,7 @@ var spine = (() => {
         this.sequence.apply(slot, this);
       super.computeWorldVertices(slot, start, count, worldVertices2, offset, stride);
     }
+    /** Returns a new mesh with the {@link #parentMesh} set to this mesh's parent mesh, if any, else to this mesh. **/
     newLinkedMesh() {
       let copy = new MeshAttachment(this.name, this.path);
       copy.region = this.region;
@@ -3809,9 +4959,15 @@ var spine = (() => {
   var PathAttachment = class extends VertexAttachment {
     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() {
@@ -3833,6 +4989,8 @@ var spine = (() => {
       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) {
@@ -3860,22 +5018,33 @@ var spine = (() => {
   var _RegionAttachment = class extends Attachment {
     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.rendererObject = null;
       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. */
     updateRegion() {
       if (!this.region)
         throw new Error("Region not set.");
@@ -3939,6 +5108,14 @@ var spine = (() => {
         uvs[7] = region.v2;
       }
     }
+    /** Transforms the attachment's four vertices to world coordinates. If the attachment has a {@link #sequence}, the region may
+     * be changed.
+     * <p>
+     * See <a href="http://esotericsoftware.com/spine-runtime-skeletons#World-transforms">World transforms</a> in the Spine
+     * Runtimes Guide.
+     * @param worldVertices The output world vertices. Must have a length >= <code>offset</code> + 8.
+     * @param offset The <code>worldVertices</code> index to begin writing values.
+     * @param stride The number of <code>worldVertices</code> entries between the value pairs written. */
     computeWorldVertices(slot, worldVertices2, offset, stride) {
       if (this.sequence != null)
         this.sequence.apply(slot, this);
@@ -3970,7 +5147,6 @@ var spine = (() => {
     copy() {
       let copy = new _RegionAttachment(this.name, this.path);
       copy.region = this.region;
-      copy.rendererObject = this.rendererObject;
       copy.x = this.x;
       copy.y = this.y;
       copy.scaleX = this.scaleX;
@@ -4032,7 +5208,6 @@ var spine = (() => {
         if (region == null)
           throw new Error("Region not found in atlas: " + path + " (sequence: " + name + ")");
         regions[i] = region;
-        regions[i].renderObject = regions[i];
       }
     }
     newRegionAttachment(skin, name, path, sequence) {
@@ -4043,7 +5218,6 @@ var spine = (() => {
         let region = this.atlas.findRegion(path);
         if (!region)
           throw new Error("Region not found in atlas: " + path + " (region attachment: " + name + ")");
-        region.renderObject = region;
         attachment.region = region;
       }
       return attachment;
@@ -4056,7 +5230,6 @@ var spine = (() => {
         let region = this.atlas.findRegion(path);
         if (!region)
           throw new Error("Region not found in atlas: " + path + " (mesh attachment: " + name + ")");
-        region.renderObject = region;
         attachment.region = region;
       }
       return attachment;
@@ -4078,18 +5251,34 @@ var spine = (() => {
   // spine-core/src/BoneData.ts
   var BoneData = class {
     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.");
@@ -4100,39 +5289,62 @@ var spine = (() => {
       this.parent = parent;
     }
   };
-  var TransformMode;
-  (function(TransformMode2) {
+  var TransformMode = /* @__PURE__ */ ((TransformMode2) => {
     TransformMode2[TransformMode2["Normal"] = 0] = "Normal";
     TransformMode2[TransformMode2["OnlyTranslation"] = 1] = "OnlyTranslation";
     TransformMode2[TransformMode2["NoRotationOrReflection"] = 2] = "NoRotationOrReflection";
     TransformMode2[TransformMode2["NoScale"] = 3] = "NoScale";
     TransformMode2[TransformMode2["NoScaleOrReflection"] = 4] = "NoScaleOrReflection";
-  })(TransformMode || (TransformMode = {}));
+    return TransformMode2;
+  })(TransformMode || {});
 
   // spine-core/src/Bone.ts
   var Bone = class {
+    /** @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;
@@ -4145,15 +5357,26 @@ var spine = (() => {
       this.parent = parent;
       this.setToSetupPose();
     }
+    /** Returns false when the bone has not been computed because {@link BoneData#skinRequired} is true and the
+      * {@link Skeleton#skin active skin} does not {@link Skin#bones contain} this bone. */
     isActive() {
       return this.active;
     }
+    /** Computes the world transform using the parent bone and this bone's local applied transform. */
     update() {
       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.
+     *
+     * See {@link #updateWorldTransformWith()}. */
     updateWorldTransform() {
       this.updateWorldTransformWith(this.x, this.y, this.rotation, this.scaleX, this.scaleY, this.shearX, this.shearY);
     }
+    /** Computes the world transform using the parent bone and the specified local transform. The applied transform is set to the
+     * specified local transform. Child bones are not updated.
+     *
+     * See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine
+     * Runtimes Guide. */
     updateWorldTransformWith(x, y, rotation, scaleX, scaleY, shearX, shearY) {
       this.ax = x;
       this.ay = y;
@@ -4180,7 +5403,7 @@ var spine = (() => {
       this.worldX = pa * x + pb * y + parent.worldX;
       this.worldY = pc * x + pd * y + parent.worldY;
       switch (this.data.transformMode) {
-        case TransformMode.Normal: {
+        case 0 /* Normal */: {
           let rotationY = rotation + 90 + shearY;
           let la = MathUtils.cosDeg(rotation + shearX) * scaleX;
           let lb = MathUtils.cosDeg(rotationY) * scaleY;
@@ -4192,7 +5415,7 @@ var spine = (() => {
           this.d = pc * lb + pd * ld;
           return;
         }
-        case TransformMode.OnlyTranslation: {
+        case 1 /* OnlyTranslation */: {
           let rotationY = rotation + 90 + shearY;
           this.a = MathUtils.cosDeg(rotation + shearX) * scaleX;
           this.b = MathUtils.cosDeg(rotationY) * scaleY;
@@ -4200,7 +5423,7 @@ var spine = (() => {
           this.d = MathUtils.sinDeg(rotationY) * scaleY;
           break;
         }
-        case TransformMode.NoRotationOrReflection: {
+        case 2 /* NoRotationOrReflection */: {
           let s = pa * pa + pc * pc;
           let prx = 0;
           if (s > 1e-4) {
@@ -4227,8 +5450,8 @@ var spine = (() => {
           this.d = pc * lb + pd * ld;
           break;
         }
-        case TransformMode.NoScale:
-        case TransformMode.NoScaleOrReflection: {
+        case 3 /* NoScale */:
+        case 4 /* NoScaleOrReflection */: {
           let cos = MathUtils.cosDeg(rotation);
           let sin = MathUtils.sinDeg(rotation);
           let za = (pa * cos + pb * sin) / this.skeleton.scaleX;
@@ -4239,7 +5462,7 @@ var spine = (() => {
           za *= s;
           zc *= s;
           s = Math.sqrt(za * za + zc * zc);
-          if (this.data.transformMode == TransformMode.NoScale && pa * pd - pb * pc < 0 != (this.skeleton.scaleX < 0 != this.skeleton.scaleY < 0))
+          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;
@@ -4260,6 +5483,7 @@ var spine = (() => {
       this.c *= this.skeleton.scaleY;
       this.d *= this.skeleton.scaleY;
     }
+    /** Sets this bone's local transform to the setup pose. */
     setToSetupPose() {
       let data = this.data;
       this.x = data.x;
@@ -4270,18 +5494,30 @@ 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
+     * the applied transform matches the world transform. The applied transform may be needed by other code (eg to apply other
+     * constraints).
+     *
+     * Some information is ambiguous in the world transform, such as -1,-1 scale versus 180 rotation. The applied transform after
+     * calling this method is equivalent to the local transform used to compute the world transform, but may not be identical. */
     updateAppliedTransform() {
       let parent = this.parent;
       if (!parent) {
@@ -4301,14 +5537,14 @@ var spine = (() => {
       this.ax = dx * ia - dy * ib;
       this.ay = dy * id - dx * ic;
       let ra, rb, rc, rd;
-      if (this.data.transformMode == TransformMode.OnlyTranslation) {
+      if (this.data.transformMode == 1 /* OnlyTranslation */) {
         ra = this.a;
         rb = this.b;
         rc = this.c;
         rd = this.d;
       } else {
         switch (this.data.transformMode) {
-          case TransformMode.NoRotationOrReflection: {
+          case 2 /* NoRotationOrReflection */: {
             let s2 = Math.abs(pa * pd - pb * pc) / (pa * pa + pc * pc);
             let sa = pa / this.skeleton.scaleX;
             let sc = pc / this.skeleton.scaleY;
@@ -4319,8 +5555,8 @@ var spine = (() => {
             ib = pb * pid;
             break;
           }
-          case TransformMode.NoScale:
-          case TransformMode.NoScaleOrReflection:
+          case 3 /* NoScale */:
+          case 4 /* NoScaleOrReflection */:
             let cos = MathUtils.cosDeg(this.rotation), sin = MathUtils.sinDeg(this.rotation);
             pa = (pa * cos + pb * sin) / this.skeleton.scaleX;
             pc = (pc * cos + pd * sin) / this.skeleton.scaleY;
@@ -4330,7 +5566,7 @@ var spine = (() => {
             pa *= s;
             pc *= s;
             s = Math.sqrt(pa * pa + pc * pc);
-            if (this.data.transformMode == TransformMode.NoScale && pid < 0 != (this.skeleton.scaleX < 0 != this.skeleton.scaleY < 0))
+            if (this.data.transformMode == 3 /* NoScale */ && pid < 0 != (this.skeleton.scaleX < 0 != this.skeleton.scaleY < 0))
               s = -s;
             let r = MathUtils.PI / 2 + Math.atan2(pc, pa);
             pb = Math.cos(r) * s;
@@ -4360,6 +5596,7 @@ var spine = (() => {
         this.arotation = 90 - Math.atan2(rd, rb) * MathUtils.radDeg;
       }
     }
+    /** 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);
       let x = world.x - this.worldX, y = world.y - this.worldY;
@@ -4367,21 +5604,28 @@ var spine = (() => {
       world.y = y * this.a * invDet - x * this.c * invDet;
       return world;
     }
+    /** Transforms a point from the bone's local coordinates to world coordinates. */
     localToWorld(local) {
       let x = local.x, y = local.y;
       local.x = x * this.a + y * this.b + this.worldX;
       local.y = x * this.c + y * this.d + this.worldY;
       return local;
     }
+    /** Transforms a world rotation to a local rotation. */
     worldToLocalRotation(worldRotation) {
       let sin = MathUtils.sinDeg(worldRotation), cos = MathUtils.cosDeg(worldRotation);
       return Math.atan2(this.a * sin - this.c * cos, this.d * cos - this.b * sin) * MathUtils.radDeg + this.rotation - this.shearX;
     }
+    /** Transforms a local rotation to a world rotation. */
     localToWorldRotation(localRotation) {
       localRotation -= this.rotation - this.shearX;
       let sin = MathUtils.sinDeg(localRotation), cos = MathUtils.cosDeg(localRotation);
       return Math.atan2(cos * this.c + sin * this.d, cos * this.a + sin * this.b) * MathUtils.radDeg;
     }
+    /** 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. */
     rotateWorld(degrees) {
       let a = this.a, b = this.b, c = this.c, d = this.d;
       let cos = MathUtils.cosDeg(degrees), sin = MathUtils.sinDeg(degrees);
@@ -4523,17 +5767,21 @@ var spine = (() => {
           let atlas = new TextureAtlas(atlasText);
           let toLoad = atlas.pages.length, abort = false;
           for (let page of atlas.pages) {
-            this.loadTexture(!fileAlias ? parent + page.name : fileAlias[page.name], (imagePath, texture) => {
-              if (!abort) {
-                page.setTexture(texture);
-                if (--toLoad == 0)
-                  this.success(success, path, atlas);
+            this.loadTexture(
+              !fileAlias ? parent + page.name : fileAlias[page.name],
+              (imagePath, texture) => {
+                if (!abort) {
+                  page.setTexture(texture);
+                  if (--toLoad == 0)
+                    this.success(success, path, atlas);
+                }
+              },
+              (imagePath, message) => {
+                if (!abort)
+                  this.error(error, path, `Couldn't load texture atlas ${path} page image: ${imagePath}`);
+                abort = true;
               }
-            }, (imagePath, message) => {
-              if (!abort)
-                this.error(error, path, `Couldn't load texture atlas ${path} page image: ${imagePath}`);
-              abort = true;
-            });
+            );
           }
         } catch (e) {
           this.error(error, path, `Couldn't parse texture atlas ${path}: ${e.message}`);
@@ -4729,10 +5977,16 @@ var spine = (() => {
   // spine-core/src/IkConstraint.ts
   var IkConstraint = class {
     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)
@@ -4774,6 +6028,7 @@ var spine = (() => {
           break;
       }
     }
+    /** Applies 1 bone IK. The target is specified in the world coordinate system. */
     apply1(bone, targetX, targetY, compress, stretch, uniform, alpha) {
       let p = bone.parent;
       if (!p)
@@ -4781,12 +6036,12 @@ var spine = (() => {
       let pa = p.a, pb = p.b, pc = p.c, pd = p.d;
       let rotationIK = -bone.ashearX - bone.arotation, tx = 0, ty = 0;
       switch (bone.data.transformMode) {
-        case TransformMode.OnlyTranslation:
+        case 1 /* OnlyTranslation */:
           tx = targetX - bone.worldX;
           ty = targetY - bone.worldY;
           break;
-        case TransformMode.NoRotationOrReflection:
-          let s = Math.abs(pa * pd - pb * pc) / (pa * pa + pc * pc);
+        case 2 /* NoRotationOrReflection */:
+          let s = Math.abs(pa * pd - pb * pc) / Math.max(1e-4, pa * pa + pc * pc);
           let sa = pa / bone.skeleton.scaleX;
           let sc = pc / bone.skeleton.scaleY;
           pb = -sc * s * bone.skeleton.scaleX;
@@ -4795,8 +6050,13 @@ var spine = (() => {
         default:
           let x = targetX - p.worldX, y = targetY - p.worldY;
           let d = pa * pd - pb * pc;
-          tx = (x * pd - y * pb) / d - bone.ax;
-          ty = (y * pa - x * pc) / d - bone.ay;
+          if (Math.abs(d) <= 1e-4) {
+            tx = 0;
+            ty = 0;
+          } else {
+            tx = (x * pd - y * pb) / d - bone.ax;
+            ty = (y * pa - x * pc) / d - bone.ay;
+          }
       }
       rotationIK += Math.atan2(ty, tx) * MathUtils.radDeg;
       if (bone.ascaleX < 0)
@@ -4808,8 +6068,8 @@ var spine = (() => {
       let sx = bone.ascaleX, sy = bone.ascaleY;
       if (compress || stretch) {
         switch (bone.data.transformMode) {
-          case TransformMode.NoScale:
-          case TransformMode.NoScaleOrReflection:
+          case 3 /* NoScale */:
+          case 4 /* NoScaleOrReflection */:
             tx = targetX - bone.worldX;
             ty = targetY - bone.worldY;
         }
@@ -4821,8 +6081,18 @@ var spine = (() => {
             sy *= s;
         }
       }
-      bone.updateWorldTransformWith(bone.ax, bone.ay, bone.arotation + rotationIK * alpha, sx, sy, bone.ashearX, bone.ashearY);
+      bone.updateWorldTransformWith(
+        bone.ax,
+        bone.ay,
+        bone.arotation + rotationIK * alpha,
+        sx,
+        sy,
+        bone.ashearX,
+        bone.ashearY
+      );
     }
+    /** Applies 2 bone IK. The target is specified in the world coordinate system.
+     * @param child A direct descendant of the parent bone. */
     apply2(parent, child, targetX, targetY, bendDir, stretch, uniform, softness, alpha) {
       let px = parent.ax, py = parent.ay, psx = parent.ascaleX, psy = parent.ascaleY, sx = psx, sy = psy, csx = child.ascaleX;
       let os1 = 0, os2 = 0, s2 = 0;
@@ -4861,7 +6131,8 @@ var spine = (() => {
       b = pp.b;
       c = pp.c;
       d = pp.d;
-      let id = 1 / (a * d - b * c), x = cwx - pp.worldX, y = cwy - pp.worldY;
+      let id = a * d - b * c, x = cwx - pp.worldX, y = cwy - pp.worldY;
+      id = Math.abs(id) <= 1e-4 ? 0 : 1 / id;
       let dx = (x * d - y * b) * id - px, dy = (y * a - x * c) * id - py;
       let l1 = Math.sqrt(dx * dx + dy * dy), l2 = child.data.length * csx, a1, a2;
       if (l1 < 1e-4) {
@@ -4977,13 +6248,23 @@ var spine = (() => {
   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;
     }
     set target(boneData) {
@@ -5001,13 +6282,21 @@ var spine = (() => {
   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;
@@ -5023,29 +6312,31 @@ var spine = (() => {
         return this._target;
     }
   };
-  var PositionMode;
-  (function(PositionMode2) {
+  var PositionMode = /* @__PURE__ */ ((PositionMode2) => {
     PositionMode2[PositionMode2["Fixed"] = 0] = "Fixed";
     PositionMode2[PositionMode2["Percent"] = 1] = "Percent";
-  })(PositionMode || (PositionMode = {}));
-  var SpacingMode;
-  (function(SpacingMode2) {
+    return PositionMode2;
+  })(PositionMode || {});
+  var SpacingMode = /* @__PURE__ */ ((SpacingMode2) => {
     SpacingMode2[SpacingMode2["Length"] = 0] = "Length";
     SpacingMode2[SpacingMode2["Fixed"] = 1] = "Fixed";
     SpacingMode2[SpacingMode2["Percent"] = 2] = "Percent";
     SpacingMode2[SpacingMode2["Proportional"] = 3] = "Proportional";
-  })(SpacingMode || (SpacingMode = {}));
-  var RotateMode;
-  (function(RotateMode2) {
+    return SpacingMode2;
+  })(SpacingMode || {});
+  var RotateMode = /* @__PURE__ */ ((RotateMode2) => {
     RotateMode2[RotateMode2["Tangent"] = 0] = "Tangent";
     RotateMode2[RotateMode2["Chain"] = 1] = "Chain";
     RotateMode2[RotateMode2["ChainScale"] = 2] = "ChainScale";
-  })(RotateMode || (RotateMode = {}));
+    return RotateMode2;
+  })(RotateMode || {});
 
   // spine-core/src/PathConstraint.ts
   var _PathConstraint = class {
     constructor(data, skeleton) {
+      /** The position along the path. */
       this.position = 0;
+      /** The spacing between bones. */
       this.spacing = 0;
       this.mixRotate = 0;
       this.mixX = 0;
@@ -5090,13 +6381,13 @@ var spine = (() => {
       if (mixRotate == 0 && mixX == 0 && mixY == 0)
         return;
       let data = this.data;
-      let tangents = data.rotateMode == RotateMode.Tangent, scale = data.rotateMode == RotateMode.ChainScale;
+      let tangents = data.rotateMode == 0 /* Tangent */, scale = data.rotateMode == 2 /* ChainScale */;
       let bones = this.bones;
       let boneCount = bones.length, spacesCount = tangents ? boneCount : boneCount + 1;
       let spaces = Utils.setArraySize(this.spaces, spacesCount), lengths = scale ? this.lengths = Utils.setArraySize(this.lengths, boneCount) : [];
       let spacing = this.spacing;
       switch (data.spacingMode) {
-        case SpacingMode.Percent:
+        case 2 /* Percent */:
           if (scale) {
             for (let i = 0, n = spacesCount - 1; i < n; i++) {
               let bone = bones[i];
@@ -5111,7 +6402,7 @@ var spine = (() => {
           }
           Utils.arrayFill(spaces, 1, spacesCount, spacing);
           break;
-        case SpacingMode.Proportional:
+        case 3 /* Proportional */:
           let sum = 0;
           for (let i = 0, n = spacesCount - 1; i < n; ) {
             let bone = bones[i];
@@ -5136,7 +6427,7 @@ var spine = (() => {
           }
           break;
         default:
-          let lengthSpacing = data.spacingMode == SpacingMode.Length;
+          let lengthSpacing = data.spacingMode == 0 /* Length */;
           for (let i = 0, n = spacesCount - 1; i < n; ) {
             let bone = bones[i];
             let setupLength = bone.data.length;
@@ -5157,7 +6448,7 @@ var spine = (() => {
       let boneX = positions[0], boneY = positions[1], offsetRotation = data.offsetRotation;
       let tip = false;
       if (offsetRotation == 0)
-        tip = data.rotateMode == RotateMode.Chain;
+        tip = data.rotateMode == 1 /* Chain */;
       else {
         tip = false;
         let p = this.target.bone;
@@ -5221,14 +6512,14 @@ var spine = (() => {
         let lengths = path.lengths;
         curveCount -= closed2 ? 1 : 2;
         let pathLength2 = lengths[curveCount];
-        if (this.data.positionMode == PositionMode.Percent)
+        if (this.data.positionMode == 1 /* Percent */)
           position *= pathLength2;
         let multiplier2;
         switch (this.data.spacingMode) {
-          case SpacingMode.Percent:
+          case 2 /* Percent */:
             multiplier2 = pathLength2;
             break;
-          case SpacingMode.Proportional:
+          case 3 /* Proportional */:
             multiplier2 = pathLength2 / spacesCount;
             break;
           default:
@@ -5279,7 +6570,20 @@ var spine = (() => {
             } else
               path.computeWorldVertices(target, curve * 6 + 2, 8, world, 0, 2);
           }
-          this.addCurvePosition(p, world[0], world[1], world[2], world[3], world[4], world[5], world[6], world[7], out, o, tangents || i > 0 && space == 0);
+          this.addCurvePosition(
+            p,
+            world[0],
+            world[1],
+            world[2],
+            world[3],
+            world[4],
+            world[5],
+            world[6],
+            world[7],
+            out,
+            o,
+            tangents || i > 0 && space == 0
+          );
         }
         return out;
       }
@@ -5331,14 +6635,14 @@ var spine = (() => {
         x1 = x2;
         y1 = y2;
       }
-      if (this.data.positionMode == PositionMode.Percent)
+      if (this.data.positionMode == 1 /* Percent */)
         position *= pathLength;
       let multiplier;
       switch (this.data.spacingMode) {
-        case SpacingMode.Percent:
+        case 2 /* Percent */:
           multiplier = pathLength;
           break;
-        case SpacingMode.Proportional:
+        case 3 /* Proportional */:
           multiplier = pathLength / spacesCount;
           break;
         default:
@@ -5471,10 +6775,18 @@ var spine = (() => {
   // spine-core/src/Slot.ts
   var Slot = class {
     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.");
@@ -5486,12 +6798,17 @@ var spine = (() => {
       this.darkColor = !data.darkColor ? null : new Color();
       this.setToSetupPose();
     }
+    /** The skeleton this slot belongs to. */
     getSkeleton() {
       return this.bone.skeleton;
     }
+    /** The current attachment for the slot, or null if the slot has no attachment. */
     getAttachment() {
       return this.attachment;
     }
+    /** Sets the slot's attachment and, if the attachment changed, resets {@link #sequenceIndex} and clears the {@link #deform}.
+     * The deform is not cleared if the old attachment has the same {@link VertexAttachment#getTimelineAttachment()} as the
+     * specified attachment. */
     setAttachment(attachment) {
       if (this.attachment == attachment)
         return;
@@ -5501,6 +6818,7 @@ var spine = (() => {
       this.attachment = attachment;
       this.sequenceIndex = -1;
     }
+    /** Sets this slot to the setup pose. */
     setToSetupPose() {
       this.color.setFromColor(this.data.color);
       if (this.darkColor)
@@ -5552,7 +6870,7 @@ var spine = (() => {
       return this.active;
     }
     update() {
-      if (this.mixRotate == 0 && this.mixX == 0 && this.mixY == 0 && this.mixScaleX == 0 && this.mixScaleX == 0 && this.mixShearY == 0)
+      if (this.mixRotate == 0 && this.mixX == 0 && this.mixY == 0 && this.mixScaleX == 0 && this.mixScaleY == 0 && this.mixShearY == 0)
         return;
       if (this.data.local) {
         if (this.data.relative)
@@ -5729,13 +7047,21 @@ var spine = (() => {
   };
 
   // spine-core/src/Skeleton.ts
-  var Skeleton = class {
+  var _Skeleton = class {
     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;
-      this.scaleY = 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.");
@@ -5780,6 +7106,14 @@ var spine = (() => {
       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() {
       let updateCache = this._updateCache;
       updateCache.length = 0;
@@ -5947,6 +7281,10 @@ var spine = (() => {
         bone.sorted = false;
       }
     }
+    /** Updates the world transform for each bone and applies all constraints.
+     *
+     * See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine
+     * Runtimes Guide. */
     updateWorldTransform() {
       let bones = this.bones;
       for (let i = 0, n = bones.length; i < n; i++) {
@@ -5986,10 +7324,12 @@ var spine = (() => {
           updatable.update();
       }
     }
+    /** Sets the bones, constraints, and slots to their setup pose values. */
     setToSetupPose() {
       this.setBonesToSetupPose();
       this.setSlotsToSetupPose();
     }
+    /** 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++)
@@ -6025,17 +7365,20 @@ var spine = (() => {
         constraint.mixY = data.mixY;
       }
     }
+    /** Sets the slots and draw order to their setup pose values. */
     setSlotsToSetupPose() {
       let slots = this.slots;
       Utils.arrayCopy(slots, 0, this.drawOrder, 0, slots.length);
       for (let i = 0, n = slots.length; i < n; i++)
         slots[i].setToSetupPose();
     }
+    /** @returns May return null. */
     getRootBone() {
       if (this.bones.length == 0)
         return null;
       return this.bones[0];
     }
+    /** @returns May be null. */
     findBone(boneName) {
       if (!boneName)
         throw new Error("boneName cannot be null.");
@@ -6047,6 +7390,9 @@ var spine = (() => {
       }
       return null;
     }
+    /** Finds a slot by comparing each slot's name. It is more efficient to cache the results of this method than to call it
+     * repeatedly.
+     * @returns May be null. */
     findSlot(slotName) {
       if (!slotName)
         throw new Error("slotName cannot be null.");
@@ -6058,12 +7404,25 @@ var spine = (() => {
       }
       return null;
     }
+    /** Sets a skin by name.
+     *
+     * See {@link #setSkin()}. */
     setSkinByName(skinName) {
       let skin = this.data.findSkin(skinName);
       if (!skin)
         throw new Error("Skin not found: " + skinName);
       this.setSkin(skin);
     }
+    /** Sets the skin used to look up attachments before looking in the {@link SkeletonData#defaultSkin default skin}. If the
+     * skin is changed, {@link #updateCache()} is called.
+     *
+     * Attachments from the new skin are attached if the corresponding attachment from the old skin was attached. If there was no
+     * old skin, each slot's setup mode attachment is attached from the new skin.
+     *
+     * After changing the skin, the visible attachments can be reset to those attached in the setup pose by calling
+     * {@link #setSlotsToSetupPose()}. Also, often {@link AnimationState#apply()} is called before the next time the
+     * skeleton is rendered to allow any attachment keys in the current animation(s) to hide or show attachments from the new skin.
+     * @param newSkin May be null. */
     setSkin(newSkin) {
       if (newSkin == this.skin)
         return;
@@ -6086,12 +7445,22 @@ var spine = (() => {
       this.skin = newSkin;
       this.updateCache();
     }
+    /** Finds an attachment by looking in the {@link #skin} and {@link SkeletonData#defaultSkin} using the slot name and attachment
+     * name.
+     *
+     * See {@link #getAttachment()}.
+     * @returns May be null. */
     getAttachmentByName(slotName, attachmentName) {
       let slot = this.data.findSlot(slotName);
       if (!slot)
         throw new Error(`Can't find slot with name ${slotName}`);
       return this.getAttachment(slot.index, attachmentName);
     }
+    /** Finds an attachment by looking in the {@link #skin} and {@link SkeletonData#defaultSkin} using the slot index and
+     * attachment name. First the skin is checked and if the attachment was not found, the default skin is checked.
+     *
+     * See [Runtime skins](http://esotericsoftware.com/spine-runtime-skins) in the Spine Runtimes Guide.
+     * @returns May be null. */
     getAttachment(slotIndex, attachmentName) {
       if (!attachmentName)
         throw new Error("attachmentName cannot be null.");
@@ -6104,6 +7473,9 @@ var spine = (() => {
         return this.data.defaultSkin.getAttachment(slotIndex, attachmentName);
       return null;
     }
+    /** A convenience method to set an attachment by finding the slot with {@link #findSlot()}, finding the attachment with
+     * {@link #getAttachment()}, then setting the slot's {@link Slot#attachment}.
+     * @param attachmentName May be null to clear the slot's attachment. */
     setAttachment(slotName, attachmentName) {
       if (!slotName)
         throw new Error("slotName cannot be null.");
@@ -6123,6 +7495,9 @@ var spine = (() => {
       }
       throw new Error("Slot not found: " + slotName);
     }
+    /** Finds an IK constraint by comparing each IK constraint's name. It is more efficient to cache the results of this method
+     * than to call it repeatedly.
+     * @return May be null. */
     findIkConstraint(constraintName) {
       if (!constraintName)
         throw new Error("constraintName cannot be null.");
@@ -6134,6 +7509,9 @@ var spine = (() => {
       }
       return 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.
+     * @return May be null. */
     findTransformConstraint(constraintName) {
       if (!constraintName)
         throw new Error("constraintName cannot be null.");
@@ -6145,6 +7523,9 @@ var spine = (() => {
       }
       return 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.
+     * @return May be null. */
     findPathConstraint(constraintName) {
       if (!constraintName)
         throw new Error("constraintName cannot be null.");
@@ -6156,12 +7537,18 @@ var spine = (() => {
       }
       return 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. */
     getBoundsRect() {
       let offset = new Vector2();
       let size = new Vector2();
       this.getBounds(offset, size);
       return { x: offset.x, y: offset.y, width: size.x, height: size.y };
     }
+    /** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the current pose.
+     * @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB.
+     * @param size An output value, the width and height of the AABB.
+     * @param temp Working memory to temporarily store attachments' computed world vertices. */
     getBounds(offset, size, temp = new Array(2)) {
       if (!offset)
         throw new Error("offset cannot be null.");
@@ -6200,30 +7587,59 @@ var spine = (() => {
       size.set(maxX - minX, maxY - minY);
     }
   };
+  var Skeleton = _Skeleton;
+  Skeleton.yDown = false;
 
   // 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;
     }
+    /** 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. */
     findBone(boneName) {
       if (!boneName)
         throw new Error("boneName cannot be null.");
@@ -6235,6 +7651,9 @@ var spine = (() => {
       }
       return null;
     }
+    /** Finds a slot by comparing each slot's name. It is more efficient to cache the results of this method than to call it
+     * multiple times.
+     * @returns May be null. */
     findSlot(slotName) {
       if (!slotName)
         throw new Error("slotName cannot be null.");
@@ -6246,6 +7665,9 @@ var spine = (() => {
       }
       return null;
     }
+    /** Finds a skin by comparing each skin's name. It is more efficient to cache the results of this method than to call it
+     * multiple times.
+     * @returns May be null. */
     findSkin(skinName) {
       if (!skinName)
         throw new Error("skinName cannot be null.");
@@ -6257,6 +7679,9 @@ var spine = (() => {
       }
       return null;
     }
+    /** Finds an event by comparing each events's name. It is more efficient to cache the results of this method than to call it
+     * multiple times.
+     * @returns May be null. */
     findEvent(eventDataName) {
       if (!eventDataName)
         throw new Error("eventDataName cannot be null.");
@@ -6268,6 +7693,9 @@ var spine = (() => {
       }
       return null;
     }
+    /** Finds an animation by comparing each animation's name. It is more efficient to cache the results of this method than to
+     * call it multiple times.
+     * @returns May be null. */
     findAnimation(animationName) {
       if (!animationName)
         throw new Error("animationName cannot be null.");
@@ -6279,6 +7707,9 @@ var spine = (() => {
       }
       return null;
     }
+    /** Finds an IK constraint by comparing each IK constraint's name. It is more efficient to cache the results of this method
+     * than to call it multiple times.
+     * @return May be null. */
     findIkConstraint(constraintName) {
       if (!constraintName)
         throw new Error("constraintName cannot be null.");
@@ -6290,6 +7721,9 @@ var spine = (() => {
       }
       return 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 multiple times.
+     * @return May be null. */
     findTransformConstraint(constraintName) {
       if (!constraintName)
         throw new Error("constraintName cannot be null.");
@@ -6301,6 +7735,9 @@ var spine = (() => {
       }
       return 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 multiple times.
+     * @return May be null. */
     findPathConstraint(constraintName) {
       if (!constraintName)
         throw new Error("constraintName cannot be null.");
@@ -6331,6 +7768,7 @@ var spine = (() => {
         throw new Error("name cannot be null.");
       this.name = name;
     }
+    /** Adds an attachment to the skin for the specified slot index and name. */
     setAttachment(slotIndex, name, attachment) {
       if (!attachment)
         throw new Error("attachment cannot be null.");
@@ -6341,6 +7779,7 @@ var spine = (() => {
         attachments[slotIndex] = {};
       attachments[slotIndex][name] = attachment;
     }
+    /** Adds all attachments, bones, and constraints from the specified skin to this skin. */
     addSkin(skin) {
       for (let i = 0; i < skin.bones.length; i++) {
         let bone = skin.bones[i];
@@ -6372,6 +7811,8 @@ var spine = (() => {
         this.setAttachment(attachment.slotIndex, attachment.name, attachment.attachment);
       }
     }
+    /** Adds all bones and constraints and copies of all attachments from the specified skin to this skin. Mesh attachments are not
+     * copied, instead a new linked mesh is created. The attachment copies can be modified without affecting the originals. */
     copySkin(skin) {
       for (let i = 0; i < skin.bones.length; i++) {
         let bone = skin.bones[i];
@@ -6411,15 +7852,18 @@ var spine = (() => {
         }
       }
     }
+    /** Returns the attachment for the specified slot index and name, or null. */
     getAttachment(slotIndex, name) {
       let dictionary = this.attachments[slotIndex];
       return dictionary ? dictionary[name] : null;
     }
+    /** Removes the attachment in the skin for the specified slot index and name, if any. */
     removeAttachment(slotIndex, name) {
       let dictionary = this.attachments[slotIndex];
       if (dictionary)
         delete dictionary[name];
     }
+    /** Returns all attachments in this skin. */
     getAttachments() {
       let entries = new Array();
       for (var i = 0; i < this.attachments.length; i++) {
@@ -6434,6 +7878,7 @@ var spine = (() => {
       }
       return entries;
     }
+    /** Returns all attachments in this skin for the specified slot index. */
     getAttachmentsForSlot(slotIndex, attachments) {
       let slotAttachments = this.attachments[slotIndex];
       if (slotAttachments) {
@@ -6444,11 +7889,13 @@ var spine = (() => {
         }
       }
     }
+    /** Clears all attachments, bones, and constraints. */
     clear() {
       this.attachments.length = 0;
       this.bones.length = 0;
       this.constraints.length = 0;
     }
+    /** Attach each attachment in this skin if the corresponding attachment in the old skin is currently attached. */
     attachAll(skeleton, oldSkin) {
       let slotIndex = 0;
       for (let i = 0; i < skeleton.slots.length; i++) {
@@ -6474,10 +7921,17 @@ var spine = (() => {
   // spine-core/src/SlotData.ts
   var SlotData = class {
     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.");
@@ -6490,19 +7944,21 @@ var spine = (() => {
       this.boneData = boneData;
     }
   };
-  var BlendMode;
-  (function(BlendMode3) {
+  var BlendMode = /* @__PURE__ */ ((BlendMode3) => {
     BlendMode3[BlendMode3["Normal"] = 0] = "Normal";
     BlendMode3[BlendMode3["Additive"] = 1] = "Additive";
     BlendMode3[BlendMode3["Multiply"] = 2] = "Multiply";
     BlendMode3[BlendMode3["Screen"] = 3] = "Screen";
-  })(BlendMode || (BlendMode = {}));
+    return BlendMode3;
+  })(BlendMode || {});
 
   // 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;
@@ -6510,11 +7966,17 @@ var spine = (() => {
       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;
@@ -6533,6 +7995,10 @@ var spine = (() => {
   // spine-core/src/SkeletonBinary.ts
   var SkeletonBinary = class {
     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;
@@ -6665,10 +8131,10 @@ var spine = (() => {
         data.rotateMode = input.readInt(true);
         data.offsetRotation = input.readFloat();
         data.position = input.readFloat();
-        if (data.positionMode == PositionMode.Fixed)
+        if (data.positionMode == 0 /* Fixed */)
           data.position *= scale;
         data.spacing = input.readFloat();
-        if (data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed)
+        if (data.spacingMode == 0 /* Length */ || data.spacingMode == 1 /* Fixed */)
           data.spacing *= scale;
         data.mixRotate = input.readFloat();
         data.mixX = input.readFloat();
@@ -7293,10 +8759,18 @@ var spine = (() => {
         for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) {
           switch (input.readByte()) {
             case PATH_POSITION:
-              timelines.push(readTimeline1(input, new PathConstraintPositionTimeline(input.readInt(true), input.readInt(true), index), data.positionMode == PositionMode.Fixed ? scale : 1));
+              timelines.push(readTimeline1(
+                input,
+                new PathConstraintPositionTimeline(input.readInt(true), input.readInt(true), index),
+                data.positionMode == 0 /* Fixed */ ? scale : 1
+              ));
               break;
             case PATH_SPACING:
-              timelines.push(readTimeline1(input, new PathConstraintSpacingTimeline(input.readInt(true), input.readInt(true), index), data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed ? scale : 1));
+              timelines.push(readTimeline1(
+                input,
+                new PathConstraintSpacingTimeline(input.readInt(true), input.readInt(true), index),
+                data.spacingMode == 0 /* Length */ || data.spacingMode == 1 /* Fixed */ ? scale : 1
+              ));
               break;
             case PATH_MIX:
               let timeline = new PathConstraintMixTimeline(input.readInt(true), input.readInt(true), index);
@@ -7387,7 +8861,13 @@ var spine = (() => {
                 for (let frame = 0; frame < frameCount; frame++) {
                   let time = input.readFloat();
                   let modeAndIndex = input.readInt32();
-                  timeline.setFrame(frame, time, SequenceModeValues[modeAndIndex & 15], modeAndIndex >> 4, input.readFloat());
+                  timeline.setFrame(
+                    frame,
+                    time,
+                    SequenceModeValues[modeAndIndex & 15],
+                    modeAndIndex >> 4,
+                    input.readFloat()
+                  );
                 }
                 timelines.push(timeline);
                 break;
@@ -7548,8 +9028,7 @@ var spine = (() => {
       this.vertices = vertices;
     }
   };
-  var AttachmentType;
-  (function(AttachmentType2) {
+  var AttachmentType = /* @__PURE__ */ ((AttachmentType2) => {
     AttachmentType2[AttachmentType2["Region"] = 0] = "Region";
     AttachmentType2[AttachmentType2["BoundingBox"] = 1] = "BoundingBox";
     AttachmentType2[AttachmentType2["Mesh"] = 2] = "Mesh";
@@ -7557,7 +9036,8 @@ var spine = (() => {
     AttachmentType2[AttachmentType2["Path"] = 4] = "Path";
     AttachmentType2[AttachmentType2["Point"] = 5] = "Point";
     AttachmentType2[AttachmentType2["Clipping"] = 6] = "Clipping";
-  })(AttachmentType || (AttachmentType = {}));
+    return AttachmentType2;
+  })(AttachmentType || {});
   function readTimeline1(input, timeline, scale) {
     let time = input.readFloat(), value = input.readFloat() * scale;
     for (let frame = 0, bezier = 0, frameLast = timeline.getFrameCount() - 1; ; frame++) {
@@ -7628,16 +9108,26 @@ 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);
       });
     }
+    /** 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
+     *           SkeletonBounds AABB methods will always return true. */
     update(skeleton, updateAabb) {
       if (!skeleton)
         throw new Error("skeleton cannot be null.");
@@ -7694,9 +9184,11 @@ var spine = (() => {
       this.maxX = maxX;
       this.maxY = maxY;
     }
+    /** Returns true if the axis aligned bounding box contains the point. */
     aabbContainsPoint(x, y) {
       return x >= this.minX && x <= this.maxX && y >= this.minY && y <= this.maxY;
     }
+    /** Returns true if the axis aligned bounding box intersects the line segment. */
     aabbIntersectsSegment(x1, y1, x2, y2) {
       let minX = this.minX;
       let minY = this.minY;
@@ -7719,9 +9211,12 @@ var spine = (() => {
         return true;
       return false;
     }
+    /** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */
     aabbIntersectsSkeleton(bounds) {
       return this.minX < bounds.maxX && this.maxX > bounds.minX && this.minY < bounds.maxY && this.maxY > bounds.minY;
     }
+    /** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
+     * efficient to only call this method if {@link #aabbContainsPoint(float, float)} returns true. */
     containsPoint(x, y) {
       let polygons = this.polygons;
       for (let i = 0, n = polygons.length; i < n; i++)
@@ -7729,6 +9224,7 @@ var spine = (() => {
           return this.boundingBoxes[i];
       return null;
     }
+    /** Returns true if the polygon contains the point. */
     containsPointPolygon(polygon, x, y) {
       let vertices = polygon;
       let nn = polygon.length;
@@ -7746,6 +9242,9 @@ var spine = (() => {
       }
       return inside;
     }
+    /** Returns the first bounding box attachment that contains any part of the line segment, or null. When doing many checks, it
+     * is usually more efficient to only call this method if {@link #aabbIntersectsSegment()} returns
+     * true. */
     intersectsSegment(x1, y1, x2, y2) {
       let polygons = this.polygons;
       for (let i = 0, n = polygons.length; i < n; i++)
@@ -7753,6 +9252,7 @@ var spine = (() => {
           return this.boundingBoxes[i];
       return null;
     }
+    /** Returns true if the polygon contains any part of the line segment. */
     intersectsSegmentPolygon(polygon, x1, y1, x2, y2) {
       let vertices = polygon;
       let nn = polygon.length;
@@ -7775,15 +9275,18 @@ var spine = (() => {
       }
       return false;
     }
+    /** Returns the polygon for the specified bounding box, or null. */
     getPolygon(boundingBox) {
       if (!boundingBox)
         throw new Error("boundingBox cannot be null.");
       let index = this.boundingBoxes.indexOf(boundingBox);
       return index == -1 ? null : this.polygons[index];
     }
+    /** The width of the axis aligned bounding box. */
     getWidth() {
       return this.maxX - this.minX;
     }
+    /** The height of the axis aligned bounding box. */
     getHeight() {
       return this.maxY - this.minY;
     }
@@ -7987,7 +9490,14 @@ var spine = (() => {
       let previous = indices[(vertexCount + index - 1) % vertexCount] << 1;
       let current = indices[index] << 1;
       let next = indices[(index + 1) % vertexCount] << 1;
-      return !this.positiveArea(vertices[previous], vertices[previous + 1], vertices[current], vertices[current + 1], vertices[next], vertices[next + 1]);
+      return !this.positiveArea(
+        vertices[previous],
+        vertices[previous + 1],
+        vertices[current],
+        vertices[current + 1],
+        vertices[next],
+        vertices[next + 1]
+      );
     }
     static positiveArea(p1x, p1y, p2x, p2y, p3x, p3y) {
       return p1x * (p3y - p2y) + p2x * (p1y - p3y) + p3x * (p2y - p1y) >= 0;
@@ -8177,6 +9687,8 @@ var spine = (() => {
           }
         }
     }
+    /** Clips the input triangle against the convex, clockwise clipping area. If the triangle lies entirely within the clipping
+     * area, false is returned. The clipping area must duplicate the first vertex at the end of the vertices list. */
     clip(x1, y1, x2, y2, x3, y3, clippingArea, output) {
       let originalOutput = output;
       let clipped = false;
@@ -8288,6 +9800,10 @@ var spine = (() => {
   // spine-core/src/SkeletonJson.ts
   var SkeletonJson = class {
     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;
@@ -8433,10 +9949,10 @@ var spine = (() => {
           data.rotateMode = Utils.enumValue(RotateMode, getValue(constraintMap, "rotateMode", "Tangent"));
           data.offsetRotation = getValue(constraintMap, "rotation", 0);
           data.position = getValue(constraintMap, "position", 0);
-          if (data.positionMode == PositionMode.Fixed)
+          if (data.positionMode == 0 /* Fixed */)
             data.position *= scale;
           data.spacing = getValue(constraintMap, "spacing", 0);
-          if (data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed)
+          if (data.spacingMode == 0 /* Length */ || data.spacingMode == 1 /* Fixed */)
             data.spacing *= scale;
           data.mixRotate = getValue(constraintMap, "mixRotate", 1);
           data.mixX = getValue(constraintMap, "mixX", 1);
@@ -8977,10 +10493,10 @@ var spine = (() => {
             let frames = timelineMap.length;
             if (timelineName === "position") {
               let timeline = new PathConstraintPositionTimeline(frames, frames, constraintIndex);
-              timelines.push(readTimeline12(timelineMap, timeline, 0, constraint.positionMode == PositionMode.Fixed ? scale : 1));
+              timelines.push(readTimeline12(timelineMap, timeline, 0, constraint.positionMode == 0 /* Fixed */ ? scale : 1));
             } else if (timelineName === "spacing") {
               let timeline = new PathConstraintSpacingTimeline(frames, frames, constraintIndex);
-              timelines.push(readTimeline12(timelineMap, timeline, 0, constraint.spacingMode == SpacingMode.Length || constraint.spacingMode == SpacingMode.Fixed ? scale : 1));
+              timelines.push(readTimeline12(timelineMap, timeline, 0, constraint.spacingMode == 0 /* Length */ || constraint.spacingMode == 1 /* Fixed */ ? scale : 1));
             } else if (timelineName === "mix") {
               let timeline = new PathConstraintMixTimeline(frames, frames * 3, constraintIndex);
               let time = getValue(keyMap, "time", 0);
@@ -9290,10 +10806,15 @@ var spine = (() => {
           continue;
         attachment.computeWorldVertices(slot, worldVertices, 0, 2);
         let region = attachment.region;
-        let image = region.page.texture.getImage();
+        let image = region.texture.getImage();
         let slotColor = slot.color;
         let regionColor = attachment.color;
-        color.set(skeletonColor.r * slotColor.r * regionColor.r, skeletonColor.g * slotColor.g * regionColor.g, skeletonColor.b * slotColor.b * regionColor.b, skeletonColor.a * slotColor.a * regionColor.a);
+        color.set(
+          skeletonColor.r * slotColor.r * regionColor.r,
+          skeletonColor.g * slotColor.g * regionColor.g,
+          skeletonColor.b * slotColor.b * regionColor.b,
+          skeletonColor.a * slotColor.a * regionColor.a
+        );
         ctx.save();
         ctx.transform(bone.a, bone.c, bone.b, bone.d, bone.worldX, bone.worldY);
         ctx.translate(attachment.offset[0], attachment.offset[1]);
@@ -9311,7 +10832,7 @@ var spine = (() => {
         ctx.scale(1, -1);
         ctx.translate(-w / 2, -h / 2);
         ctx.globalAlpha = color.a;
-        ctx.drawImage(image, region.x, region.y, w, h, 0, 0, w, h);
+        ctx.drawImage(image, image.width * region.u, image.height * region.v, w, h, 0, 0, w, h);
         if (this.debugRendering)
           ctx.strokeRect(0, 0, w, h);
         ctx.restore();
@@ -9334,14 +10855,12 @@ var spine = (() => {
           let regionAttachment = attachment;
           vertices = this.computeRegionVertices(slot, regionAttachment, false);
           triangles = _SkeletonRenderer.QUAD_TRIANGLES;
-          region = regionAttachment.region;
-          texture = region.page.texture.getImage();
+          texture = regionAttachment.region.texture.getImage();
         } else if (attachment instanceof MeshAttachment) {
           let mesh = attachment;
           vertices = this.computeMeshVertices(slot, mesh, false);
           triangles = mesh.triangles;
-          let region2 = mesh.region.renderObject;
-          texture = region2.page.texture.getImage();
+          texture = mesh.region.texture.getImage();
         } else
           continue;
         if (texture) {
@@ -9349,7 +10868,12 @@ var spine = (() => {
             blendMode = slot.data.blendMode;
           let slotColor = slot.color;
           let attachmentColor = attachment.color;
-          color.set(skeletonColor.r * slotColor.r * attachmentColor.r, skeletonColor.g * slotColor.g * attachmentColor.g, skeletonColor.b * slotColor.b * attachmentColor.b, skeletonColor.a * slotColor.a * attachmentColor.a);
+          color.set(
+            skeletonColor.r * slotColor.r * attachmentColor.r,
+            skeletonColor.g * slotColor.g * attachmentColor.g,
+            skeletonColor.b * slotColor.b * attachmentColor.b,
+            skeletonColor.a * slotColor.a * attachmentColor.a
+          );
           ctx.globalAlpha = color.a;
           for (var j = 0; j < triangles.length; j += 3) {
             let t1 = triangles[j] * 8, t2 = triangles[j + 1] * 8, t3 = triangles[j + 2] * 8;
@@ -9371,6 +10895,8 @@ var spine = (() => {
       }
       this.ctx.globalAlpha = 1;
     }
+    // Adapted from http://extremelysatisfactorytotalitarianism.com/blog/?p=2120
+    // Apache 2 licensed
     drawTriangle(img, x0, y0, u0, v0, x1, y1, u1, v1, x2, y2, u2, v2) {
       let ctx = this.ctx;
       u0 *= img.width;
@@ -9406,7 +10932,12 @@ var spine = (() => {
       let alpha = skeletonColor.a * slotColor.a * regionColor.a;
       let multiplier = pma ? alpha : 1;
       let color = this.tempColor;
-      color.set(skeletonColor.r * slotColor.r * regionColor.r * multiplier, skeletonColor.g * slotColor.g * regionColor.g * multiplier, skeletonColor.b * slotColor.b * regionColor.b * multiplier, alpha);
+      color.set(
+        skeletonColor.r * slotColor.r * regionColor.r * multiplier,
+        skeletonColor.g * slotColor.g * regionColor.g * multiplier,
+        skeletonColor.b * slotColor.b * regionColor.b * multiplier,
+        alpha
+      );
       region.computeWorldVertices(slot, this.vertices, 0, _SkeletonRenderer.VERTEX_SIZE);
       let vertices = this.vertices;
       let uvs = region.uvs;
@@ -9443,7 +10974,12 @@ var spine = (() => {
       let alpha = skeletonColor.a * slotColor.a * regionColor.a;
       let multiplier = pma ? alpha : 1;
       let color = this.tempColor;
-      color.set(skeletonColor.r * slotColor.r * regionColor.r * multiplier, skeletonColor.g * slotColor.g * regionColor.g * multiplier, skeletonColor.b * slotColor.b * regionColor.b * multiplier, alpha);
+      color.set(
+        skeletonColor.r * slotColor.r * regionColor.r * multiplier,
+        skeletonColor.g * slotColor.g * regionColor.g * multiplier,
+        skeletonColor.b * slotColor.b * regionColor.b * multiplier,
+        alpha
+      );
       let vertexCount = mesh.worldVerticesLength / 2;
       let vertices = this.vertices;
       if (vertices.length < mesh.worldVerticesLength)
@@ -9465,6 +11001,6 @@ var spine = (() => {
   var SkeletonRenderer = _SkeletonRenderer;
   SkeletonRenderer.QUAD_TRIANGLES = [0, 1, 2, 2, 3, 0];
   SkeletonRenderer.VERTEX_SIZE = 2 + 2 + 4;
-  return src_exports;
+  return __toCommonJS(src_exports);
 })();
 //# sourceMappingURL=spine-canvas.js.map