@esotericsoftware/spine-webgl 4.0.12 → 4.1.1

package/dist/iife/spine-webgl.js

@@ -1,9 +1,6 @@
 var spine = (() => {
   var __defProp = Object.defineProperty;
   var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-  var __require = typeof require !== "undefined" ? require : (x) => {
-    throw new Error('Dynamic require of "' + x + '" is not supported');
-  };
   var __export = (target, all) => {
     __markAsModule(target);
     for (var name in all)
@@ -113,6 +110,7 @@ var spine = (() => {
     ScaleXTimeline: () => ScaleXTimeline,
     ScaleYTimeline: () => ScaleYTimeline,
     SceneRenderer: () => SceneRenderer,
+    SequenceTimeline: () => SequenceTimeline,
     Shader: () => Shader,
     ShapeRenderer: () => ShapeRenderer,
     ShapeType: () => ShapeType,
@@ -557,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;
@@ -629,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) {
@@ -702,7 +763,8 @@ var spine = (() => {
     transformConstraint: 15,
     pathConstraintPosition: 16,
     pathConstraintSpacing: 17,
-    pathConstraintMix: 18
+    pathConstraintMix: 18,
+    sequence: 19
   };
   var Timeline = class {
     constructor(frameCount, propertyIds) {
@@ -1860,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)
@@ -1869,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;
@@ -1880,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++)
@@ -2404,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 {
@@ -3497,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);
@@ -3585,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);
@@ -3593,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;
     }
   };
@@ -3668,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;
@@ -3697,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;
@@ -3721,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;
@@ -3761,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;
     }
   };
@@ -3803,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) {
@@ -5125,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);
@@ -5361,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;
@@ -5795,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;
@@ -5815,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
@@ -6269,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);
@@ -6340,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;
@@ -6354,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: {
@@ -6379,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) {
@@ -6388,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;
@@ -6398,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;
@@ -6412,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();
@@ -6420,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: {
@@ -6488,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;
@@ -6730,7 +6901,6 @@ var spine = (() => {
                 a = a2;
               }
               timelines.push(timeline);
-              break;
             }
           }
         }
@@ -6870,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);
           }
         }
       }
@@ -7059,7 +7246,7 @@ var spine = (() => {
       this.skin = skin;
       this.slotIndex = slotIndex;
       this.parent = parent;
-      this.inheritDeform = inheritDeform;
+      this.inheritTimeline = inheritDeform;
     }
   };
   var Vertices = class {
@@ -7137,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;
@@ -7972,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) {
@@ -8006,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;
@@ -8017,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": {
@@ -8036,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;
@@ -8045,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;
@@ -8105,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;
@@ -8149,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") {
@@ -8451,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);
             }
           }
         }
@@ -8564,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) {
@@ -9255,77 +9478,6 @@ 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) => {
-          console.log(`Down ${x.toFixed(0)} ${y.toFixed(0)}`);
-          cameraX = camera.position.x;
-          cameraY = camera.position.y;
-          mouseX = lastX = x;
-          mouseY = lastY = y;
-          initialZoom = camera.zoom;
-        },
-        dragged: (x, y) => {
-          console.log(`Dragged ${x.toFixed(0)} ${y.toFixed(0)}`);
-          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;
-          console.log(`${newZoom}, ${initialDistance}, ${distance}`);
-          camera.zoom = initialZoom * newZoom;
-          console.log(`zoom ${newZoom}`);
-        },
-        up: (x, y) => {
-          console.log(`Up ${x.toFixed(0)} ${y.toFixed(0)}`);
-          lastX = x;
-          lastY = y;
-        },
-        moved: (x, y) => {
-          lastX = x;
-          lastY = y;
-        }
-      });
-    }
-  };
-
   // spine-webgl/src/Input.ts
   var Input = class {
     constructor(element) {
@@ -9525,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) {
@@ -9977,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;
@@ -10374,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);
@@ -10390,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]);
@@ -10491,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) {
@@ -10595,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;