@esotericsoftware/spine-webgl 4.0.11 → 4.1.0

package/dist/iife/spine-webgl.js

@@ -26,6 +26,7 @@ var spine = (() => {
     BoneData: () => BoneData,
     BoundingBoxAttachment: () => BoundingBoxAttachment,
     CURRENT: () => CURRENT,
+    CameraController: () => CameraController,
     ClippingAttachment: () => ClippingAttachment,
     Color: () => Color,
     Color2Attribute: () => Color2Attribute,
@@ -109,6 +110,7 @@ var spine = (() => {
     ScaleXTimeline: () => ScaleXTimeline,
     ScaleYTimeline: () => ScaleYTimeline,
     SceneRenderer: () => SceneRenderer,
+    SequenceTimeline: () => SequenceTimeline,
     Shader: () => Shader,
     ShapeRenderer: () => ShapeRenderer,
     ShapeType: () => ShapeType,
@@ -553,7 +555,7 @@ var spine = (() => {
       super(name);
       this.id = _VertexAttachment.nextID++;
       this.worldVerticesLength = 0;
-      this.deformAttachment = this;
+      this.timelineAttahment = this;
     }
     computeWorldVertices(slot, start, count, worldVertices, offset, stride) {
       count = offset + (count >> 1) * stride;
@@ -625,12 +627,75 @@ var spine = (() => {
       } else
         attachment.vertices = null;
       attachment.worldVerticesLength = this.worldVerticesLength;
-      attachment.deformAttachment = this.deformAttachment;
+      attachment.timelineAttahment = this.timelineAttahment;
     }
   };
   var VertexAttachment = _VertexAttachment;
   VertexAttachment.nextID = 0;
 
+  // spine-core/src/attachments/Sequence.ts
+  var _Sequence = class {
+    constructor(count) {
+      this.id = _Sequence.nextID();
+      this.start = 0;
+      this.digits = 0;
+      this.setupIndex = 0;
+      this.regions = new Array(count);
+    }
+    copy() {
+      let copy = new _Sequence(this.regions.length);
+      Utils.arrayCopy(this.regions, 0, copy.regions, 0, this.regions.length);
+      copy.start = this.start;
+      copy.digits = this.digits;
+      copy.setupIndex = this.setupIndex;
+      return copy;
+    }
+    apply(slot, attachment) {
+      let index = slot.sequenceIndex;
+      if (index == -1)
+        index = this.setupIndex;
+      if (index >= this.regions.length)
+        index = this.regions.length - 1;
+      let region = this.regions[index];
+      if (attachment.region != region) {
+        attachment.region = region;
+        attachment.updateRegion();
+      }
+    }
+    getPath(basePath, index) {
+      let result = basePath;
+      let frame = (this.start + index).toString();
+      for (let i = this.digits - frame.length; i > 0; i--)
+        result += "0";
+      result += frame;
+      return result;
+    }
+    static nextID() {
+      return _Sequence._nextID++;
+    }
+  };
+  var Sequence = _Sequence;
+  Sequence._nextID = 0;
+  var SequenceMode;
+  (function(SequenceMode2) {
+    SequenceMode2[SequenceMode2["hold"] = 0] = "hold";
+    SequenceMode2[SequenceMode2["once"] = 1] = "once";
+    SequenceMode2[SequenceMode2["loop"] = 2] = "loop";
+    SequenceMode2[SequenceMode2["pingpong"] = 3] = "pingpong";
+    SequenceMode2[SequenceMode2["onceReverse"] = 4] = "onceReverse";
+    SequenceMode2[SequenceMode2["loopReverse"] = 5] = "loopReverse";
+    SequenceMode2[SequenceMode2["pingpongReverse"] = 6] = "pingpongReverse";
+  })(SequenceMode || (SequenceMode = {}));
+  var SequenceModeValues = [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6
+  ];
+
   // spine-core/src/Animation.ts
   var Animation = class {
     constructor(name, timelines, duration) {
@@ -698,7 +763,8 @@ var spine = (() => {
     transformConstraint: 15,
     pathConstraintPosition: 16,
     pathConstraintSpacing: 17,
-    pathConstraintMix: 18
+    pathConstraintMix: 18,
+    sequence: 19
   };
   var Timeline = class {
     constructor(frameCount, propertyIds) {
@@ -1856,7 +1922,7 @@ var spine = (() => {
       if (!slot.bone.active)
         return;
       let slotAttachment = slot.getAttachment();
-      if (!(slotAttachment instanceof VertexAttachment) || slotAttachment.deformAttachment != this.attachment)
+      if (!(slotAttachment instanceof VertexAttachment) || slotAttachment.timelineAttahment != this.attachment)
         return;
       let deform = slot.deform;
       if (deform.length == 0)
@@ -1865,7 +1931,6 @@ var spine = (() => {
       let vertexCount = vertices[0].length;
       let frames = this.frames;
       if (time < frames[0]) {
-        let vertexAttachment = slotAttachment;
         switch (blend) {
           case 0:
             deform.length = 0;
@@ -1876,6 +1941,7 @@ var spine = (() => {
               return;
             }
             deform.length = vertexCount;
+            let vertexAttachment = slotAttachment;
             if (!vertexAttachment.bones) {
               let setupVertices = vertexAttachment.vertices;
               for (var i = 0; i < vertexCount; i++)
@@ -2400,6 +2466,81 @@ var spine = (() => {
       }
     }
   };
+  var _SequenceTimeline = class extends Timeline {
+    constructor(frameCount, slotIndex, attachment) {
+      super(frameCount, [
+        Property.sequence + "|" + slotIndex + "|" + attachment.sequence.id
+      ]);
+      this.slotIndex = slotIndex;
+      this.attachment = attachment;
+    }
+    getFrameEntries() {
+      return _SequenceTimeline.ENTRIES;
+    }
+    getSlotIndex() {
+      return this.slotIndex;
+    }
+    getAttachment() {
+      return this.attachment;
+    }
+    setFrame(frame, time, mode, index, delay) {
+      let frames = this.frames;
+      frame *= _SequenceTimeline.ENTRIES;
+      frames[frame] = time;
+      frames[frame + _SequenceTimeline.MODE] = mode | index << 4;
+      frames[frame + _SequenceTimeline.DELAY] = delay;
+    }
+    apply(skeleton, lastTime, time, events, alpha, blend, direction) {
+      let slot = skeleton.slots[this.slotIndex];
+      if (!slot.bone.active)
+        return;
+      let slotAttachment = slot.attachment;
+      let attachment = this.attachment;
+      if (slotAttachment != attachment) {
+        if (!(slotAttachment instanceof VertexAttachment) || slotAttachment.timelineAttahment != attachment)
+          return;
+      }
+      let frames = this.frames;
+      if (time < frames[0]) {
+        if (blend == 0 || blend == 1)
+          slot.sequenceIndex = -1;
+        return;
+      }
+      let i = Timeline.search(frames, time, _SequenceTimeline.ENTRIES);
+      let before = frames[i];
+      let modeAndIndex = frames[i + _SequenceTimeline.MODE];
+      let delay = frames[i + _SequenceTimeline.DELAY];
+      let index = modeAndIndex >> 4, count = this.attachment.sequence.regions.length;
+      let mode = SequenceModeValues[modeAndIndex & 15];
+      if (mode != SequenceMode.hold) {
+        index += (time - before) / delay + 1e-5 | 0;
+        switch (mode) {
+          case SequenceMode.once:
+            index = Math.min(count - 1, index);
+            break;
+          case SequenceMode.loop:
+            index %= count;
+            break;
+          case SequenceMode.pingpong:
+            let n = (count << 1) - 2;
+            index %= n;
+            if (index >= count)
+              index = n - index;
+            break;
+          case SequenceMode.onceReverse:
+            index = Math.max(count - 1 - index, 0);
+            break;
+          case SequenceMode.loopReverse:
+            index = count - 1 - index % count;
+        }
+      }
+      slot.sequenceIndex = index;
+    }
+  };
+  var SequenceTimeline = _SequenceTimeline;
+  SequenceTimeline.ENTRIES = 3;
+  SequenceTimeline.MODE = 1;
+  SequenceTimeline.DELAY = 2;
 
   // spine-core/src/AnimationState.ts
   var AnimationState = class {
@@ -3493,7 +3634,7 @@ var spine = (() => {
       this.color = new Color(1, 1, 1, 1);
       this.tempColor = new Color(0, 0, 0, 0);
     }
-    updateUVs() {
+    updateRegion() {
       let regionUVs = this.regionUVs;
       if (!this.uvs || this.uvs.length != regionUVs.length)
         this.uvs = Utils.newFloatArray(regionUVs.length);
@@ -3581,6 +3722,7 @@ var spine = (() => {
       copy.triangles = new Array(this.triangles.length);
       Utils.arrayCopy(this.triangles, 0, copy.triangles, 0, this.triangles.length);
       copy.hullLength = this.hullLength;
+      copy.sequence = this.sequence.copy();
       if (this.edges) {
         copy.edges = new Array(this.edges.length);
         Utils.arrayCopy(this.edges, 0, copy.edges, 0, this.edges.length);
@@ -3589,14 +3731,20 @@ var spine = (() => {
       copy.height = this.height;
       return copy;
     }
+    computeWorldVertices(slot, start, count, worldVertices, offset, stride) {
+      if (this.sequence != null)
+        this.sequence.apply(slot, this);
+      super.computeWorldVertices(slot, start, count, worldVertices, offset, stride);
+    }
     newLinkedMesh() {
       let copy = new MeshAttachment(this.name);
       copy.region = this.region;
       copy.path = this.path;
       copy.color.setFromColor(this.color);
-      copy.deformAttachment = this.deformAttachment;
+      copy.timelineAttahment = this.timelineAttahment;
       copy.setParentMesh(this.parentMesh ? this.parentMesh : this);
-      copy.updateUVs();
+      if (copy.region != null)
+        copy.updateRegion();
       return copy;
     }
   };
@@ -3664,7 +3812,7 @@ var spine = (() => {
       this.uvs = Utils.newFloatArray(8);
       this.tempColor = new Color(1, 1, 1, 1);
     }
-    updateOffset() {
+    updateRegion() {
       let region = this.region;
       let regionScaleX = this.width / this.region.originalWidth * this.scaleX;
       let regionScaleY = this.height / this.region.originalHeight * this.scaleY;
@@ -3693,9 +3841,6 @@ var spine = (() => {
       offset[5] = localY2Cos + localX2Sin;
       offset[6] = localX2Cos - localYSin;
       offset[7] = localYCos + localX2Sin;
-    }
-    setRegion(region) {
-      this.region = region;
       let uvs = this.uvs;
       if (region.degrees == 90) {
         uvs[2] = region.u;
@@ -3717,7 +3862,10 @@ var spine = (() => {
         uvs[7] = region.v2;
       }
     }
-    computeWorldVertices(bone, worldVertices, offset, stride) {
+    computeWorldVertices(slot, worldVertices, offset, stride) {
+      if (this.sequence != null)
+        this.sequence.apply(slot, this);
+      let bone = slot.bone;
       let vertexOffset = this.offset;
       let x = bone.worldX, y = bone.worldY;
       let a = bone.a, b = bone.b, c = bone.c, d = bone.d;
@@ -3757,6 +3905,7 @@ var spine = (() => {
       Utils.arrayCopy(this.uvs, 0, copy.uvs, 0, 8);
       Utils.arrayCopy(this.offset, 0, copy.offset, 0, 8);
       copy.color.setFromColor(this.color);
+      copy.sequence = this.sequence.copy();
       return copy;
     }
   };
@@ -3799,22 +3948,40 @@ var spine = (() => {
     constructor(atlas) {
       this.atlas = atlas;
     }
-    newRegionAttachment(skin, name, path) {
-      let region = this.atlas.findRegion(path);
-      if (!region)
-        throw new Error("Region not found in atlas: " + path + " (region attachment: " + name + ")");
-      region.renderObject = region;
+    loadSequence(name, basePath, sequence) {
+      let regions = sequence.regions;
+      for (let i = 0, n = regions.length; i < n; i++) {
+        let path = sequence.getPath(basePath, i);
+        regions[i] = this.atlas.findRegion(path);
+        regions[i].renderObject = regions[i];
+        if (regions[i] == null)
+          throw new Error("Region not found in atlas: " + path + " (sequence: " + name + ")");
+      }
+    }
+    newRegionAttachment(skin, name, path, sequence) {
       let attachment = new RegionAttachment(name);
-      attachment.setRegion(region);
+      if (sequence != null) {
+        this.loadSequence(name, path, sequence);
+      } else {
+        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;
     }
-    newMeshAttachment(skin, name, path) {
-      let region = this.atlas.findRegion(path);
-      if (!region)
-        throw new Error("Region not found in atlas: " + path + " (mesh attachment: " + name + ")");
-      region.renderObject = region;
+    newMeshAttachment(skin, name, path, sequence) {
       let attachment = new MeshAttachment(name);
-      attachment.region = region;
+      if (sequence != null) {
+        this.loadSequence(name, path, sequence);
+      } else {
+        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;
     }
     newBoundingBoxAttachment(skin, name) {
@@ -4291,14 +4458,14 @@ var spine = (() => {
         return dataUri.substr(dataUri.indexOf(",") + 1);
       }
     }
-    base64ToArrayBuffer(base64) {
+    base64ToUint8Array(base64) {
       var binary_string = window.atob(base64);
       var len = binary_string.length;
       var bytes = new Uint8Array(len);
       for (var i = 0; i < len; i++) {
         bytes[i] = binary_string.charCodeAt(i);
       }
-      return bytes.buffer;
+      return bytes;
     }
     dataUriToUint8Array(dataUri) {
       if (!dataUri.startsWith("data:")) {
@@ -4308,7 +4475,7 @@ var spine = (() => {
       if (base64Idx == -1)
         throw new Error("Not a binary data URI.");
       base64Idx += "base64,".length;
-      return this.base64ToArrayBuffer(dataUri.substr(base64Idx));
+      return this.base64ToUint8Array(dataUri.substr(base64Idx));
     }
     downloadText(url, success, error) {
       if (this.start(url, success, error))
@@ -5121,17 +5288,11 @@ var spine = (() => {
     setAttachment(attachment) {
       if (this.attachment == attachment)
         return;
-      if (!(attachment instanceof VertexAttachment) || !(this.attachment instanceof VertexAttachment) || attachment.deformAttachment != this.attachment.deformAttachment) {
+      if (!(attachment instanceof VertexAttachment) || !(this.attachment instanceof VertexAttachment) || attachment.timelineAttahment != this.attachment.timelineAttahment) {
         this.deform.length = 0;
       }
       this.attachment = attachment;
-      this.attachmentTime = this.bone.skeleton.time;
-    }
-    setAttachmentTime(time) {
-      this.attachmentTime = this.bone.skeleton.time - time;
-    }
-    getAttachmentTime() {
-      return this.bone.skeleton.time - this.attachmentTime;
+      this.sequenceIndex = -1;
     }
     setToSetupPose() {
       this.color.setFromColor(this.data.color);
@@ -5357,7 +5518,6 @@ var spine = (() => {
   var Skeleton = class {
     constructor(data) {
       this._updateCache = new Array();
-      this.time = 0;
       this.scaleX = 1;
       this.scaleY = 1;
       this.x = 0;
@@ -5791,7 +5951,7 @@ var spine = (() => {
         if (attachment instanceof RegionAttachment) {
           verticesLength = 8;
           vertices = Utils.setArraySize(temp, verticesLength, 0);
-          attachment.computeWorldVertices(slot.bone, vertices, 0, 2);
+          attachment.computeWorldVertices(slot, vertices, 0, 2);
         } else if (attachment instanceof MeshAttachment) {
           let mesh = attachment;
           verticesLength = mesh.worldVerticesLength;
@@ -5811,9 +5971,6 @@ var spine = (() => {
       offset.set(minX, minY);
       size.set(maxX - minX, maxY - minY);
     }
-    update(delta) {
-      this.time += delta;
-    }
   };
 
   // spine-core/src/SkeletonData.ts
@@ -6265,9 +6422,10 @@ var spine = (() => {
         let linkedMesh = this.linkedMeshes[i];
         let skin = !linkedMesh.skin ? skeletonData.defaultSkin : skeletonData.findSkin(linkedMesh.skin);
         let parent = skin.getAttachment(linkedMesh.slotIndex, linkedMesh.parent);
-        linkedMesh.mesh.deformAttachment = linkedMesh.inheritDeform ? parent : linkedMesh.mesh;
+        linkedMesh.mesh.timelineAttahment = linkedMesh.inheritTimeline ? parent : linkedMesh.mesh;
         linkedMesh.mesh.setParentMesh(parent);
-        linkedMesh.mesh.updateUVs();
+        if (linkedMesh.mesh.region != null)
+          linkedMesh.mesh.updateRegion();
       }
       this.linkedMeshes.length = 0;
       n = input.readInt(true);
@@ -6336,9 +6494,10 @@ var spine = (() => {
           let width = input.readFloat();
           let height = input.readFloat();
           let color = input.readInt32();
+          let sequence = this.readSequence(input);
           if (!path)
             path = name;
-          let region = this.attachmentLoader.newRegionAttachment(skin, name, path);
+          let region = this.attachmentLoader.newRegionAttachment(skin, name, path, sequence);
           if (!region)
             return null;
           region.path = path;
@@ -6350,7 +6509,9 @@ var spine = (() => {
           region.width = width * scale;
           region.height = height * scale;
           Color.rgba8888ToColor(region.color, color);
-          region.updateOffset();
+          region.sequence = sequence;
+          if (sequence == null)
+            region.updateRegion();
           return region;
         }
         case AttachmentType.BoundingBox: {
@@ -6375,6 +6536,7 @@ var spine = (() => {
           let triangles = this.readShortArray(input);
           let vertices = this.readVertices(input, vertexCount);
           let hullLength = input.readInt(true);
+          let sequence = this.readSequence(input);
           let edges = null;
           let width = 0, height = 0;
           if (nonessential) {
@@ -6384,7 +6546,7 @@ var spine = (() => {
           }
           if (!path)
             path = name;
-          let mesh = this.attachmentLoader.newMeshAttachment(skin, name, path);
+          let mesh = this.attachmentLoader.newMeshAttachment(skin, name, path, sequence);
           if (!mesh)
             return null;
           mesh.path = path;
@@ -6394,8 +6556,10 @@ var spine = (() => {
           mesh.worldVerticesLength = vertexCount << 1;
           mesh.triangles = triangles;
           mesh.regionUVs = uvs;
-          mesh.updateUVs();
+          if (sequence == null)
+            mesh.updateRegion();
           mesh.hullLength = hullLength << 1;
+          mesh.sequence = sequence;
           if (nonessential) {
             mesh.edges = edges;
             mesh.width = width * scale;
@@ -6408,7 +6572,8 @@ var spine = (() => {
           let color = input.readInt32();
           let skinName = input.readStringRef();
           let parent = input.readStringRef();
-          let inheritDeform = input.readBoolean();
+          let inheritTimelines = input.readBoolean();
+          let sequence = this.readSequence(input);
           let width = 0, height = 0;
           if (nonessential) {
             width = input.readFloat();
@@ -6416,16 +6581,17 @@ var spine = (() => {
           }
           if (!path)
             path = name;
-          let mesh = this.attachmentLoader.newMeshAttachment(skin, name, path);
+          let mesh = this.attachmentLoader.newMeshAttachment(skin, name, path, sequence);
           if (!mesh)
             return null;
           mesh.path = path;
           Color.rgba8888ToColor(mesh.color, color);
+          mesh.sequence = sequence;
           if (nonessential) {
             mesh.width = width * scale;
             mesh.height = height * scale;
           }
-          this.linkedMeshes.push(new LinkedMesh(mesh, skinName, slotIndex, parent, inheritDeform));
+          this.linkedMeshes.push(new LinkedMesh(mesh, skinName, slotIndex, parent, inheritTimelines));
           return mesh;
         }
         case AttachmentType.Path: {
@@ -6484,6 +6650,15 @@ 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);
+      sequence.setupIndex = input.readInt(true);
+      return sequence;
+    }
     readVertices(input, vertexCount) {
       let scale = this.scale;
       let verticesLength = vertexCount << 1;
@@ -6726,7 +6901,6 @@ var spine = (() => {
                 a = a2;
               }
               timelines.push(timeline);
-              break;
             }
           }
         }
@@ -6866,49 +7040,66 @@ var spine = (() => {
           for (let iii = 0, nnn = input.readInt(true); iii < nnn; iii++) {
             let attachmentName = input.readStringRef();
             let attachment = skin.getAttachment(slotIndex, attachmentName);
-            let weighted = attachment.bones;
-            let vertices = attachment.vertices;
-            let deformLength = weighted ? vertices.length / 3 * 2 : vertices.length;
+            let timelineType = input.readByte();
             let frameCount = input.readInt(true);
             let frameLast = frameCount - 1;
-            let bezierCount = input.readInt(true);
-            let timeline = new DeformTimeline(frameCount, bezierCount, slotIndex, attachment);
-            let time = input.readFloat();
-            for (let frame = 0, bezier = 0; ; frame++) {
-              let deform;
-              let end = input.readInt(true);
-              if (end == 0)
-                deform = weighted ? Utils.newFloatArray(deformLength) : vertices;
-              else {
-                deform = Utils.newFloatArray(deformLength);
-                let start = input.readInt(true);
-                end += start;
-                if (scale == 1) {
-                  for (let v = start; v < end; v++)
-                    deform[v] = input.readFloat();
-                } else {
-                  for (let v = start; v < end; v++)
-                    deform[v] = input.readFloat() * scale;
-                }
-                if (!weighted) {
-                  for (let v = 0, vn = deform.length; v < vn; v++)
-                    deform[v] += vertices[v];
+            switch (timelineType) {
+              case ATTACHMENT_DEFORM: {
+                let vertexAttachment = attachment;
+                let weighted = vertexAttachment.bones;
+                let vertices = vertexAttachment.vertices;
+                let deformLength = weighted ? vertices.length / 3 * 2 : vertices.length;
+                let bezierCount = input.readInt(true);
+                let timeline = new DeformTimeline(frameCount, bezierCount, slotIndex, vertexAttachment);
+                let time = input.readFloat();
+                for (let frame = 0, bezier = 0; ; frame++) {
+                  let deform;
+                  let end = input.readInt(true);
+                  if (end == 0)
+                    deform = weighted ? Utils.newFloatArray(deformLength) : vertices;
+                  else {
+                    deform = Utils.newFloatArray(deformLength);
+                    let start = input.readInt(true);
+                    end += start;
+                    if (scale == 1) {
+                      for (let v = start; v < end; v++)
+                        deform[v] = input.readFloat();
+                    } else {
+                      for (let v = start; v < end; v++)
+                        deform[v] = input.readFloat() * scale;
+                    }
+                    if (!weighted) {
+                      for (let v = 0, vn = deform.length; v < vn; v++)
+                        deform[v] += vertices[v];
+                    }
+                  }
+                  timeline.setFrame(frame, time, deform);
+                  if (frame == frameLast)
+                    break;
+                  let time2 = input.readFloat();
+                  switch (input.readByte()) {
+                    case CURVE_STEPPED:
+                      timeline.setStepped(frame);
+                      break;
+                    case CURVE_BEZIER:
+                      setBezier(input, timeline, bezier++, frame, 0, time, time2, 0, 1, 1);
+                  }
+                  time = time2;
                 }
+                timelines.push(timeline);
+                break;
               }
-              timeline.setFrame(frame, time, deform);
-              if (frame == frameLast)
+              case ATTACHMENT_SEQUENCE: {
+                let timeline = new SequenceTimeline(frameCount, slotIndex, attachment);
+                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());
+                }
+                timelines.push(timeline);
                 break;
-              let time2 = input.readFloat();
-              switch (input.readByte()) {
-                case CURVE_STEPPED:
-                  timeline.setStepped(frame);
-                  break;
-                case CURVE_BEZIER:
-                  setBezier(input, timeline, bezier++, frame, 0, time, time2, 0, 1, 1);
               }
-              time = time2;
             }
-            timelines.push(timeline);
           }
         }
       }
@@ -7055,7 +7246,7 @@ var spine = (() => {
       this.skin = skin;
       this.slotIndex = slotIndex;
       this.parent = parent;
-      this.inheritDeform = inheritDeform;
+      this.inheritTimeline = inheritDeform;
     }
   };
   var Vertices = class {
@@ -7133,6 +7324,8 @@ var spine = (() => {
   var SLOT_RGBA2 = 3;
   var SLOT_RGB2 = 4;
   var SLOT_ALPHA = 5;
+  var ATTACHMENT_DEFORM = 0;
+  var ATTACHMENT_SEQUENCE = 1;
   var PATH_POSITION = 0;
   var PATH_SPACING = 1;
   var PATH_MIX = 2;
@@ -7968,9 +8161,10 @@ var spine = (() => {
         let linkedMesh = this.linkedMeshes[i];
         let skin = !linkedMesh.skin ? skeletonData.defaultSkin : skeletonData.findSkin(linkedMesh.skin);
         let parent = skin.getAttachment(linkedMesh.slotIndex, linkedMesh.parent);
-        linkedMesh.mesh.deformAttachment = linkedMesh.inheritDeform ? parent : linkedMesh.mesh;
+        linkedMesh.mesh.timelineAttahment = linkedMesh.inheritTimeline ? parent : linkedMesh.mesh;
         linkedMesh.mesh.setParentMesh(parent);
-        linkedMesh.mesh.updateUVs();
+        if (linkedMesh.mesh.region != null)
+          linkedMesh.mesh.updateRegion();
       }
       this.linkedMeshes.length = 0;
       if (root.events) {
@@ -8002,7 +8196,8 @@ var spine = (() => {
       switch (getValue(map, "type", "region")) {
         case "region": {
           let path = getValue(map, "path", name);
-          let region = this.attachmentLoader.newRegionAttachment(skin, name, path);
+          let sequence = this.readSequence(getValue(map, "sequence", null));
+          let region = this.attachmentLoader.newRegionAttachment(skin, name, path, sequence);
           if (!region)
             return null;
           region.path = path;
@@ -8013,10 +8208,12 @@ var spine = (() => {
           region.rotation = getValue(map, "rotation", 0);
           region.width = map.width * scale;
           region.height = map.height * scale;
+          region.sequence = sequence;
           let color = getValue(map, "color", null);
           if (color)
             region.color.setFromString(color);
-          region.updateOffset();
+          if (region.region != null)
+            region.updateRegion();
           return region;
         }
         case "boundingbox": {
@@ -8032,7 +8229,8 @@ var spine = (() => {
         case "mesh":
         case "linkedmesh": {
           let path = getValue(map, "path", name);
-          let mesh = this.attachmentLoader.newMeshAttachment(skin, name, path);
+          let sequence = this.readSequence(getValue(map, "sequence", null));
+          let mesh = this.attachmentLoader.newMeshAttachment(skin, name, path, sequence);
           if (!mesh)
             return null;
           mesh.path = path;
@@ -8041,16 +8239,18 @@ var spine = (() => {
             mesh.color.setFromString(color);
           mesh.width = getValue(map, "width", 0) * scale;
           mesh.height = getValue(map, "height", 0) * scale;
+          mesh.sequence = sequence;
           let parent = getValue(map, "parent", null);
           if (parent) {
-            this.linkedMeshes.push(new LinkedMesh2(mesh, getValue(map, "skin", null), slotIndex, parent, getValue(map, "deform", true)));
+            this.linkedMeshes.push(new LinkedMesh2(mesh, getValue(map, "skin", null), slotIndex, parent, getValue(map, "timelines", true)));
             return mesh;
           }
           let uvs = map.uvs;
           this.readVertices(map, mesh, uvs.length);
           mesh.triangles = map.triangles;
           mesh.regionUVs = uvs;
-          mesh.updateUVs();
+          if (mesh.region != null)
+            mesh.updateRegion();
           mesh.edges = getValue(map, "edges", null);
           mesh.hullLength = getValue(map, "hull", 0) * 2;
           return mesh;
@@ -8101,6 +8301,15 @@ var spine = (() => {
       }
       return null;
     }
+    readSequence(map) {
+      if (map == null)
+        return null;
+      let sequence = new Sequence(getValue(map, "count", 0));
+      sequence.start = getValue(map, "start", 1);
+      sequence.digits = getValue(map, "digits", 0);
+      sequence.setupIndex = getValue(map, "setup", 0);
+      return sequence;
+    }
     readVertices(map, attachment, verticesLength) {
       let scale = this.scale;
       attachment.worldVerticesLength = verticesLength;
@@ -8145,7 +8354,7 @@ var spine = (() => {
               let timeline = new AttachmentTimeline(frames, slotIndex);
               for (let frame = 0; frame < frames; frame++) {
                 let keyMap = timelineMap[frame];
-                timeline.setFrame(frame, getValue(keyMap, "time", 0), keyMap.name);
+                timeline.setFrame(frame, getValue(keyMap, "time", 0), getValue(keyMap, "name", null));
               }
               timelines.push(timeline);
             } else if (timelineName == "rgba") {
@@ -8447,56 +8656,74 @@ var spine = (() => {
           }
         }
       }
-      if (map.deform) {
-        for (let deformName in map.deform) {
-          let deformMap = map.deform[deformName];
-          let skin = skeletonData.findSkin(deformName);
-          for (let slotName in deformMap) {
-            let slotMap = deformMap[slotName];
-            let slotIndex = skeletonData.findSlot(slotName).index;
-            for (let timelineName in slotMap) {
-              let timelineMap = slotMap[timelineName];
-              let keyMap = timelineMap[0];
-              if (!keyMap)
-                continue;
-              let attachment = skin.getAttachment(slotIndex, timelineName);
-              let weighted = attachment.bones;
-              let vertices = attachment.vertices;
-              let deformLength = weighted ? vertices.length / 3 * 2 : vertices.length;
-              let timeline = new DeformTimeline(timelineMap.length, timelineMap.length, slotIndex, attachment);
-              let time = getValue(keyMap, "time", 0);
-              for (let frame = 0, bezier = 0; ; frame++) {
-                let deform;
-                let verticesValue = getValue(keyMap, "vertices", null);
-                if (!verticesValue)
-                  deform = weighted ? Utils.newFloatArray(deformLength) : vertices;
-                else {
-                  deform = Utils.newFloatArray(deformLength);
-                  let start = getValue(keyMap, "offset", 0);
-                  Utils.arrayCopy(verticesValue, 0, deform, start, verticesValue.length);
-                  if (scale != 1) {
-                    for (let i = start, n = i + verticesValue.length; i < n; i++)
-                      deform[i] *= scale;
+      if (map.attachments) {
+        for (let attachmentsName in map.attachments) {
+          let attachmentsMap = map.attachments[attachmentsName];
+          let skin = skeletonData.findSkin(attachmentsName);
+          for (let slotMapName in attachmentsMap) {
+            let slotMap = attachmentsMap[slotMapName];
+            let slotIndex = skeletonData.findSlot(slotMapName).index;
+            for (let attachmentMapName in slotMap) {
+              let attachmentMap = slotMap[attachmentMapName];
+              let attachment = skin.getAttachment(slotIndex, attachmentMapName);
+              for (let timelineMapName in attachmentMap) {
+                let timelineMap = attachmentMap[timelineMapName];
+                let keyMap = timelineMap[0];
+                if (!keyMap)
+                  continue;
+                if (timelineMapName == "deform") {
+                  let weighted = attachment.bones;
+                  let vertices = attachment.vertices;
+                  let deformLength = weighted ? vertices.length / 3 * 2 : vertices.length;
+                  let timeline = new DeformTimeline(timelineMap.length, timelineMap.length, slotIndex, attachment);
+                  let time = getValue(keyMap, "time", 0);
+                  for (let frame = 0, bezier = 0; ; frame++) {
+                    let deform;
+                    let verticesValue = getValue(keyMap, "vertices", null);
+                    if (!verticesValue)
+                      deform = weighted ? Utils.newFloatArray(deformLength) : vertices;
+                    else {
+                      deform = Utils.newFloatArray(deformLength);
+                      let start = getValue(keyMap, "offset", 0);
+                      Utils.arrayCopy(verticesValue, 0, deform, start, verticesValue.length);
+                      if (scale != 1) {
+                        for (let i = start, n = i + verticesValue.length; i < n; i++)
+                          deform[i] *= scale;
+                      }
+                      if (!weighted) {
+                        for (let i = 0; i < deformLength; i++)
+                          deform[i] += vertices[i];
+                      }
+                    }
+                    timeline.setFrame(frame, time, deform);
+                    let nextMap = timelineMap[frame + 1];
+                    if (!nextMap) {
+                      timeline.shrink(bezier);
+                      break;
+                    }
+                    let time2 = getValue(nextMap, "time", 0);
+                    let curve = keyMap.curve;
+                    if (curve)
+                      bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, 0, 1, 1);
+                    time = time2;
+                    keyMap = nextMap;
                   }
-                  if (!weighted) {
-                    for (let i = 0; i < deformLength; i++)
-                      deform[i] += vertices[i];
+                  timelines.push(timeline);
+                } else if (timelineMapName == "sequence") {
+                  let timeline = new SequenceTimeline(timelineMap.length, slotIndex, attachment);
+                  let lastDelay = 0;
+                  for (let frame = 0; frame < timelineMap.length; frame++) {
+                    let delay = getValue(keyMap, "delay", lastDelay);
+                    let time = getValue(keyMap, "time", 0);
+                    let mode = SequenceMode[getValue(keyMap, "mode", "hold")];
+                    let index = getValue(keyMap, "index", 0);
+                    timeline.setFrame(frame, time, mode, index, delay);
+                    lastDelay = delay;
+                    keyMap = timelineMap[frame + 1];
                   }
+                  timelines.push(timeline);
                 }
-                timeline.setFrame(frame, time, deform);
-                let nextMap = timelineMap[frame + 1];
-                if (!nextMap) {
-                  timeline.shrink(bezier);
-                  break;
-                }
-                let time2 = getValue(nextMap, "time", 0);
-                let curve = keyMap.curve;
-                if (curve)
-                  bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, 0, 1, 1);
-                time = time2;
-                keyMap = nextMap;
               }
-              timelines.push(timeline);
             }
           }
         }
@@ -8560,7 +8787,7 @@ var spine = (() => {
       this.skin = skin;
       this.slotIndex = slotIndex;
       this.parent = parent;
-      this.inheritDeform = inheritDeform;
+      this.inheritTimeline = inheritDeform;
     }
   };
   function readTimeline12(keys, timeline, defaultValue, scale) {
@@ -9254,14 +9481,13 @@ var spine = (() => {
   // spine-webgl/src/Input.ts
   var Input = class {
     constructor(element) {
-      this.lastX = 0;
-      this.lastY = 0;
+      this.mouseX = 0;
+      this.mouseY = 0;
       this.buttonDown = false;
-      this.currTouch = null;
+      this.touch0 = null;
+      this.touch1 = null;
+      this.initialPinchDistance = 0;
       this.listeners = new Array();
-      this.touchesPool = new Pool(() => {
-        return new Touch(0, 0, 0);
-      });
       this.element = element;
       this.setupCallbacks(element);
     }
@@ -9269,15 +9495,14 @@ var spine = (() => {
       let mouseDown = (ev) => {
         if (ev instanceof MouseEvent) {
           let rect = element.getBoundingClientRect();
-          let x = ev.clientX - rect.left;
-          let y = ev.clientY - rect.top;
-          let listeners = this.listeners;
-          for (let i = 0; i < listeners.length; i++)
-            if (listeners[i].down)
-              listeners[i].down(x, y);
-          this.lastX = x;
-          this.lastY = y;
+          this.mouseX = ev.clientX - rect.left;
+          ;
+          this.mouseY = ev.clientY - rect.top;
           this.buttonDown = true;
+          this.listeners.map((listener) => {
+            if (listener.down)
+              listener.down(this.mouseX, this.mouseY);
+          });
           document.addEventListener("mousemove", mouseMove);
           document.addEventListener("mouseup", mouseUp);
         }
@@ -9285,138 +9510,154 @@ var spine = (() => {
       let mouseMove = (ev) => {
         if (ev instanceof MouseEvent) {
           let rect = element.getBoundingClientRect();
-          let x = ev.clientX - rect.left;
-          let y = ev.clientY - rect.top;
-          let listeners = this.listeners;
-          for (let i = 0; i < listeners.length; i++) {
+          this.mouseX = ev.clientX - rect.left;
+          ;
+          this.mouseY = ev.clientY - rect.top;
+          this.listeners.map((listener) => {
             if (this.buttonDown) {
-              if (listeners[i].dragged)
-                listeners[i].dragged(x, y);
+              if (listener.dragged)
+                listener.dragged(this.mouseX, this.mouseY);
             } else {
-              if (listeners[i].moved)
-                listeners[i].moved(x, y);
+              if (listener.moved)
+                listener.moved(this.mouseX, this.mouseY);
             }
-          }
-          this.lastX = x;
-          this.lastY = y;
+          });
         }
       };
       let mouseUp = (ev) => {
         if (ev instanceof MouseEvent) {
           let rect = element.getBoundingClientRect();
-          let x = ev.clientX - rect.left;
-          let y = ev.clientY - rect.top;
-          let listeners = this.listeners;
-          for (let i = 0; i < listeners.length; i++)
-            if (listeners[i].up)
-              listeners[i].up(x, y);
-          this.lastX = x;
-          this.lastY = y;
+          this.mouseX = ev.clientX - rect.left;
+          ;
+          this.mouseY = ev.clientY - rect.top;
           this.buttonDown = false;
+          this.listeners.map((listener) => {
+            if (listener.up)
+              listener.up(this.mouseX, this.mouseY);
+          });
           document.removeEventListener("mousemove", mouseMove);
           document.removeEventListener("mouseup", mouseUp);
         }
       };
+      let mouseWheel = (e) => {
+        e.preventDefault();
+        let deltaY = e.deltaY;
+        if (e.deltaMode == WheelEvent.DOM_DELTA_LINE)
+          deltaY *= 8;
+        if (e.deltaMode == WheelEvent.DOM_DELTA_PAGE)
+          deltaY *= 24;
+        this.listeners.map((listener) => {
+          if (listener.wheel)
+            listener.wheel(e.deltaY);
+        });
+      };
       element.addEventListener("mousedown", mouseDown, true);
       element.addEventListener("mousemove", mouseMove, true);
       element.addEventListener("mouseup", mouseUp, true);
+      element.addEventListener("wheel", mouseWheel, true);
       element.addEventListener("touchstart", (ev) => {
-        if (!this.currTouch) {
+        if (!this.touch0 || !this.touch1) {
           var touches = ev.changedTouches;
-          for (var i = 0; i < touches.length; i++) {
-            var touch = touches[i];
-            let rect = element.getBoundingClientRect();
-            let x = touch.clientX - rect.left;
-            let y = touch.clientY - rect.top;
-            this.currTouch = this.touchesPool.obtain();
-            this.currTouch.identifier = touch.identifier;
-            this.currTouch.x = x;
-            this.currTouch.y = y;
-            break;
-          }
-          let listeners = this.listeners;
-          for (let i2 = 0; i2 < listeners.length; i2++) {
-            if (listeners[i2].down)
-              listeners[i2].down(this.currTouch.x, this.currTouch.y);
-          }
-          this.lastX = this.currTouch.x;
-          this.lastY = this.currTouch.y;
+          let nativeTouch = touches.item(0);
+          let rect = element.getBoundingClientRect();
+          let x = nativeTouch.clientX - rect.left;
+          let y = nativeTouch.clientY - rect.top;
+          let touch = new Touch(nativeTouch.identifier, x, y);
+          this.mouseX = x;
+          this.mouseY = y;
           this.buttonDown = true;
-        }
-        ev.preventDefault();
-      }, false);
-      element.addEventListener("touchend", (ev) => {
-        if (this.currTouch) {
-          var touches = ev.changedTouches;
-          for (var i = 0; i < touches.length; i++) {
-            var touch = touches[i];
-            if (this.currTouch.identifier === touch.identifier) {
-              let rect = element.getBoundingClientRect();
-              let x = this.currTouch.x = touch.clientX - rect.left;
-              let y = this.currTouch.y = touch.clientY - rect.top;
-              this.touchesPool.free(this.currTouch);
-              let listeners = this.listeners;
-              for (let i2 = 0; i2 < listeners.length; i2++) {
-                if (listeners[i2].up)
-                  listeners[i2].up(x, y);
-              }
-              this.lastX = x;
-              this.lastY = y;
-              this.buttonDown = false;
-              this.currTouch = null;
-              break;
-            }
+          if (!this.touch0) {
+            this.touch0 = touch;
+            this.listeners.map((listener) => {
+              if (listener.down)
+                listener.down(touch.x, touch.y);
+            });
+          } else if (!this.touch1) {
+            this.touch1 = touch;
+            let dx = this.touch1.x - this.touch0.x;
+            let dy = this.touch1.x - this.touch0.x;
+            this.initialPinchDistance = Math.sqrt(dx * dx + dy * dy);
+            this.listeners.map((listener) => {
+              if (listener.zoom)
+                listener.zoom(this.initialPinchDistance, this.initialPinchDistance);
+            });
           }
         }
         ev.preventDefault();
       }, false);
-      element.addEventListener("touchcancel", (ev) => {
-        if (this.currTouch) {
+      element.addEventListener("touchmove", (ev) => {
+        if (this.touch0) {
           var touches = ev.changedTouches;
+          let rect = element.getBoundingClientRect();
           for (var i = 0; i < touches.length; i++) {
-            var touch = touches[i];
-            if (this.currTouch.identifier === touch.identifier) {
-              let rect = element.getBoundingClientRect();
-              let x = this.currTouch.x = touch.clientX - rect.left;
-              let y = this.currTouch.y = touch.clientY - rect.top;
-              this.touchesPool.free(this.currTouch);
-              let listeners = this.listeners;
-              for (let i2 = 0; i2 < listeners.length; i2++) {
-                if (listeners[i2].up)
-                  listeners[i2].up(x, y);
-              }
-              this.lastX = x;
-              this.lastY = y;
-              this.buttonDown = false;
-              this.currTouch = null;
-              break;
+            var nativeTouch = touches[i];
+            let x = nativeTouch.clientX - rect.left;
+            let y = nativeTouch.clientY - rect.top;
+            if (this.touch0.identifier === nativeTouch.identifier) {
+              this.touch0.x = this.mouseX = x;
+              this.touch0.y = this.mouseY = y;
+              this.listeners.map((listener) => {
+                if (listener.dragged)
+                  listener.dragged(x, y);
+              });
+            }
+            if (this.touch1 && this.touch1.identifier === nativeTouch.identifier) {
+              this.touch1.x = this.mouseX = x;
+              this.touch1.y = this.mouseY = y;
             }
           }
+          if (this.touch0 && this.touch1) {
+            let dx = this.touch1.x - this.touch0.x;
+            let dy = this.touch1.x - this.touch0.x;
+            let distance = Math.sqrt(dx * dx + dy * dy);
+            this.listeners.map((listener) => {
+              if (listener.zoom)
+                listener.zoom(this.initialPinchDistance, distance);
+            });
+          }
         }
         ev.preventDefault();
       }, false);
-      element.addEventListener("touchmove", (ev) => {
-        if (this.currTouch) {
+      let touchEnd = (ev) => {
+        if (this.touch0) {
           var touches = ev.changedTouches;
+          let rect = element.getBoundingClientRect();
           for (var i = 0; i < touches.length; i++) {
-            var touch = touches[i];
-            if (this.currTouch.identifier === touch.identifier) {
-              let rect = element.getBoundingClientRect();
-              let x = touch.clientX - rect.left;
-              let y = touch.clientY - rect.top;
-              let listeners = this.listeners;
-              for (let i2 = 0; i2 < listeners.length; i2++) {
-                if (listeners[i2].dragged)
-                  listeners[i2].dragged(x, y);
+            var nativeTouch = touches[i];
+            let x = nativeTouch.clientX - rect.left;
+            let y = nativeTouch.clientY - rect.top;
+            if (this.touch0.identifier === nativeTouch.identifier) {
+              this.touch0 = null;
+              this.mouseX = x;
+              this.mouseY = y;
+              this.listeners.map((listener) => {
+                if (listener.up)
+                  listener.up(x, y);
+              });
+              if (!this.touch1) {
+                this.buttonDown = false;
+                break;
+              } else {
+                this.touch0 = this.touch1;
+                this.touch1 = null;
+                this.mouseX = this.touch0.x;
+                this.mouseX = this.touch0.x;
+                this.buttonDown = true;
+                this.listeners.map((listener) => {
+                  if (listener.down)
+                    listener.down(this.touch0.x, this.touch0.y);
+                });
               }
-              this.lastX = this.currTouch.x = x;
-              this.lastY = this.currTouch.y = y;
-              break;
+            }
+            if (this.touch1 && this.touch1.identifier) {
+              this.touch1 = null;
             }
           }
         }
         ev.preventDefault();
-      }, false);
+      };
+      element.addEventListener("touchend", touchEnd, false);
+      element.addEventListener("touchcancel", touchEnd);
     }
     addListener(listener) {
       this.listeners.push(listener);
@@ -9436,6 +9677,72 @@ var spine = (() => {
     }
   };
 
+  // spine-webgl/src/CameraController.ts
+  var CameraController = class {
+    constructor(canvas, camera) {
+      this.canvas = canvas;
+      this.camera = camera;
+      let cameraX = 0, cameraY = 0, cameraZoom = 0;
+      let mouseX = 0, mouseY = 0;
+      let lastX = 0, lastY = 0;
+      let initialZoom = 0;
+      new Input(canvas).addListener({
+        down: (x, y) => {
+          cameraX = camera.position.x;
+          cameraY = camera.position.y;
+          mouseX = lastX = x;
+          mouseY = lastY = y;
+          initialZoom = camera.zoom;
+        },
+        dragged: (x, y) => {
+          let deltaX = x - mouseX;
+          let deltaY = y - mouseY;
+          let originWorld = camera.screenToWorld(new Vector3(0, 0), canvas.clientWidth, canvas.clientHeight);
+          let deltaWorld = camera.screenToWorld(new Vector3(deltaX, deltaY), canvas.clientWidth, canvas.clientHeight).sub(originWorld);
+          camera.position.set(cameraX - deltaWorld.x, cameraY - deltaWorld.y, 0);
+          camera.update();
+          lastX = x;
+          lastY = y;
+        },
+        wheel: (delta) => {
+          let zoomAmount = delta / 200 * camera.zoom;
+          let newZoom = camera.zoom + zoomAmount;
+          if (newZoom > 0) {
+            let x = 0, y = 0;
+            if (delta < 0) {
+              x = lastX;
+              y = lastY;
+            } else {
+              let viewCenter = new Vector3(canvas.clientWidth / 2 + 15, canvas.clientHeight / 2);
+              let mouseToCenterX = lastX - viewCenter.x;
+              let mouseToCenterY = canvas.clientHeight - 1 - lastY - viewCenter.y;
+              x = viewCenter.x - mouseToCenterX;
+              y = canvas.clientHeight - 1 - viewCenter.y + mouseToCenterY;
+            }
+            let oldDistance = camera.screenToWorld(new Vector3(x, y), canvas.clientWidth, canvas.clientHeight);
+            camera.zoom = newZoom;
+            camera.update();
+            let newDistance = camera.screenToWorld(new Vector3(x, y), canvas.clientWidth, canvas.clientHeight);
+            camera.position.add(oldDistance.sub(newDistance));
+            camera.update();
+          }
+        },
+        zoom: (initialDistance, distance) => {
+          let newZoom = initialDistance / distance;
+          camera.zoom = initialZoom * newZoom;
+        },
+        up: (x, y) => {
+          lastX = x;
+          lastY = y;
+        },
+        moved: (x, y) => {
+          lastX = x;
+          lastY = y;
+        }
+      });
+    }
+  };
+
   // spine-webgl/src/Shader.ts
   var _Shader = class {
     constructor(context, vertexShader, fragmentShader) {
@@ -9888,6 +10195,8 @@ var spine = (() => {
       gl.blendFuncSeparate(this.srcColorBlend, this.dstBlend, this.srcAlphaBlend, this.dstBlend);
     }
     setBlendMode(srcColorBlend, srcAlphaBlend, dstBlend) {
+      if (this.srcColorBlend == srcColorBlend && this.srcAlphaBlend == srcAlphaBlend && this.dstBlend == dstBlend)
+        return;
       this.srcColorBlend = srcColorBlend;
       this.srcAlphaBlend = srcAlphaBlend;
       this.dstBlend = dstBlend;
@@ -10285,9 +10594,9 @@ var spine = (() => {
             continue;
           if (!bone.parent)
             continue;
-          let x = skeletonX + bone.data.length * bone.a + bone.worldX;
-          let y = skeletonY + bone.data.length * bone.c + bone.worldY;
-          shapes.rectLine(true, skeletonX + bone.worldX, skeletonY + bone.worldY, x, y, this.boneWidth * this.scale);
+          let x = bone.data.length * bone.a + bone.worldX;
+          let y = bone.data.length * bone.c + bone.worldY;
+          shapes.rectLine(true, bone.worldX, bone.worldY, x, y, this.boneWidth * this.scale);
         }
         if (this.drawSkeletonXY)
           shapes.x(skeletonX, skeletonY, 4 * this.scale);
@@ -10301,7 +10610,7 @@ var spine = (() => {
           if (attachment instanceof RegionAttachment) {
             let regionAttachment = attachment;
             let vertices = this.vertices;
-            regionAttachment.computeWorldVertices(slot.bone, vertices, 0, 2);
+            regionAttachment.computeWorldVertices(slot, vertices, 0, 2);
             shapes.line(vertices[0], vertices[1], vertices[2], vertices[3]);
             shapes.line(vertices[2], vertices[3], vertices[4], vertices[5]);
             shapes.line(vertices[4], vertices[5], vertices[6], vertices[7]);
@@ -10402,7 +10711,7 @@ var spine = (() => {
           let bone = bones[i];
           if (ignoredBones && ignoredBones.indexOf(bone.data.name) > -1)
             continue;
-          shapes.circle(true, skeletonX + bone.worldX, skeletonY + bone.worldY, 3 * this.scale, _SkeletonDebugRenderer.GREEN, 8);
+          shapes.circle(true, bone.worldX, bone.worldY, 3 * this.scale, _SkeletonDebugRenderer.GREEN, 8);
         }
       }
       if (this.drawClipping) {
@@ -10506,7 +10815,7 @@ var spine = (() => {
           renderable.vertices = this.vertices;
           renderable.numVertices = 4;
           renderable.numFloats = clippedVertexSize << 2;
-          region.computeWorldVertices(slot.bone, renderable.vertices, 0, clippedVertexSize);
+          region.computeWorldVertices(slot, renderable.vertices, 0, clippedVertexSize);
           triangles = _SkeletonRenderer.QUAD_TRIANGLES;
           uvs = region.uvs;
           texture = region.region.renderObject.page.texture;