@esotericsoftware/spine-webgl 4.2.35 → 4.2.36

package/dist/iife/spine-webgl.js

@@ -69,6 +69,8 @@ var spine = (() => {
     IkConstraint: () => IkConstraint,
     IkConstraintData: () => IkConstraintData,
     IkConstraintTimeline: () => IkConstraintTimeline,
+    Inherit: () => Inherit,
+    InheritTimeline: () => InheritTimeline,
     Input: () => Input,
     IntSet: () => IntSet,
     Interpolation: () => Interpolation,
@@ -142,7 +144,7 @@ var spine = (() => {
     ShearTimeline: () => ShearTimeline,
     ShearXTimeline: () => ShearXTimeline,
     ShearYTimeline: () => ShearYTimeline,
-    Skeleton: () => Skeleton2,
+    Skeleton: () => Skeleton,
     SkeletonBinary: () => SkeletonBinary,
     SkeletonBounds: () => SkeletonBounds,
     SkeletonClipping: () => SkeletonClipping,
@@ -172,7 +174,6 @@ var spine = (() => {
     TransformConstraint: () => TransformConstraint,
     TransformConstraintData: () => TransformConstraintData,
     TransformConstraintTimeline: () => TransformConstraintTimeline,
-    TransformMode: () => TransformMode,
     TranslateTimeline: () => TranslateTimeline,
     TranslateXTimeline: () => TranslateXTimeline,
     TranslateYTimeline: () => TranslateYTimeline,
@@ -814,27 +815,28 @@ var spine = (() => {
     scaleY: 4,
     shearX: 5,
     shearY: 6,
-    rgb: 7,
-    alpha: 8,
-    rgb2: 9,
-    attachment: 10,
-    deform: 11,
-    event: 12,
-    drawOrder: 13,
-    ikConstraint: 14,
-    transformConstraint: 15,
-    pathConstraintPosition: 16,
-    pathConstraintSpacing: 17,
-    pathConstraintMix: 18,
-    physicsConstraintInertia: 19,
-    physicsConstraintStrength: 20,
-    physicsConstraintDamping: 21,
-    physicsConstraintMass: 22,
-    physicsConstraintWind: 23,
-    physicsConstraintGravity: 24,
-    physicsConstraintMix: 25,
-    physicsConstraintReset: 26,
-    sequence: 27
+    inherit: 7,
+    rgb: 8,
+    alpha: 9,
+    rgb2: 10,
+    attachment: 11,
+    deform: 12,
+    event: 13,
+    drawOrder: 14,
+    ikConstraint: 15,
+    transformConstraint: 16,
+    pathConstraintPosition: 17,
+    pathConstraintSpacing: 18,
+    pathConstraintMix: 19,
+    physicsConstraintInertia: 20,
+    physicsConstraintStrength: 21,
+    physicsConstraintDamping: 22,
+    physicsConstraintMass: 23,
+    physicsConstraintWind: 24,
+    physicsConstraintGravity: 25,
+    physicsConstraintMix: 26,
+    physicsConstraintReset: 27,
+    sequence: 28
   };
   var Timeline = class {
     propertyIds;
@@ -1431,7 +1433,7 @@ var spine = (() => {
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
       let bone = skeleton.bones[this.boneIndex];
       if (bone.active)
-        bone.scaleY = this.getScaleValue(time, alpha, blend, direction, bone.scaleX, bone.data.scaleY);
+        bone.scaleY = this.getScaleValue(time, alpha, blend, direction, bone.scaleY, bone.data.scaleY);
     }
   };
   var ShearTimeline = class extends CurveTimeline2 {
@@ -1560,7 +1562,48 @@ var spine = (() => {
     apply(skeleton, lastTime, time, events, alpha, blend, direction) {
       let bone = skeleton.bones[this.boneIndex];
       if (bone.active)
-        bone.shearY = this.getRelativeValue(time, alpha, blend, bone.shearX, bone.data.shearY);
+        bone.shearY = this.getRelativeValue(time, alpha, blend, bone.shearY, bone.data.shearY);
+    }
+  };
+  var InheritTimeline = class extends Timeline {
+    boneIndex = 0;
+    constructor(frameCount, boneIndex) {
+      super(frameCount, [Property.inherit + "|" + boneIndex]);
+      this.boneIndex = boneIndex;
+    }
+    getFrameEntries() {
+      return 2;
+    }
+    /** Sets the transform mode for the specified frame.
+     * @param frame Between 0 and <code>frameCount</code>, inclusive.
+     * @param time The frame time in seconds. */
+    setFrame(frame, time, inherit) {
+      frame *= 2;
+      this.frames[frame] = time;
+      this.frames[
+        frame + 1
+        /*INHERIT*/
+      ] = inherit;
+    }
+    apply(skeleton, lastTime, time, events, alpha, blend, direction) {
+      let bone = skeleton.bones[this.boneIndex];
+      if (!bone.active)
+        return;
+      let frames = this.frames;
+      if (time < frames[0]) {
+        if (blend == 0 /* setup */ || blend == 1 /* first */)
+          bone.inherit = bone.data.inherit;
+        return;
+      }
+      bone.inherit = this.frames[
+        Timeline.search(
+          frames,
+          time,
+          2
+          /*ENTRIES*/
+        ) + 1
+        /*INHERIT*/
+      ];
     }
   };
   var RGBATimeline = class extends CurveTimeline {
@@ -2736,7 +2779,7 @@ var spine = (() => {
   var DrawOrderTimeline = _DrawOrderTimeline;
   __publicField(DrawOrderTimeline, "propertyIds", ["" + Property.drawOrder]);
   var IkConstraintTimeline = class extends CurveTimeline {
-    /** The index of the IK constraint in {@link Skeleton#getIkConstraints()} that will be changed when this timeline is */
+    /** The index of the IK constraint in {@link Skeleton#getIkConstraints()} that will be changed when this timeline is applied */
     constraintIndex = 0;
     constructor(frameCount, bezierCount, ikConstraintIndex) {
       super(frameCount, bezierCount, [
@@ -3921,9 +3964,14 @@ var spine = (() => {
         this.queue.event(entry, event);
       }
       let complete = false;
-      if (entry.loop)
-        complete = duration == 0 || trackLastWrapped > entry.trackTime % duration;
-      else
+      if (entry.loop) {
+        if (duration == 0)
+          complete = true;
+        else {
+          const cycles = Math.floor(entry.trackTime / duration);
+          complete = cycles > 0 && cycles > Math.floor(entry.trackTime / duration);
+        }
+      } else
         complete = animationTime >= animationEnd && entry.animationLast < animationEnd;
       if (complete)
         this.queue.complete(entry);
@@ -5427,7 +5475,7 @@ var spine = (() => {
     /** The local shearX. */
     shearY = 0;
     /** The transform mode for how parent world transforms affect this bone. */
-    transformMode = TransformMode.Normal;
+    inherit = Inherit.Normal;
     /** When true, {@link Skeleton#updateWorldTransform()} only updates this bone if the {@link Skeleton#skin} contains this
       * bone.
       * @see Skin#bones */
@@ -5449,14 +5497,14 @@ var spine = (() => {
       this.parent = parent;
     }
   };
-  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";
-    return TransformMode2;
-  })(TransformMode || {});
+  var Inherit = /* @__PURE__ */ ((Inherit2) => {
+    Inherit2[Inherit2["Normal"] = 0] = "Normal";
+    Inherit2[Inherit2["OnlyTranslation"] = 1] = "OnlyTranslation";
+    Inherit2[Inherit2["NoRotationOrReflection"] = 2] = "NoRotationOrReflection";
+    Inherit2[Inherit2["NoScale"] = 3] = "NoScale";
+    Inherit2[Inherit2["NoScaleOrReflection"] = 4] = "NoScaleOrReflection";
+    return Inherit2;
+  })(Inherit || {});
 
   // spine-core/src/Bone.ts
   var Bone = class {
@@ -5508,6 +5556,7 @@ var spine = (() => {
     worldY = 0;
     /** The world Y position. If changed, {@link #updateAppliedTransform()} should be called. */
     worldX = 0;
+    inherit = 0 /* Normal */;
     sorted = false;
     active = false;
     /** @param parent May be null. */
@@ -5566,7 +5615,7 @@ var spine = (() => {
       let pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d;
       this.worldX = pa * x + pb * y + parent.worldX;
       this.worldY = pc * x + pd * y + parent.worldY;
-      switch (this.data.transformMode) {
+      switch (this.inherit) {
         case 0 /* Normal */: {
           const rx = (rotation + shearX) * MathUtils.degRad;
           const ry = (rotation + 90 + shearY) * MathUtils.degRad;
@@ -5628,7 +5677,7 @@ var spine = (() => {
           za *= s;
           zc *= s;
           s = Math.sqrt(za * za + zc * zc);
-          if (this.data.transformMode == 3 /* NoScale */ && pa * pd - pb * pc < 0 != (this.skeleton.scaleX < 0 != this.skeleton.scaleY < 0))
+          if (this.inherit == 3 /* NoScale */ && pa * pd - pb * pc < 0 != (this.skeleton.scaleX < 0 != this.skeleton.scaleY < 0))
             s = -s;
           rotation = Math.PI / 2 + Math.atan2(zc, za);
           const zb = Math.cos(rotation) * s;
@@ -5661,6 +5710,7 @@ var spine = (() => {
       this.scaleY = data.scaleY;
       this.shearX = data.shearX;
       this.shearY = data.shearY;
+      this.inherit = data.inherit;
     }
     /** Computes the applied transform values from the world transform.
      *
@@ -5689,13 +5739,13 @@ var spine = (() => {
       this.ax = dx * ia - dy * ib;
       this.ay = dy * id - dx * ic;
       let ra, rb, rc, rd;
-      if (this.data.transformMode == 1 /* OnlyTranslation */) {
+      if (this.inherit == 1 /* OnlyTranslation */) {
         ra = this.a;
         rb = this.b;
         rc = this.c;
         rd = this.d;
       } else {
-        switch (this.data.transformMode) {
+        switch (this.inherit) {
           case 2 /* NoRotationOrReflection */: {
             let s2 = Math.abs(pa * pd - pb * pc) / (pa * pa + pc * pc);
             let sa = pa / this.skeleton.scaleX;
@@ -5718,7 +5768,7 @@ var spine = (() => {
             pa *= s;
             pc *= s;
             s = Math.sqrt(pa * pa + pc * pc);
-            if (this.data.transformMode == 3 /* NoScale */ && pid < 0 != (this.skeleton.scaleX < 0 != this.skeleton.scaleY < 0))
+            if (this.inherit == 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;
@@ -6232,7 +6282,7 @@ var spine = (() => {
         throw new Error("IK bone must have parent.");
       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) {
+      switch (bone.inherit) {
         case 1 /* OnlyTranslation */:
           tx = (targetX - bone.worldX) * MathUtils.signum(bone.skeleton.scaleX);
           ty = (targetY - bone.worldY) * MathUtils.signum(bone.skeleton.scaleY);
@@ -6264,7 +6314,7 @@ var spine = (() => {
         rotationIK += 360;
       let sx = bone.ascaleX, sy = bone.ascaleY;
       if (compress || stretch) {
-        switch (bone.data.transformMode) {
+        switch (bone.inherit) {
           case 3 /* NoScale */:
           case 4 /* NoScaleOrReflection */:
             tx = targetX - bone.worldX;
@@ -6294,6 +6344,8 @@ var spine = (() => {
     /** 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) {
+      if (parent.inherit != 0 /* Normal */ || child.inherit != 0 /* Normal */)
+        return;
       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;
       if (psx < 0) {
@@ -6460,7 +6512,7 @@ var spine = (() => {
         return this._target;
     }
     /** Controls the bend direction of the IK bones, either 1 or -1. */
-    bendDirection = 1;
+    bendDirection = 0;
     /** When true and only a single bone is being constrained, if the target is too close, the bone is scaled to reach it. */
     compress = false;
     /** When true, if the target is out of range, the parent bone is scaled to reach it. If more than one bone is being constrained
@@ -6470,7 +6522,7 @@ var spine = (() => {
      * is scaled on both the X and Y axes. */
     uniform = false;
     /** A percentage (0-1) that controls the mix between the constrained and unconstrained rotations. */
-    mix = 1;
+    mix = 0;
     /** For two bone IK, the distance from the maximum reach of the bones that rotation will slow. */
     softness = 0;
     constructor(name) {
@@ -7074,7 +7126,8 @@ var spine = (() => {
         case 1 /* reset */:
           this.reset();
         case 2 /* update */:
-          this.remaining += Math.max(this.skeleton.time - this.lastTime, 0);
+          const delta = Math.max(this.skeleton.time - this.lastTime, 0);
+          this.remaining += delta;
           this.lastTime = this.skeleton.time;
           const bx = bone.worldX, by = bone.worldY;
           if (this._reset) {
@@ -7082,32 +7135,34 @@ var spine = (() => {
             this.ux = bx;
             this.uy = by;
           } else {
-            let remaining = this.remaining, i = this.inertia, step = this.data.step;
+            let a = this.remaining, i = this.inertia, q = this.data.limit * delta, t = this.data.step, f = this.skeleton.data.referenceScale, d = -1;
             if (x || y) {
               if (x) {
-                this.xOffset += (this.ux - bx) * i;
+                const u = (this.ux - bx) * i;
+                this.xOffset += u > q ? q : u < -q ? -q : u;
                 this.ux = bx;
               }
               if (y) {
-                this.yOffset += (this.uy - by) * i;
+                const u = (this.uy - by) * i;
+                this.yOffset += u > q ? q : u < -q ? -q : u;
                 this.uy = by;
               }
-              if (remaining >= step) {
-                const m = this.massInverse * step, e = this.strength, w = this.wind * 100, g = this.gravity * -100;
-                const d = Math.pow(this.damping, 60 * step);
+              if (a >= t) {
+                d = Math.pow(this.damping, 60 * t);
+                const m = this.massInverse * t, e = this.strength, w = this.wind * f, g = (Skeleton.yDown ? -this.gravity : this.gravity) * f;
                 do {
                   if (x) {
                     this.xVelocity += (w - this.xOffset * e) * m;
-                    this.xOffset += this.xVelocity * step;
+                    this.xOffset += this.xVelocity * t;
                     this.xVelocity *= d;
                   }
                   if (y) {
-                    this.yVelocity += (g - this.yOffset * e) * m;
-                    this.yOffset += this.yVelocity * step;
+                    this.yVelocity -= (g + this.yOffset * e) * m;
+                    this.yOffset += this.yVelocity * t;
                     this.yVelocity *= d;
                   }
-                  remaining -= step;
-                } while (remaining >= step);
+                  a -= t;
+                } while (a >= t);
               }
               if (x)
                 bone.worldX += this.xOffset * mix * this.data.x;
@@ -7116,9 +7171,18 @@ var spine = (() => {
             }
             if (rotateOrShearX || scaleX) {
               let ca = Math.atan2(bone.c, bone.a), c = 0, s = 0, mr = 0;
+              let dx = this.cx - bone.worldX, dy = this.cy - bone.worldY;
+              if (dx > q)
+                dx = q;
+              else if (dx < -q)
+                dx = -q;
+              if (dy > q)
+                dy = q;
+              else if (dy < -q)
+                dy = -q;
               if (rotateOrShearX) {
                 mr = (this.data.rotate + this.data.shearX) * mix;
-                let dx = this.cx - bone.worldX, dy = this.cy - bone.worldY, r = Math.atan2(dy + this.ty, dx + this.tx) - ca - this.rotateOffset * mr;
+                let r = Math.atan2(dy + this.ty, dx + this.tx) - ca - this.rotateOffset * mr;
                 this.rotateOffset += (r - Math.ceil(r * MathUtils.invPI2 - 0.5) * MathUtils.PI2) * i;
                 r = this.rotateOffset * mr + ca;
                 c = Math.cos(r);
@@ -7133,34 +7197,35 @@ var spine = (() => {
                 s = Math.sin(ca);
                 const r = l * bone.getWorldScaleX();
                 if (r > 0)
-                  this.scaleOffset += ((this.cx - bone.worldX) * c + (this.cy - bone.worldY) * s) * i / r;
+                  this.scaleOffset += (dx * c + dy * s) * i / r;
               }
-              remaining = this.remaining;
-              if (remaining >= step) {
-                const m = this.massInverse * step, e = this.strength, w = this.wind, g = this.gravity;
-                const d = Math.pow(this.damping, 60 * step);
+              a = this.remaining;
+              if (a >= t) {
+                if (d == -1)
+                  d = Math.pow(this.damping, 60 * t);
+                const m = this.massInverse * t, e = this.strength, w = this.wind, g = Skeleton.yDown ? -this.gravity : this.gravity, h = l / f;
                 while (true) {
-                  remaining -= step;
+                  a -= t;
                   if (scaleX) {
                     this.scaleVelocity += (w * c - g * s - this.scaleOffset * e) * m;
-                    this.scaleOffset += this.scaleVelocity * step;
+                    this.scaleOffset += this.scaleVelocity * t;
                     this.scaleVelocity *= d;
                   }
                   if (rotateOrShearX) {
-                    this.rotateVelocity += (-0.01 * l * (w * s + g * c) - this.rotateOffset * e) * m;
-                    this.rotateOffset += this.rotateVelocity * step;
+                    this.rotateVelocity -= ((w * s + g * c) * h + this.rotateOffset * e) * m;
+                    this.rotateOffset += this.rotateVelocity * t;
                     this.rotateVelocity *= d;
-                    if (remaining < step)
+                    if (a < t)
                       break;
                     const r = this.rotateOffset * mr + ca;
                     c = Math.cos(r);
                     s = Math.sin(r);
-                  } else if (remaining < step)
+                  } else if (a < t)
                     break;
                 }
               }
             }
-            this.remaining = remaining;
+            this.remaining = a;
           }
           this.cx = bone.worldX;
           this.cy = bone.worldY;
@@ -7212,6 +7277,21 @@ var spine = (() => {
       }
       bone.updateAppliedTransform();
     }
+    /** Translates the physics constraint so next {@link #update(Physics)} forces are applied as if the bone moved an additional
+     * amount in world space. */
+    translate(x, y) {
+      this.ux -= x;
+      this.uy -= y;
+      this.cx -= x;
+      this.cy -= y;
+    }
+    /** Rotates the physics constraint so next {@link #update(Physics)} forces are applied as if the bone rotated around the
+     * specified point in world space. */
+    rotate(x, y, degrees) {
+      const r = degrees * MathUtils.degRad, cos = Math.cos(r), sin = Math.sin(r);
+      const dx = this.cx - x, dy = this.cy - y;
+      this.translate(dx * cos - dy * sin - dx, dx * sin + dy * cos - dy);
+    }
   };
 
   // spine-core/src/Slot.ts
@@ -7471,11 +7551,8 @@ var spine = (() => {
       for (let i = 0, n = bones.length; i < n; i++) {
         let bone = bones[i];
         let rotation = bone.arotation;
-        if (mixRotate != 0) {
-          let r = target.arotation - rotation + this.data.offsetRotation;
-          r -= Math.ceil(r / 360 - 0.5) * 360;
-          rotation += r * mixRotate;
-        }
+        if (mixRotate != 0)
+          rotation += (target.arotation - rotation + this.data.offsetRotation) * mixRotate;
         let x = bone.ax, y = bone.ay;
         x += (target.ax - x + this.data.offsetX) * mixX;
         y += (target.ay - y + this.data.offsetY) * mixY;
@@ -7485,11 +7562,8 @@ var spine = (() => {
         if (mixScaleY != 0 && scaleY != 0)
           scaleY = (scaleY + (target.ascaleY - scaleY + this.data.offsetScaleY) * mixScaleY) / scaleY;
         let shearY = bone.ashearY;
-        if (mixShearY != 0) {
-          let r = target.ashearY - shearY + this.data.offsetShearY;
-          r -= Math.ceil(r / 360 - 0.5) * 360;
-          shearY += r * mixShearY;
-        }
+        if (mixShearY != 0)
+          shearY += (target.ashearY - shearY + this.data.offsetShearY) * mixShearY;
         bone.updateWorldTransformWith(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
       }
     }
@@ -7516,7 +7590,7 @@ var spine = (() => {
     data;
     /** The skeleton's bones, sorted parent first. The root bone is always the first bone. */
     bones;
-    /** The skeleton's slots. */
+    /** The skeleton's slots in the setup pose draw order. */
     slots;
     /** The skeleton's slots in the order they should be drawn. The returned array may be modified to change the draw order. */
     drawOrder;
@@ -8068,9 +8142,20 @@ var spine = (() => {
     update(delta) {
       this.time += delta;
     }
+    physicsTranslate(x, y) {
+      const physicsConstraints = this.physicsConstraints;
+      for (let i = 0, n = physicsConstraints.length; i < n; i++)
+        physicsConstraints[i].translate(x, y);
+    }
+    /** Calls {@link PhysicsConstraint#rotate(float, float, float)} for each physics constraint. */
+    physicsRotate(x, y, degrees) {
+      const physicsConstraints = this.physicsConstraints;
+      for (let i = 0, n = physicsConstraints.length; i < n; i++)
+        physicsConstraints[i].rotate(x, y, degrees);
+    }
   };
-  var Skeleton2 = _Skeleton;
-  __publicField(Skeleton2, "yDown", false);
+  var Skeleton = _Skeleton;
+  __publicField(Skeleton, "yDown", false);
   var Physics = /* @__PURE__ */ ((Physics2) => {
     Physics2[Physics2["none"] = 0] = "none";
     Physics2[Physics2["reset"] = 1] = "reset";
@@ -8097,6 +8182,7 @@ var spine = (() => {
     rotate = 0;
     scaleX = 0;
     shearX = 0;
+    limit = 0;
     step = 0;
     inertia = 0;
     strength = 0;
@@ -8125,7 +8211,7 @@ var spine = (() => {
     /** The skeleton's bones, sorted parent first. The root bone is always the first bone. */
     bones = new Array();
     // Ordered parents first.
-    /** The skeleton's slots. */
+    /** The skeleton's slots in the setup pose draw order. */
     slots = new Array();
     // Setup pose draw order.
     skins = new Array();
@@ -8154,6 +8240,9 @@ var spine = (() => {
     width = 0;
     /** The height of the skeleton's axis aligned bounding box in the setup pose. */
     height = 0;
+    /** Baseline scale factor for applying distance-dependent effects on non-scalable properties, such as angle or scale. Default
+     * is 100. */
+    referenceScale = 100;
     /** The Spine version used to export the skeleton data, or null. */
     version = null;
     /** The skeleton data hash. This value will change if any of the skeleton data has changed. May be null. */
@@ -8485,6 +8574,8 @@ var spine = (() => {
     blendMode = BlendMode.Normal;
     /** False if the slot was hidden in Spine and nonessential data was exported. Does not affect runtime rendering. */
     visible = true;
+    /** The folders for this slot in the draw order, delimited by <code>/</code>, or null if nonessential data was not exported. */
+    path = null;
     constructor(index, name, boneData) {
       if (index < 0)
         throw new Error("index must be >= 0.");
@@ -8570,6 +8661,7 @@ var spine = (() => {
       skeletonData.y = input.readFloat();
       skeletonData.width = input.readFloat();
       skeletonData.height = input.readFloat();
+      skeletonData.referenceScale = input.readFloat() * scale;
       let nonessential = input.readBoolean();
       if (nonessential) {
         skeletonData.fps = input.readFloat();
@@ -8599,7 +8691,7 @@ var spine = (() => {
         data.shearX = input.readFloat();
         data.shearY = input.readFloat();
         data.length = input.readFloat() * scale;
-        data.transformMode = input.readInt(true);
+        data.inherit = input.readByte();
         data.skinRequired = input.readBoolean();
         if (nonessential) {
           Color.rgba8888ToColor(data.color, input.readInt32());
@@ -8613,6 +8705,14 @@ var spine = (() => {
         let slotName = input.readString();
         if (!slotName)
           throw new Error("Slot name must not be null.");
+        let path = null;
+        if (nonessential) {
+          const slash = slotName.lastIndexOf("/");
+          if (slash != -1) {
+            path = slotName.substring(0, slash);
+            slotName = slotName.substring(slash + 1);
+          }
+        }
         let boneData = skeletonData.bones[input.readInt(true)];
         let data = new SlotData(i, slotName, boneData);
         Color.rgba8888ToColor(data.color, input.readInt32());
@@ -8621,8 +8721,10 @@ var spine = (() => {
           Color.rgb888ToColor(data.darkColor = new Color(), darkColor);
         data.attachmentName = input.readStringRef();
         data.blendMode = input.readInt(true);
-        if (nonessential)
+        if (nonessential) {
           data.visible = input.readBoolean();
+          data.path = path;
+        }
         skeletonData.slots.push(data);
       }
       n = input.readInt(true);
@@ -8636,14 +8738,16 @@ var spine = (() => {
         for (let ii = 0; ii < nn; ii++)
           data.bones.push(skeletonData.bones[input.readInt(true)]);
         data.target = skeletonData.bones[input.readInt(true)];
-        data.mix = input.readFloat();
-        data.softness = input.readFloat() * scale;
         let flags = input.readByte();
         data.skinRequired = (flags & 1) != 0;
         data.bendDirection = (flags & 2) != 0 ? 1 : -1;
         data.compress = (flags & 4) != 0;
         data.stretch = (flags & 8) != 0;
         data.uniform = (flags & 16) != 0;
+        if ((flags & 32) != 0)
+          data.mix = (flags & 64) != 0 ? input.readFloat() : 1;
+        if ((flags & 128) != 0)
+          data.softness = input.readFloat() * scale;
         skeletonData.ikConstraints.push(data);
       }
       n = input.readInt(true);
@@ -8657,22 +8761,35 @@ var spine = (() => {
         for (let ii = 0; ii < nn; ii++)
           data.bones.push(skeletonData.bones[input.readInt(true)]);
         data.target = skeletonData.bones[input.readInt(true)];
-        const flags = input.readByte();
+        let flags = input.readByte();
         data.skinRequired = (flags & 1) != 0;
         data.local = (flags & 2) != 0;
         data.relative = (flags & 4) != 0;
-        data.offsetRotation = input.readFloat();
-        data.offsetX = input.readFloat() * scale;
-        data.offsetY = input.readFloat() * scale;
-        data.offsetScaleX = input.readFloat();
-        data.offsetScaleY = input.readFloat();
-        data.offsetShearY = input.readFloat();
-        data.mixRotate = input.readFloat();
-        data.mixX = input.readFloat();
-        data.mixY = input.readFloat();
-        data.mixScaleX = input.readFloat();
-        data.mixScaleY = input.readFloat();
-        data.mixShearY = input.readFloat();
+        if ((flags & 8) != 0)
+          data.offsetRotation = input.readFloat();
+        if ((flags & 16) != 0)
+          data.offsetX = input.readFloat() * scale;
+        if ((flags & 32) != 0)
+          data.offsetY = input.readFloat() * scale;
+        if ((flags & 64) != 0)
+          data.offsetScaleX = input.readFloat();
+        if ((flags & 128) != 0)
+          data.offsetScaleY = input.readFloat();
+        flags = input.readByte();
+        if ((flags & 1) != 0)
+          data.offsetShearY = input.readFloat();
+        if ((flags & 2) != 0)
+          data.mixRotate = input.readFloat();
+        if ((flags & 4) != 0)
+          data.mixX = input.readFloat();
+        if ((flags & 8) != 0)
+          data.mixY = input.readFloat();
+        if ((flags & 16) != 0)
+          data.mixScaleX = input.readFloat();
+        if ((flags & 32) != 0)
+          data.mixScaleY = input.readFloat();
+        if ((flags & 64) != 0)
+          data.mixShearY = input.readFloat();
         skeletonData.transformConstraints.push(data);
       }
       n = input.readInt(true);
@@ -8687,10 +8804,12 @@ var spine = (() => {
         for (let ii = 0; ii < nn; ii++)
           data.bones.push(skeletonData.bones[input.readInt(true)]);
         data.target = skeletonData.slots[input.readInt(true)];
-        data.positionMode = input.readInt(true);
-        data.spacingMode = input.readInt(true);
-        data.rotateMode = input.readInt(true);
-        data.offsetRotation = input.readFloat();
+        const flags = input.readByte();
+        data.positionMode = flags & 1;
+        data.spacingMode = flags >> 1 & 3;
+        data.rotateMode = flags >> 3 & 3;
+        if ((flags & 128) != 0)
+          data.offsetRotation = input.readFloat();
         data.position = input.readFloat();
         if (data.positionMode == 0 /* Fixed */)
           data.position *= scale;
@@ -8722,14 +8841,14 @@ var spine = (() => {
           data.scaleX = input.readFloat();
         if ((flags & 32) != 0)
           data.shearX = input.readFloat();
-        data.step = 1 / input.readByte();
+        data.limit = ((flags & 64) != 0 ? input.readFloat() : 5e3) * scale;
+        data.step = 1 / input.readUnsignedByte();
         data.inertia = input.readFloat();
         data.strength = input.readFloat();
         data.damping = input.readFloat();
-        data.massInverse = input.readFloat();
-        data.wind = input.readFloat() * scale;
-        data.gravity = input.readFloat() * scale;
-        data.mix = input.readFloat();
+        data.massInverse = (flags & 128) != 0 ? input.readFloat() : 1;
+        data.wind = input.readFloat();
+        data.gravity = input.readFloat();
         flags = input.readByte();
         if ((flags & 1) != 0)
           data.inertiaGlobal = true;
@@ -8745,6 +8864,7 @@ var spine = (() => {
           data.gravityGlobal = true;
         if ((flags & 64) != 0)
           data.mixGlobal = true;
+        data.mix = (flags & 128) != 0 ? input.readFloat() : 1;
         skeletonData.physicsConstraints.push(data);
       }
       let defaultSkin = this.readSkin(input, skeletonData, true, nonessential);
@@ -8854,7 +8974,7 @@ var spine = (() => {
           let path = (flags & 16) != 0 ? input.readStringRef() : null;
           const color = (flags & 32) != 0 ? input.readInt32() : 4294967295;
           const sequence = (flags & 64) != 0 ? this.readSequence(input) : null;
-          let rotation = input.readFloat();
+          let rotation = (flags & 128) != 0 ? input.readFloat() : 0;
           let x = input.readFloat();
           let y = input.readFloat();
           let scaleX = input.readFloat();
@@ -9013,8 +9133,6 @@ var spine = (() => {
       return null;
     }
     readSequence(input) {
-      if (!input.readBoolean())
-        return null;
       let sequence = new Sequence(input.readInt(true));
       sequence.start = input.readInt(true);
       sequence.digits = input.readInt(true);
@@ -9268,7 +9386,16 @@ var spine = (() => {
       for (let i = 0, n = input.readInt(true); i < n; i++) {
         let boneIndex = input.readInt(true);
         for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) {
-          let type = input.readByte(), frameCount = input.readInt(true), bezierCount = input.readInt(true);
+          let type = input.readByte(), frameCount = input.readInt(true);
+          if (type == BONE_INHERIT) {
+            let timeline = new InheritTimeline(frameCount, boneIndex);
+            for (let frame = 0; frame < frameCount; frame++) {
+              timeline.setFrame(frame, input.readFloat(), input.readByte());
+            }
+            timelines.push(timeline);
+            continue;
+          }
+          let bezierCount = input.readInt(true);
           switch (type) {
             case BONE_ROTATE:
               timelines.push(readTimeline1(input, new RotateTimeline(frameCount, bezierCount, boneIndex), 1));
@@ -9305,20 +9432,21 @@ var spine = (() => {
       for (let i = 0, n = input.readInt(true); i < n; i++) {
         let index = input.readInt(true), frameCount = input.readInt(true), frameLast = frameCount - 1;
         let timeline = new IkConstraintTimeline(frameCount, input.readInt(true), index);
-        let time = input.readFloat(), mix = input.readFloat(), softness = input.readFloat() * scale;
+        let flags = input.readByte();
+        let time = input.readFloat(), mix = (flags & 1) != 0 ? (flags & 2) != 0 ? input.readFloat() : 1 : 0;
+        let softness = (flags & 4) != 0 ? input.readFloat() * scale : 0;
         for (let frame = 0, bezier = 0; ; frame++) {
-          const flags = input.readByte();
-          timeline.setFrame(frame, time, mix, softness, input.readByte(), (flags & 1) != 0, (flags & 2) != 0);
+          timeline.setFrame(frame, time, mix, softness, (flags & 8) != 0 ? 1 : -1, (flags & 16) != 0, (flags & 32) != 0);
           if (frame == frameLast)
             break;
-          let time2 = input.readFloat(), mix2 = input.readFloat(), softness2 = input.readFloat() * scale;
-          switch (input.readByte()) {
-            case CURVE_STEPPED:
-              timeline.setStepped(frame);
-              break;
-            case CURVE_BEZIER:
-              setBezier(input, timeline, bezier++, frame, 0, time, time2, mix, mix2, 1);
-              setBezier(input, timeline, bezier++, frame, 1, time, time2, softness, softness2, scale);
+          flags = input.readByte();
+          const time2 = input.readFloat(), mix2 = (flags & 1) != 0 ? (flags & 2) != 0 ? input.readFloat() : 1 : 0;
+          const softness2 = (flags & 4) != 0 ? input.readFloat() * scale : 0;
+          if ((flags & 64) != 0) {
+            timeline.setStepped(frame);
+          } else if ((flags & 128) != 0) {
+            setBezier(input, timeline, bezier++, frame, 0, time, time2, mix, mix2, 1);
+            setBezier(input, timeline, bezier++, frame, 1, time, time2, softness, softness2, scale);
           }
           time = time2;
           mix = mix2;
@@ -9429,10 +9557,10 @@ var spine = (() => {
               timelines.push(readTimeline1(input, new PhysicsConstraintMassTimeline(frameCount, bezierCount, index), 1));
               break;
             case PHYSICS_WIND:
-              timelines.push(readTimeline1(input, new PhysicsConstraintWindTimeline(frameCount, bezierCount, index), scale));
+              timelines.push(readTimeline1(input, new PhysicsConstraintWindTimeline(frameCount, bezierCount, index), 1));
               break;
             case PHYSICS_GRAVITY:
-              timelines.push(readTimeline1(input, new PhysicsConstraintGravityTimeline(frameCount, bezierCount, index), scale));
+              timelines.push(readTimeline1(input, new PhysicsConstraintGravityTimeline(frameCount, bezierCount, index), 1));
               break;
             case PHYSICS_MIX:
               timelines.push(readTimeline1(input, new PhysicsConstraintMixTimeline(frameCount, bezierCount, index), 1));
@@ -9740,6 +9868,7 @@ var spine = (() => {
   var BONE_SHEAR = 7;
   var BONE_SHEARX = 8;
   var BONE_SHEARY = 9;
+  var BONE_INHERIT = 10;
   var SLOT_ATTACHMENT = 0;
   var SLOT_RGBA = 1;
   var SLOT_RGB = 2;
@@ -10472,8 +10601,10 @@ var spine = (() => {
         skeletonData.y = skeletonMap.y;
         skeletonData.width = skeletonMap.width;
         skeletonData.height = skeletonMap.height;
+        skeletonData.referenceScale = getValue(skeletonMap, "referenceScale", 100) * scale;
         skeletonData.fps = skeletonMap.fps;
-        skeletonData.imagesPath = skeletonMap.images;
+        skeletonData.imagesPath = skeletonMap.images ?? null;
+        skeletonData.audioPath = skeletonMap.audio ?? null;
       }
       if (root.bones) {
         for (let i = 0; i < root.bones.length; i++) {
@@ -10491,7 +10622,7 @@ var spine = (() => {
           data.scaleY = getValue(boneMap, "scaleY", 1);
           data.shearX = getValue(boneMap, "shearX", 0);
           data.shearY = getValue(boneMap, "shearY", 0);
-          data.transformMode = Utils.enumValue(TransformMode, getValue(boneMap, "transform", "Normal"));
+          data.inherit = Utils.enumValue(Inherit, getValue(boneMap, "inherit", "Normal"));
           data.skinRequired = getValue(boneMap, "skin", false);
           let color = getValue(boneMap, "color", null);
           if (color)
@@ -10502,10 +10633,17 @@ var spine = (() => {
       if (root.slots) {
         for (let i = 0; i < root.slots.length; i++) {
           let slotMap = root.slots[i];
+          let path = null;
+          let slotName = slotMap.name;
+          const slash = slotName.lastIndexOf("/");
+          if (slash != -1) {
+            path = slotName.substring(0, slash);
+            slotName = slotName.substring(slash + 1);
+          }
           let boneData = skeletonData.findBone(slotMap.bone);
           if (!boneData)
-            throw new Error(`Couldn't find bone ${slotMap.bone} for slot ${slotMap.name}`);
-          let data = new SlotData(skeletonData.slots.length, slotMap.name, boneData);
+            throw new Error(`Couldn't find bone ${slotMap.bone} for slot ${slotName}`);
+          let data = new SlotData(skeletonData.slots.length, slotName, boneData);
           let color = getValue(slotMap, "color", null);
           if (color)
             data.color.setFromString(color);
@@ -10514,6 +10652,8 @@ var spine = (() => {
             data.darkColor = Color.fromString(dark);
           data.attachmentName = getValue(slotMap, "attachment", null);
           data.blendMode = Utils.enumValue(BlendMode, getValue(slotMap, "blend", "normal"));
+          data.visible = getValue(slotMap, "visible", true);
+          data.path = path;
           skeletonData.slots.push(data);
         }
       }
@@ -10628,13 +10768,14 @@ var spine = (() => {
           data.rotate = getValue(constraintMap, "rotate", 0);
           data.scaleX = getValue(constraintMap, "scaleX", 0);
           data.shearX = getValue(constraintMap, "shearX", 0);
+          data.limit = getValue(constraintMap, "limit", 5e3) * scale;
           data.step = 1 / getValue(constraintMap, "fps", 60);
           data.inertia = getValue(constraintMap, "inertia", 1);
           data.strength = getValue(constraintMap, "strength", 100);
           data.damping = getValue(constraintMap, "damping", 1);
           data.massInverse = 1 / getValue(constraintMap, "mass", 1);
-          data.wind = getValue(constraintMap, "wind", 0) * scale;
-          data.gravity = getValue(constraintMap, "gravity", 0) * scale;
+          data.wind = getValue(constraintMap, "wind", 0);
+          data.gravity = getValue(constraintMap, "gravity", 0);
           data.mix = getValue(constraintMap, "mix", 1);
           data.inertiaGlobal = getValue(constraintMap, "inertiaGlobal", false);
           data.strengthGlobal = getValue(constraintMap, "strengthGlobal", false);
@@ -11079,6 +11220,13 @@ var spine = (() => {
             } else if (timelineName === "sheary") {
               let timeline = new ShearYTimeline(frames, frames, boneIndex);
               timelines.push(readTimeline12(timelineMap, timeline, 0, 1));
+            } else if (timelineName === "inherit") {
+              let timeline = new InheritTimeline(frames, bone.index);
+              for (let frame = 0; frame < timelineMap.length; frame++) {
+                let aFrame = timelineMap[frame];
+                timeline.setFrame(frame, getValue(aFrame, "time", 0), Utils.enumValue(Inherit, getValue(aFrame, "inherit", "Normal")));
+              }
+              timelines.push(timeline);
             }
           }
         }
@@ -11250,7 +11398,6 @@ var spine = (() => {
               continue;
             }
             let timeline;
-            let timelineScale = 1;
             if (timelineName == "inertia")
               timeline = new PhysicsConstraintInertiaTimeline(frames, frames, constraintIndex);
             else if (timelineName == "strength")
@@ -11259,17 +11406,15 @@ var spine = (() => {
               timeline = new PhysicsConstraintDampingTimeline(frames, frames, constraintIndex);
             else if (timelineName == "mass")
               timeline = new PhysicsConstraintMassTimeline(frames, frames, constraintIndex);
-            else if (timelineName == "wind") {
+            else if (timelineName == "wind")
               timeline = new PhysicsConstraintWindTimeline(frames, frames, constraintIndex);
-              timelineScale = scale;
-            } else if (timelineName == "gravity") {
+            else if (timelineName == "gravity")
               timeline = new PhysicsConstraintGravityTimeline(frames, frames, constraintIndex);
-              timelineScale = scale;
-            } else if (timelineName == "mix")
+            else if (timelineName == "mix")
               timeline = new PhysicsConstraintMixTimeline(frames, frames, constraintIndex);
             else
               continue;
-            timelines.push(readTimeline12(timelineMap, timeline, 0, timelineScale));
+            timelines.push(readTimeline12(timelineMap, timeline, 0, 1));
           }
         }
       }