@esotericsoftware/spine-canvas 4.3.0 → 4.3.1

package/dist/iife/spine-canvas.js

@@ -301,6 +301,8 @@ var spine = (() => {
     }
   };
   var MathUtils = class _MathUtils {
+    static epsilon = 1e-5;
+    static epsilon2 = _MathUtils.epsilon * _MathUtils.epsilon;
     // biome-ignore lint/suspicious/noApproximativeNumericConstant: reference runtime
     static PI = 3.1415927;
     static PI2 = _MathUtils.PI * 2;
@@ -6098,73 +6100,70 @@ ${error}` : ""}`);
           return;
         }
         case 1 /* OnlyTranslation */: {
+          const sx = skeleton.scaleX, sy = skeleton.scaleY;
           const rx = (rotation + shearX) * MathUtils.degRad;
           const ry = (rotation + 90 + shearY) * MathUtils.degRad;
-          this.a = Math.cos(rx) * scaleX;
-          this.b = Math.cos(ry) * scaleY;
-          this.c = Math.sin(rx) * scaleX;
-          this.d = Math.sin(ry) * scaleY;
+          this.a = Math.cos(rx) * scaleX * sx;
+          this.b = Math.cos(ry) * scaleY * sx;
+          this.c = Math.sin(rx) * scaleX * sy;
+          this.d = Math.sin(ry) * scaleY * sy;
           break;
         }
         case 2 /* NoRotationOrReflection */: {
-          const sx = 1 / skeleton.scaleX, sy = 1 / skeleton.scaleY;
-          pa *= sx;
-          pc *= sy;
+          const sx = skeleton.scaleX, sy = skeleton.scaleY, sxi = 1 / sx, syi = 1 / sy;
+          pa *= sxi;
+          pc *= syi;
           let s = pa * pa + pc * pc;
-          let prx = 0;
-          if (s > 1e-4) {
-            s = Math.abs(pa * pd * sy - pb * sx * pc) / s;
+          let r = 0;
+          if (s > MathUtils.epsilon2) {
+            s = Math.abs(pa * pd * syi - pb * sxi * pc) / s;
             pb = pc * s;
             pd = pa * s;
-            prx = MathUtils.atan2Deg(pc, pa);
+            r = rotation - MathUtils.atan2Deg(pc, pa);
           } else {
             pa = 0;
             pc = 0;
-            prx = 90 - MathUtils.atan2Deg(pd, pb);
+            r = rotation - 90 + MathUtils.atan2Deg(pd, pb);
           }
-          const rx = (rotation + shearX - prx) * MathUtils.degRad;
-          const ry = (rotation + shearY - prx + 90) * MathUtils.degRad;
+          const rx = (r + shearX) * MathUtils.degRad;
+          const ry = (r + shearY + 90) * MathUtils.degRad;
           const la = Math.cos(rx) * scaleX;
           const lb = Math.cos(ry) * scaleY;
           const lc = Math.sin(rx) * scaleX;
           const ld = Math.sin(ry) * scaleY;
-          this.a = pa * la - pb * lc;
-          this.b = pa * lb - pb * ld;
-          this.c = pc * la + pd * lc;
-          this.d = pc * lb + pd * ld;
+          this.a = (pa * la - pb * lc) * sx;
+          this.b = (pa * lb - pb * ld) * sx;
+          this.c = (pc * la + pd * lc) * sy;
+          this.d = (pc * lb + pd * ld) * sy;
           break;
         }
         case 3 /* NoScale */:
         case 4 /* NoScaleOrReflection */: {
-          let r = rotation * MathUtils.degRad, cos = Math.cos(r), sin = Math.sin(r);
-          let za = (pa * cos + pb * sin) / skeleton.scaleX;
-          let zc = (pc * cos + pd * sin) / skeleton.scaleY;
-          let s = Math.sqrt(za * za + zc * zc);
-          if (s > 1e-5) s = 1 / s;
+          const sx = skeleton.scaleX, sy = skeleton.scaleY, sxi = 1 / sx, syi = 1 / sy;
+          const r = rotation * MathUtils.degRad, cos = Math.cos(r), sin = Math.sin(r);
+          let za = (pa * cos + pb * sin) * sxi;
+          let zc = (pc * cos + pd * sin) * syi;
+          const s = 1 / Math.sqrt(za * za + zc * zc);
           za *= s;
           zc *= s;
-          s = Math.sqrt(za * za + zc * zc);
-          if (this.inherit === 3 /* NoScale */ && pa * pd - pb * pc < 0 !== (skeleton.scaleX < 0 !== skeleton.scaleY < 0)) s = -s;
-          r = Math.PI / 2 + Math.atan2(zc, za);
-          const zb = Math.cos(r) * s;
-          const zd = Math.sin(r) * s;
+          let zb = -zc, zd = za;
+          if (this.inherit === 3 /* NoScale */ && pa * pd - pb * pc < 0 !== (sx < 0 !== sy < 0)) {
+            zb = -zb;
+            zd = -zd;
+          }
           const rx = shearX * MathUtils.degRad;
           const ry = (90 + shearY) * MathUtils.degRad;
           const la = Math.cos(rx) * scaleX;
           const lb = Math.cos(ry) * scaleY;
           const lc = Math.sin(rx) * scaleX;
           const ld = Math.sin(ry) * scaleY;
-          this.a = za * la + zb * lc;
-          this.b = za * lb + zb * ld;
-          this.c = zc * la + zd * lc;
-          this.d = zc * lb + zd * ld;
+          this.a = (za * la + zb * lc) * sx;
+          this.b = (za * lb + zb * ld) * sx;
+          this.c = (zc * la + zd * lc) * sy;
+          this.d = (zc * lb + zd * ld) * sy;
           break;
         }
       }
-      this.a *= skeleton.scaleX;
-      this.b *= skeleton.scaleX;
-      this.c *= skeleton.scaleY;
-      this.d *= skeleton.scaleY;
     }
     /** Computes the local transform values from the world transform.
      *
@@ -6177,79 +6176,118 @@ ${error}` : ""}`);
     updateLocalTransform(skeleton) {
       this.local = 0;
       this.world = skeleton._update;
+      const sx = skeleton.scaleX, sy = skeleton.scaleY;
       if (!this.bone.parent) {
-        this.x = this.worldX - skeleton.x;
-        this.y = this.worldY - skeleton.y;
-        const a = this.a, b = this.b, c = this.c, d = this.d;
-        this.rotation = MathUtils.atan2Deg(c, a);
-        this.scaleX = Math.sqrt(a * a + c * c);
-        this.scaleY = Math.sqrt(b * b + d * d);
-        this.shearX = 0;
-        this.shearY = MathUtils.atan2Deg(a * b + c * d, a * d - b * c);
+        const sxi = 1 / sx, syi = 1 / sy;
+        this.x = (this.worldX - skeleton.x) * sxi;
+        this.y = (this.worldY - skeleton.y) * syi;
+        this.set5(this.a * sxi, this.b * sxi, this.c * syi, this.d * syi, 0);
         return;
       }
       const parent = this.bone.parent.appliedPose;
       let pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d;
-      let pid = 1 / (pa * pd - pb * pc);
-      let ia = pd * pid, ib = pb * pid, ic = pc * pid, id = pa * pid;
+      const pad = pa * pd - pb * pc, pid = 1 / (pa * pd - pb * pc);
+      const ia = pd * pid, ib = pb * pid, ic = pc * pid, id = pa * pid;
       const dx = this.worldX - parent.worldX, dy = this.worldY - parent.worldY;
       this.x = dx * ia - dy * ib;
       this.y = dy * id - dx * ic;
-      let ra, rb, rc, rd;
-      if (this.inherit === 1 /* OnlyTranslation */) {
-        ra = this.a;
-        rb = this.b;
-        rc = this.c;
-        rd = this.d;
+      switch (this.inherit) {
+        case 0 /* Normal */:
+          this.set5(ia * this.a - ib * this.c, ia * this.b - ib * this.d, id * this.c - ic * this.a, id * this.d - ic * this.b, 0);
+          break;
+        case 1 /* OnlyTranslation */: {
+          const sxi = 1 / sx, syi = 1 / sy;
+          this.set5(this.a * sxi, this.b * sxi, this.c * syi, this.d * syi, 0);
+          break;
+        }
+        case 2 /* NoRotationOrReflection */: {
+          const sxi = 1 / sx, syi = 1 / sy;
+          pa *= sxi;
+          pc *= syi;
+          const wa = this.a * sxi, wb = this.b * sxi, wc = this.c * syi, wd = this.d * syi;
+          const s = 1 / (pa * pa + pc * pc), det = 1 / Math.abs(pad * sxi * syi);
+          this.set5(
+            (pa * wa + pc * wc) * s,
+            (pa * wb + pc * wd) * s,
+            (pa * wc - pc * wa) * det,
+            (pa * wd - pc * wb) * det,
+            MathUtils.atan2Deg(pc, pa)
+          );
+          break;
+        }
+        case 3 /* NoScale */:
+        case 4 /* NoScaleOrReflection */: {
+          const sxi = 1 / sx, syi = 1 / sy;
+          const wa = this.a * sxi, wb = this.b * sxi, wc = this.c * syi, wd = this.d * syi;
+          let tx = pd * this.a - pb * this.c, ty = pa * this.c - pc * this.a;
+          if (pad < 0) {
+            tx = -tx;
+            ty = -ty;
+          }
+          let r = MathUtils.atan2Deg(ty, tx);
+          this.rotation = r;
+          r *= MathUtils.degRad;
+          const cos = Math.cos(r), sin = Math.sin(r);
+          let za = (pa * cos + pb * sin) * sxi;
+          let zc = (pc * cos + pd * sin) * syi;
+          const s = 1 / Math.sqrt(za * za + zc * zc);
+          za *= s;
+          zc *= s;
+          const si = this.inherit === 3 /* NoScale */ && pad < 0 !== (sx < 0 !== sy < 0) ? -1 : 1;
+          this.set4(za * wa + zc * wc, za * wb + zc * wd, (za * wc - zc * wa) * si, (za * wd - zc * wb) * si);
+        }
+      }
+    }
+    set4(ra, rb, rc, rd) {
+      const x = ra * ra + rc * rc, y = rb * rb + rd * rd;
+      if (x > MathUtils.epsilon2) {
+        this.shearX = MathUtils.atan2Deg(rc, ra);
+        this.scaleX = Math.sqrt(x);
       } else {
-        switch (this.inherit) {
-          case 2 /* NoRotationOrReflection */: {
-            const s = Math.abs(pa * pd - pb * pc) / (pa * pa + pc * pc);
-            pb = -pc * skeleton.scaleX * s / skeleton.scaleY;
-            pd = pa * skeleton.scaleY * s / skeleton.scaleX;
-            pid = 1 / (pa * pd - pb * pc);
-            ia = pd * pid;
-            ib = pb * pid;
-            break;
-          }
-          case 3 /* NoScale */:
-          case 4 /* NoScaleOrReflection */: {
-            let r = this.rotation * MathUtils.degRad, cos = Math.cos(r), sin = Math.sin(r);
-            pa = (pa * cos + pb * sin) / skeleton.scaleX;
-            pc = (pc * cos + pd * sin) / skeleton.scaleY;
-            let s = Math.sqrt(pa * pa + pc * pc);
-            if (s > 1e-5) s = 1 / s;
-            pa *= s;
-            pc *= s;
-            s = Math.sqrt(pa * pa + pc * pc);
-            if (this.inherit === 3 /* NoScale */ && pid < 0 !== (skeleton.scaleX < 0 !== skeleton.scaleY < 0)) s = -s;
-            r = MathUtils.PI / 2 + Math.atan2(pc, pa);
-            pb = Math.cos(r) * s;
-            pd = Math.sin(r) * s;
-            pid = 1 / (pa * pd - pb * pc);
-            ia = pd * pid;
-            ib = pb * pid;
-            ic = pc * pid;
-            id = pa * pid;
-          }
-        }
-        ra = ia * this.a - ib * this.c;
-        rb = ia * this.b - ib * this.d;
-        rc = id * this.c - ic * this.a;
-        rd = id * this.d - ic * this.b;
+        this.shearX = 0;
+        this.scaleX = 0;
       }
+      this.scaleY = Math.sqrt(y);
+      if (y > MathUtils.epsilon2) {
+        this.shearY = MathUtils.atan2Deg(rd, rb);
+        if (ra * rd - rb * rc < 0) {
+          this.scaleY = -this.scaleY;
+          this.shearY += 90;
+        } else
+          this.shearY -= 90;
+        if (this.shearY > 180)
+          this.shearY -= 360;
+        else if (this.shearY <= -180)
+          this.shearY += 360;
+      } else
+        this.shearY = 0;
+    }
+    set5(ra, rb, rc, rd, ro) {
       this.shearX = 0;
-      this.scaleX = Math.sqrt(ra * ra + rc * rc);
-      if (this.scaleX > 1e-4) {
-        const det = ra * rd - rb * rc;
-        this.scaleY = det / this.scaleX;
-        this.shearY = -MathUtils.atan2Deg(ra * rb + rc * rd, det);
-        this.rotation = MathUtils.atan2Deg(rc, ra);
+      const x = ra * ra + rc * rc, y = rb * rb + rd * rd;
+      if (x > MathUtils.epsilon2) {
+        const r = MathUtils.atan2Deg(rc, ra);
+        this.rotation = r + ro;
+        this.scaleX = Math.sqrt(x);
+        this.scaleY = Math.sqrt(y);
+        if (y > MathUtils.epsilon2) {
+          this.shearY = MathUtils.atan2Deg(rd, rb);
+          if (ra * rd - rb * rc < 0) {
+            this.scaleY = -this.scaleY;
+            this.shearY += 90 - r;
+          } else
+            this.shearY -= 90 + r;
+          if (this.shearY > 180)
+            this.shearY -= 360;
+          else if (this.shearY <= -180)
+            this.shearY += 360;
+        } else
+          this.shearY = 0;
       } else {
         this.scaleX = 0;
-        this.scaleY = Math.sqrt(rb * rb + rd * rd);
+        this.scaleY = Math.sqrt(y);
         this.shearY = 0;
-        this.rotation = 90 - MathUtils.atan2Deg(rd, rb);
+        this.rotation = y > MathUtils.epsilon2 ? MathUtils.atan2Deg(rd, rb) - 90 + ro : ro;
       }
     }
     /** If the world transform has been modified by constraints and the local transform no longer matches,
@@ -6494,6 +6532,12 @@ ${error}` : ""}`);
       super(name, setup);
     }
   };
+  var ScaleYMode = /* @__PURE__ */ ((ScaleYMode2) => {
+    ScaleYMode2[ScaleYMode2["None"] = 0] = "None";
+    ScaleYMode2[ScaleYMode2["Uniform"] = 1] = "Uniform";
+    ScaleYMode2[ScaleYMode2["Volume"] = 2] = "Volume";
+    return ScaleYMode2;
+  })(ScaleYMode || {});
 
   // spine-core/src/Event.ts
   var Event = class {
@@ -6565,43 +6609,6 @@ ${error}` : ""}`);
     }
   };
 
-  // spine-core/src/IkConstraintData.ts
-  var IkConstraintData = class extends ConstraintData {
-    /** The bones that are constrained by this IK constraint. */
-    bones = [];
-    _target = null;
-    /** The bone that is the IK target. */
-    set target(boneData) {
-      this._target = boneData;
-    }
-    get target() {
-      if (!this._target) throw new Error("target cannot be null.");
-      return this._target;
-    }
-    /** Determines how the {@link BonePose.scaleY} changes when {@link IkConstraintPose.compress} or
-      * {@link IkConstraintPose.stretch} set {@link BonePose.scaleX}. */
-    _scaleYMode = 0 /* None */;
-    set scaleYMode(scaleYMode) {
-      this._scaleYMode = scaleYMode;
-    }
-    get scaleYMode() {
-      if (this._scaleYMode == null) throw new Error("scaleYMode cannot be null.");
-      return this._scaleYMode;
-    }
-    constructor(name) {
-      super(name, new IkConstraintPose());
-    }
-    create(skeleton) {
-      return new IkConstraint(this, skeleton);
-    }
-  };
-  var ScaleYMode = /* @__PURE__ */ ((ScaleYMode2) => {
-    ScaleYMode2[ScaleYMode2["None"] = 0] = "None";
-    ScaleYMode2[ScaleYMode2["Uniform"] = 1] = "Uniform";
-    ScaleYMode2[ScaleYMode2["Volume"] = 2] = "Volume";
-    return ScaleYMode2;
-  })(ScaleYMode || {});
-
   // spine-core/src/IkConstraint.ts
   var IkConstraint = class _IkConstraint extends Constraint {
     /** The 1 or 2 bones that will be modified by this IK constraint. */
@@ -6688,7 +6695,7 @@ ${error}` : ""}`);
           break;
         // biome-ignore lint/suspicious/noFallthroughSwitchClause: reference runtime
         case 2 /* NoRotationOrReflection */: {
-          const s = Math.abs(pa * pd - pb * pc) / Math.max(1e-4, pa * pa + pc * pc);
+          const s = Math.abs(pa * pd - pb * pc) / Math.max(MathUtils.epsilon, pa * pa + pc * pc);
           const sa = pa / skeleton.scaleX;
           const sc = pc / skeleton.scaleY;
           pb = -sc * s * skeleton.scaleX;
@@ -6699,7 +6706,7 @@ ${error}` : ""}`);
         default: {
           const x = targetX - p.worldX, y = targetY - p.worldY;
           const d = pa * pd - pb * pc;
-          if (Math.abs(d) <= 1e-4) {
+          if (Math.abs(d) <= MathUtils.epsilon) {
             tx = 0;
             ty = 0;
           } else {
@@ -6712,7 +6719,7 @@ ${error}` : ""}`);
       if (bone.scaleX < 0) rotationIK += 180;
       if (rotationIK > 180)
         rotationIK -= 360;
-      else if (rotationIK < -180)
+      else if (rotationIK <= -180)
         rotationIK += 360;
       bone.rotation += rotationIK * mix;
       if (compress || stretch) {
@@ -6723,7 +6730,7 @@ ${error}` : ""}`);
             ty = targetY - bone.worldY;
         }
         const b = bone.bone.data.length * bone.scaleX;
-        if (b > 1e-4) {
+        if (b > MathUtils.epsilon) {
           const dd = tx * tx + ty * ty;
           if (compress && dd < b * b || stretch && dd > b * b) {
             const s = (Math.sqrt(dd) / b - 1) * mix + 1;
@@ -6733,7 +6740,7 @@ ${error}` : ""}`);
                 bone.scaleY *= s;
                 break;
               case 2 /* Volume */:
-                bone.scaleY /= s;
+                bone.scaleY /= s < 0.7 ? 0.25 + 0.642857 * s : s;
             }
           }
         }
@@ -6765,7 +6772,7 @@ ${error}` : ""}`);
       } else
         os2 = 0;
       let cwx = 0, cwy = 0, a = parent.a, b = parent.b, c = parent.c, d = parent.d;
-      const u = Math.abs(psx - psy) <= 1e-4;
+      const u = Math.abs(psx - psy) <= MathUtils.epsilon;
       if (!u || stretch) {
         child.y = 0;
         cwx = a * child.x + parent.worldX;
@@ -6780,10 +6787,10 @@ ${error}` : ""}`);
       c = pp.c;
       d = pp.d;
       let id = a * d - b * c, x = cwx - pp.worldX, y = cwy - pp.worldY;
-      id = Math.abs(id) <= 1e-4 ? 0 : 1 / id;
+      id = Math.abs(id) <= MathUtils.epsilon ? 0 : 1 / id;
       const dx = (x * d - y * b) * id - px, dy = (y * a - x * c) * id - py;
       let l1 = Math.sqrt(dx * dx + dy * dy), l2 = child.bone.data.length * csx, a1, a2;
-      if (l1 < 1e-4) {
+      if (l1 < MathUtils.epsilon) {
         _IkConstraint.apply(skeleton, parent, targetX, targetY, false, stretch, 0 /* None */, mix);
         child.rotation = 0;
         return;
@@ -6821,7 +6828,7 @@ ${error}` : ""}`);
                   parent.scaleY *= a;
                   break;
                 case 2 /* Volume */:
-                  parent.scaleY /= a;
+                  parent.scaleY /= a < 0.7 ? 0.25 + 0.642857 * a : a;
               }
             }
           } else
@@ -6883,18 +6890,49 @@ ${error}` : ""}`);
       a1 = (a1 - os) * MathUtils.radDeg + os1 - parent.rotation;
       if (a1 > 180)
         a1 -= 360;
-      else if (a1 < -180)
+      else if (a1 <= -180)
         a1 += 360;
       parent.rotation += a1 * mix;
       a2 = ((a2 + os) * MathUtils.radDeg - child.shearX) * s2 + os2 - child.rotation;
       if (a2 > 180)
         a2 -= 360;
-      else if (a2 < -180)
+      else if (a2 <= -180)
         a2 += 360;
       child.rotation += a2 * mix;
     }
   };
 
+  // spine-core/src/IkConstraintData.ts
+  var IkConstraintData = class extends ConstraintData {
+    /** The bones that are constrained by this IK constraint. */
+    bones = [];
+    _target = null;
+    /** The bone that is the IK target. */
+    set target(boneData) {
+      this._target = boneData;
+    }
+    get target() {
+      if (!this._target) throw new Error("target cannot be null.");
+      return this._target;
+    }
+    /** Determines how the {@link BonePose.scaleY} changes when {@link IkConstraintPose.compress} or
+      * {@link IkConstraintPose.stretch} set {@link BonePose.scaleX}. */
+    _scaleYMode = 0 /* None */;
+    set scaleYMode(scaleYMode) {
+      this._scaleYMode = scaleYMode;
+    }
+    get scaleYMode() {
+      if (this._scaleYMode == null) throw new Error("scaleYMode cannot be null.");
+      return this._scaleYMode;
+    }
+    constructor(name) {
+      super(name, new IkConstraintPose());
+    }
+    create(skeleton) {
+      return new IkConstraint(this, skeleton);
+    }
+  };
+
   // spine-core/src/PathConstraintPose.ts
   var PathConstraintPose = class {
     /** The position along the path. */
@@ -6968,7 +7006,6 @@ ${error}` : ""}`);
     static NONE = -1;
     static BEFORE = -2;
     static AFTER = -3;
-    static epsilon = 1e-5;
     /** The path constraint's setup pose data. */
     data;
     /** The bones that will be modified by this path constraint. */
@@ -7024,7 +7061,7 @@ ${error}` : ""}`);
           for (let i = 0, n = spacesCount - 1; i < n; ) {
             const bone = bones[i];
             const setupLength = bone.bone.data.length;
-            if (setupLength < _PathConstraint.epsilon) {
+            if (setupLength < MathUtils.epsilon) {
               if (scale) lengths[i] = 0;
               spaces[++i] = spacing;
             } else {
@@ -7047,7 +7084,7 @@ ${error}` : ""}`);
           for (let i = 0, n = spacesCount - 1; i < n; ) {
             const bone = bones[i];
             const setupLength = bone.bone.data.length;
-            if (setupLength < _PathConstraint.epsilon) {
+            if (setupLength < MathUtils.epsilon) {
               if (scale) lengths[i] = 0;
               spaces[++i] = spacing;
             } else {
@@ -8188,9 +8225,20 @@ ${error}` : ""}`);
         }
       }
       if (scaleX) {
-        const s = 1 + (this.scaleOffset - this.scaleLag * z) * mix * this.data.scaleX;
+        let s = 1 + (this.scaleOffset - this.scaleLag * z) * mix * this.data.scaleX;
         bone.a *= s;
         bone.c *= s;
+        switch (this.data.scaleYMode) {
+          case 1 /* Uniform */:
+            bone.b *= s;
+            bone.d *= s;
+            break;
+          case 2 /* Volume */:
+            s = Math.abs(s);
+            s = s >= 0.7 ? 1 / s : 4 - 3.67347 * s;
+            bone.b *= s;
+            bone.d *= s;
+        }
       }
       if (physics !== 3 /* pose */) {
         this.tx = l * bone.a;
@@ -8249,6 +8297,16 @@ ${error}` : ""}`);
     gravityGlobal = false;
     /** True when this constraint's mix is controlled by global slider timelines. */
     mixGlobal = false;
+    /** Determines how the {@link BonePose.scaleY} changes when {@link PhysicsConstraintData.scaleX} sets
+     * {@link BonePose.scaleX}. */
+    _scaleYMode = 0 /* None */;
+    get scaleYMode() {
+      return this._scaleYMode;
+    }
+    set scaleYMode(scaleYMode) {
+      if (scaleYMode == null) throw new Error("scaleYMode cannot be null.");
+      this._scaleYMode = scaleYMode;
+    }
     constructor(name) {
       super(name, new PhysicsConstraintPose());
     }
@@ -9301,7 +9359,17 @@ ${error}` : ""}`);
             if ((flags & 2) !== 0) data.x = input.readFloat();
             if ((flags & 4) !== 0) data.y = input.readFloat();
             if ((flags & 8) !== 0) data.rotate = input.readFloat();
-            if ((flags & 16) !== 0) data.scaleX = input.readFloat();
+            if ((flags & 16) !== 0) {
+              let scaleX = input.readFloat();
+              if (scaleX < -2) {
+                data.scaleYMode = 2 /* Volume */;
+                scaleX = -2 - scaleX;
+              } else if (scaleX < 0) {
+                data.scaleYMode = 1 /* Uniform */;
+                scaleX = -1 - scaleX;
+              }
+              data.scaleX = scaleX;
+            }
             if ((flags & 32) !== 0) data.shearX = input.readFloat();
             data.limit = ((flags & 64) !== 0 ? input.readFloat() : 5e3) * scale;
             data.step = 1 / input.readUnsignedByte();
@@ -11724,6 +11792,8 @@ ${error}` : ""}`);
               data.y = getValue(constraintMap, "y", 0);
               data.rotate = getValue(constraintMap, "rotate", 0);
               data.scaleX = getValue(constraintMap, "scaleX", 0);
+              const scaleY = getValue(constraintMap, "scaleY", null);
+              if (scaleY != null) data.scaleYMode = Utils.enumValue(ScaleYMode, scaleY);
               data.shearX = getValue(constraintMap, "shearX", 0);
               data.limit = getValue(constraintMap, "limit", 5e3) * scale;
               data.step = 1 / getValue(constraintMap, "fps", 60);