@esotericsoftware/spine-core 4.2.115 → 4.3.0

package/dist/Skeleton.js

@@ -28,125 +28,134 @@
  *****************************************************************************/
 import { ClippingAttachment } from "./attachments/ClippingAttachment.js";
 import { MeshAttachment } from "./attachments/MeshAttachment.js";
-import { PathAttachment } from "./attachments/PathAttachment.js";
 import { RegionAttachment } from "./attachments/RegionAttachment.js";
 import { Bone } from "./Bone.js";
-import { IkConstraint } from "./IkConstraint.js";
-import { PathConstraint } from "./PathConstraint.js";
+import { DrawOrder } from "./DrawOrder.js";
 import { PhysicsConstraint } from "./PhysicsConstraint.js";
 import { Slot } from "./Slot.js";
-import { TransformConstraint } from "./TransformConstraint.js";
-import { Color, Utils, MathUtils, Vector2 } from "./Utils.js";
-/** Stores the current pose for a skeleton.
+import { Color, Utils, Vector2 } from "./Utils.js";
+/** Stores bones and slots to be posed by animations and application code. Multiple skeleton instances can share the same
+ * {@link SkeletonData}, including animations, attachments, and skins.
+ *
+ * After posing, call {@link updateWorldTransform} to apply constraints and compute world transforms for rendering.
  *
  * See [Instance objects](http://esotericsoftware.com/spine-runtime-architecture#Instance-objects) in the Spine Runtimes Guide. */
 export class Skeleton {
     static quadTriangles = [0, 1, 2, 2, 3, 0];
     static yDown = false;
+    static get yDir() {
+        return Skeleton.yDown ? -1 : 1;
+    }
     /** The skeleton's setup pose data. */
     data;
     /** The skeleton's bones, sorted parent first. The root bone is always the first bone. */
     bones;
-    /** The skeleton's slots in the setup pose draw order. */
+    /** The skeleton's slots. To add a slot, also add it to {@link DrawOrder.pose}. */
     slots;
-    /** The skeleton's slots in the order they should be drawn. The returned array may be modified to change the draw order. */
+    /** The skeleton's draw order. Use {@link DrawOrder.appliedPose} for rendering and {@link DrawOrder.pose} for changing the draw
+     * order. */
     drawOrder;
-    /** The skeleton's IK constraints. */
-    ikConstraints;
-    /** The skeleton's transform constraints. */
-    transformConstraints;
-    /** The skeleton's path constraints. */
-    pathConstraints;
+    /** The skeleton's constraints. */
+    // biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types
+    constraints;
     /** The skeleton's physics constraints. */
-    physicsConstraints;
-    /** The list of bones and constraints, sorted in the order they should be updated, as computed by {@link #updateCache()}. */
-    _updateCache = new Array();
+    physics;
+    /** The list of bones and constraints, sorted in the order they should be updated, as computed by {@link updateCache}. */
+    // biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types
+    _updateCache = [];
+    // biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types
+    resetCache = [];
     /** The skeleton's current skin. May be null. */
     skin = null;
     /** The color to tint all the skeleton's attachments. */
     color;
-    /** Scales the entire skeleton on the X axis. This affects all bones, even if the bone's transform mode disallows scale
-      * inheritance. */
+    /** Scales the entire skeleton on the X axis.
+     *
+     * Bones that do not inherit scale are still affected by this property. */
     scaleX = 1;
-    /** Scales the entire skeleton on the Y axis. This affects all bones, even if the bone's transform mode disallows scale
-      * inheritance. */
     _scaleY = 1;
+    /** Scales the entire skeleton on the Y axis.
+     *
+     * Bones that do not inherit scale are still affected by this property. */
     get scaleY() {
-        return Skeleton.yDown ? -this._scaleY : this._scaleY;
+        return this._scaleY * Skeleton.yDir;
     }
     set scaleY(scaleY) {
         this._scaleY = scaleY;
     }
-    /** Sets the skeleton X position, which is added to the root bone worldX position. */
+    /** Sets the skeleton X position, which is added to the root bone worldX position.
+     *
+     * Bones that do not inherit translation are still affected by this property. */
     x = 0;
-    /** Sets the skeleton Y position, which is added to the root bone worldY position. */
+    /** Sets the skeleton Y position, which is added to the root bone worldY position.
+     *
+     * Bones that do not inherit translation are still affected by this property. */
     y = 0;
-    /** Returns the skeleton's time. This is used for time-based manipulations, such as {@link PhysicsConstraint}.
-     * <p>
-     * See {@link #update(float)}. */
+    /** Returns the skeleton's time, is used for time-based manipulations, such as {@link PhysicsConstraint}.
+     *
+     * See {@link _update}. */
     time = 0;
+    /** The x component of a vector that defines the direction {@link PhysicsConstraintPose.wind} is applied. */
+    windX = 1;
+    /** The y component of a vector that defines the direction {@link PhysicsConstraintPose.wind} is applied. */
+    windY = 0;
+    /** The x component of a vector that defines the direction {@link PhysicsConstraintPose.gravity} is applied. */
+    gravityX = 0;
+    /** The y component of a vector that defines the direction {@link PhysicsConstraintPose.gravity} is applied. */
+    gravityY = 1;
+    _update = 0;
     constructor(data) {
         if (!data)
             throw new Error("data cannot be null.");
         this.data = data;
-        this.bones = new Array();
+        this.bones = [];
         for (let i = 0; i < data.bones.length; i++) {
-            let boneData = data.bones[i];
+            const boneData = data.bones[i];
             let bone;
             if (!boneData.parent)
-                bone = new Bone(boneData, this, null);
+                bone = new Bone(boneData, null);
             else {
-                let parent = this.bones[boneData.parent.index];
-                bone = new Bone(boneData, this, parent);
+                const parent = this.bones[boneData.parent.index];
+                bone = new Bone(boneData, parent);
                 parent.children.push(bone);
             }
             this.bones.push(bone);
         }
-        this.slots = new Array();
-        this.drawOrder = new Array();
-        for (let i = 0; i < data.slots.length; i++) {
-            let slotData = data.slots[i];
-            let bone = this.bones[slotData.boneData.index];
-            let slot = new Slot(slotData, bone);
-            this.slots.push(slot);
-            this.drawOrder.push(slot);
-        }
-        this.ikConstraints = new Array();
-        for (let i = 0; i < data.ikConstraints.length; i++) {
-            let ikConstraintData = data.ikConstraints[i];
-            this.ikConstraints.push(new IkConstraint(ikConstraintData, this));
-        }
-        this.transformConstraints = new Array();
-        for (let i = 0; i < data.transformConstraints.length; i++) {
-            let transformConstraintData = data.transformConstraints[i];
-            this.transformConstraints.push(new TransformConstraint(transformConstraintData, this));
-        }
-        this.pathConstraints = new Array();
-        for (let i = 0; i < data.pathConstraints.length; i++) {
-            let pathConstraintData = data.pathConstraints[i];
-            this.pathConstraints.push(new PathConstraint(pathConstraintData, this));
-        }
-        this.physicsConstraints = new Array();
-        for (let i = 0; i < data.physicsConstraints.length; i++) {
-            let physicsConstraintData = data.physicsConstraints[i];
-            this.physicsConstraints.push(new PhysicsConstraint(physicsConstraintData, this));
+        this.slots = [];
+        for (const slotData of this.data.slots)
+            this.slots.push(new Slot(slotData, this));
+        this.drawOrder = new DrawOrder(this.slots);
+        this.physics = [];
+        // biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types
+        this.constraints = [];
+        for (const constraintData of this.data.constraints) {
+            const constraint = constraintData.create(this);
+            if (constraint instanceof PhysicsConstraint)
+                this.physics.push(constraint);
+            this.constraints.push(constraint);
         }
         this.color = new Color(1, 1, 1, 1);
         this.updateCache();
     }
-    /** Caches information about bones and constraints. Must be called if the {@link #getSkin()} is modified or if bones,
-     * constraints, or weighted path attachments are added or removed. */
+    /** Caches information about bones and constraints. Must be called if the {@link skin} is modified or if bones, constraints,
+     * or weighted path attachments are added or removed. */
     updateCache() {
-        let updateCache = this._updateCache;
-        updateCache.length = 0;
-        let bones = this.bones;
-        for (let i = 0, n = bones.length; i < n; i++) {
-            let bone = bones[i];
+        this._updateCache.length = 0;
+        this.resetCache.length = 0;
+        this.drawOrder.unconstrained();
+        const slots = this.slots;
+        for (let i = 0, n = slots.length; i < n; i++)
+            slots[i].unconstrained();
+        const bones = this.bones;
+        const boneCount = bones.length;
+        for (let i = 0, n = boneCount; i < n; i++) {
+            const bone = bones[i];
             bone.sorted = bone.data.skinRequired;
             bone.active = !bone.sorted;
+            bone.unconstrained();
         }
         if (this.skin) {
-            let skinBones = this.skin.bones;
+            const skinBones = this.skin.bones;
             for (let i = 0, n = this.skin.bones.length; i < n; i++) {
                 let bone = this.bones[skinBones[i].index];
                 do {
@@ -156,158 +165,38 @@ export class Skeleton {
                 } while (bone);
             }
         }
-        // IK first, lowest hierarchy depth first.
-        let ikConstraints = this.ikConstraints;
-        let transformConstraints = this.transformConstraints;
-        let pathConstraints = this.pathConstraints;
-        let physicsConstraints = this.physicsConstraints;
-        let ikCount = ikConstraints.length, transformCount = transformConstraints.length, pathCount = pathConstraints.length, physicsCount = this.physicsConstraints.length;
-        let constraintCount = ikCount + transformCount + pathCount + physicsCount;
-        outer: for (let i = 0; i < constraintCount; i++) {
-            for (let ii = 0; ii < ikCount; ii++) {
-                let constraint = ikConstraints[ii];
-                if (constraint.data.order == i) {
-                    this.sortIkConstraint(constraint);
-                    continue outer;
-                }
-            }
-            for (let ii = 0; ii < transformCount; ii++) {
-                let constraint = transformConstraints[ii];
-                if (constraint.data.order == i) {
-                    this.sortTransformConstraint(constraint);
-                    continue outer;
-                }
-            }
-            for (let ii = 0; ii < pathCount; ii++) {
-                let constraint = pathConstraints[ii];
-                if (constraint.data.order == i) {
-                    this.sortPathConstraint(constraint);
-                    continue outer;
-                }
-            }
-            for (let ii = 0; ii < physicsCount; ii++) {
-                const constraint = physicsConstraints[ii];
-                if (constraint.data.order == i) {
-                    this.sortPhysicsConstraint(constraint);
-                    continue outer;
-                }
-            }
+        const constraints = this.constraints;
+        let n = this.constraints.length;
+        for (let i = 0; i < n; i++)
+            constraints[i].unconstrained();
+        for (let i = 0; i < n; i++) {
+            const constraint = constraints[i];
+            constraint.active = constraint.isSourceActive()
+                // biome-ignore lint/complexity/useOptionalChain: changing to this might return undefined
+                && (!constraint.data.skinRequired || (this.skin != null && this.skin.constraints.includes(constraint.data)));
+            if (constraint.active)
+                constraint.sort(this);
         }
-        for (let i = 0, n = bones.length; i < n; i++)
-            this.sortBone(bones[i]);
-    }
-    sortIkConstraint(constraint) {
-        constraint.active = constraint.target.isActive() && (!constraint.data.skinRequired || (this.skin && Utils.contains(this.skin.constraints, constraint.data, true)));
-        if (!constraint.active)
-            return;
-        let target = constraint.target;
-        this.sortBone(target);
-        let constrained = constraint.bones;
-        let parent = constrained[0];
-        this.sortBone(parent);
-        if (constrained.length == 1) {
-            this._updateCache.push(constraint);
-            this.sortReset(parent.children);
-        }
-        else {
-            let child = constrained[constrained.length - 1];
-            this.sortBone(child);
-            this._updateCache.push(constraint);
-            this.sortReset(parent.children);
-            child.sorted = true;
-        }
-    }
-    sortPathConstraint(constraint) {
-        constraint.active = constraint.target.bone.isActive() && (!constraint.data.skinRequired || (this.skin && Utils.contains(this.skin.constraints, constraint.data, true)));
-        if (!constraint.active)
-            return;
-        let slot = constraint.target;
-        let slotIndex = slot.data.index;
-        let slotBone = slot.bone;
-        if (this.skin)
-            this.sortPathConstraintAttachment(this.skin, slotIndex, slotBone);
-        if (this.data.defaultSkin && this.data.defaultSkin != this.skin)
-            this.sortPathConstraintAttachment(this.data.defaultSkin, slotIndex, slotBone);
-        for (let i = 0, n = this.data.skins.length; i < n; i++)
-            this.sortPathConstraintAttachment(this.data.skins[i], slotIndex, slotBone);
-        let attachment = slot.getAttachment();
-        if (attachment instanceof PathAttachment)
-            this.sortPathConstraintAttachmentWith(attachment, slotBone);
-        let constrained = constraint.bones;
-        let boneCount = constrained.length;
-        for (let i = 0; i < boneCount; i++)
-            this.sortBone(constrained[i]);
-        this._updateCache.push(constraint);
         for (let i = 0; i < boneCount; i++)
-            this.sortReset(constrained[i].children);
-        for (let i = 0; i < boneCount; i++)
-            constrained[i].sorted = true;
-    }
-    sortTransformConstraint(constraint) {
-        constraint.active = constraint.target.isActive() && (!constraint.data.skinRequired || (this.skin && Utils.contains(this.skin.constraints, constraint.data, true)));
-        if (!constraint.active)
-            return;
-        this.sortBone(constraint.target);
-        let constrained = constraint.bones;
-        let boneCount = constrained.length;
-        if (constraint.data.local) {
-            for (let i = 0; i < boneCount; i++) {
-                let child = constrained[i];
-                this.sortBone(child.parent);
-                this.sortBone(child);
-            }
-        }
-        else {
-            for (let i = 0; i < boneCount; i++) {
-                this.sortBone(constrained[i]);
-            }
+            this.sortBone(bones[i]);
+        n = this._updateCache.length;
+        for (let i = 0; i < n; i++) {
+            const updateable = this._updateCache[i];
+            if (updateable instanceof Bone)
+                this._updateCache[i] = updateable.appliedPose;
         }
-        this._updateCache.push(constraint);
-        for (let i = 0; i < boneCount; i++)
-            this.sortReset(constrained[i].children);
-        for (let i = 0; i < boneCount; i++)
-            constrained[i].sorted = true;
     }
-    sortPathConstraintAttachment(skin, slotIndex, slotBone) {
-        let attachments = skin.attachments[slotIndex];
-        if (!attachments)
-            return;
-        for (let key in attachments) {
-            this.sortPathConstraintAttachmentWith(attachments[key], slotBone);
+    // biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types
+    constrained(object) {
+        if (object.pose === object.appliedPose) {
+            object.constrained();
+            this.resetCache.push(object);
         }
     }
-    sortPathConstraintAttachmentWith(attachment, slotBone) {
-        if (!(attachment instanceof PathAttachment))
-            return;
-        let pathBones = attachment.bones;
-        if (!pathBones)
-            this.sortBone(slotBone);
-        else {
-            let bones = this.bones;
-            for (let i = 0, n = pathBones.length; i < n;) {
-                let nn = pathBones[i++];
-                nn += i;
-                while (i < nn)
-                    this.sortBone(bones[pathBones[i++]]);
-            }
-        }
-    }
-    sortPhysicsConstraint(constraint) {
-        const bone = constraint.bone;
-        constraint.active = bone.active && (!constraint.data.skinRequired || (this.skin != null && Utils.contains(this.skin.constraints, constraint.data, true)));
-        if (!constraint.active)
-            return;
-        this.sortBone(bone);
-        this._updateCache.push(constraint);
-        this.sortReset(bone.children);
-        bone.sorted = true;
-    }
     sortBone(bone) {
-        if (!bone)
+        if (bone.sorted || !bone.active)
             return;
-        if (bone.sorted)
-            return;
-        let parent = bone.parent;
+        const parent = bone.parent;
         if (parent)
             this.sortBone(parent);
         bone.sorted = true;
@@ -315,166 +204,106 @@ export class Skeleton {
     }
     sortReset(bones) {
         for (let i = 0, n = bones.length; i < n; i++) {
-            let bone = bones[i];
-            if (!bone.active)
-                continue;
-            if (bone.sorted)
-                this.sortReset(bone.children);
-            bone.sorted = false;
+            const bone = bones[i];
+            if (bone.active) {
+                if (bone.sorted)
+                    this.sortReset(bone.children);
+                bone.sorted = false;
+            }
         }
     }
     /** Updates the world transform for each bone and applies all constraints.
      *
-     * See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine
+     * See <a href="https://esotericsoftware.com/spine-runtime-skeletons#World-transforms">World transforms</a> in the Spine
      * Runtimes Guide. */
     updateWorldTransform(physics) {
-        if (physics === undefined || physics === null)
-            throw new Error("physics is undefined");
-        let bones = this.bones;
-        for (let i = 0, n = bones.length; i < n; i++) {
-            let bone = bones[i];
-            bone.ax = bone.x;
-            bone.ay = bone.y;
-            bone.arotation = bone.rotation;
-            bone.ascaleX = bone.scaleX;
-            bone.ascaleY = bone.scaleY;
-            bone.ashearX = bone.shearX;
-            bone.ashearY = bone.shearY;
-        }
-        let updateCache = this._updateCache;
-        for (let i = 0, n = updateCache.length; i < n; i++)
-            updateCache[i].update(physics);
-    }
-    updateWorldTransformWith(physics, parent) {
-        if (!parent)
-            throw new Error("parent cannot be null.");
-        let bones = this.bones;
-        for (let i = 1, n = bones.length; i < n; i++) { // Skip root bone.
-            let bone = bones[i];
-            bone.ax = bone.x;
-            bone.ay = bone.y;
-            bone.arotation = bone.rotation;
-            bone.ascaleX = bone.scaleX;
-            bone.ascaleY = bone.scaleY;
-            bone.ashearX = bone.shearX;
-            bone.ashearY = bone.shearY;
-        }
-        // Apply the parent bone transform to the root bone. The root bone always inherits scale, rotation and reflection.
-        let rootBone = this.getRootBone();
-        if (!rootBone)
-            throw new Error("Root bone must not be null.");
-        let pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d;
-        rootBone.worldX = pa * this.x + pb * this.y + parent.worldX;
-        rootBone.worldY = pc * this.x + pd * this.y + parent.worldY;
-        const rx = (rootBone.rotation + rootBone.shearX) * MathUtils.degRad;
-        const ry = (rootBone.rotation + 90 + rootBone.shearY) * MathUtils.degRad;
-        const la = Math.cos(rx) * rootBone.scaleX;
-        const lb = Math.cos(ry) * rootBone.scaleY;
-        const lc = Math.sin(rx) * rootBone.scaleX;
-        const ld = Math.sin(ry) * rootBone.scaleY;
-        rootBone.a = (pa * la + pb * lc) * this.scaleX;
-        rootBone.b = (pa * lb + pb * ld) * this.scaleX;
-        rootBone.c = (pc * la + pd * lc) * this.scaleY;
-        rootBone.d = (pc * lb + pd * ld) * this.scaleY;
-        // Update everything except root bone.
-        let updateCache = this._updateCache;
-        for (let i = 0, n = updateCache.length; i < n; i++) {
-            let updatable = updateCache[i];
-            if (updatable != rootBone)
-                updatable.update(physics);
-        }
+        this._update++;
+        if (this.drawOrder.appliedPose === this.drawOrder.constrainedPose)
+            this.drawOrder.resetConstrained();
+        const resetCache = this.resetCache;
+        for (let i = 0, n = this.resetCache.length; i < n; i++)
+            resetCache[i].resetConstrained();
+        const updateCache = this._updateCache;
+        for (let i = 0, n = this._updateCache.length; i < n; i++)
+            updateCache[i].update(this, physics);
     }
     /** Sets the bones, constraints, and slots to their setup pose values. */
-    setToSetupPose() {
-        this.setBonesToSetupPose();
-        this.setSlotsToSetupPose();
+    setupPose() {
+        this.setupPoseBones();
+        this.setupPoseSlots();
     }
     /** Sets the bones and constraints to their setup pose values. */
-    setBonesToSetupPose() {
-        for (const bone of this.bones)
-            bone.setToSetupPose();
-        for (const constraint of this.ikConstraints)
-            constraint.setToSetupPose();
-        for (const constraint of this.transformConstraints)
-            constraint.setToSetupPose();
-        for (const constraint of this.pathConstraints)
-            constraint.setToSetupPose();
-        for (const constraint of this.physicsConstraints)
-            constraint.setToSetupPose();
+    setupPoseBones() {
+        const bones = this.bones;
+        for (let i = 0, n = bones.length; i < n; i++)
+            bones[i].setupPose();
+        const constraints = this.constraints;
+        for (let i = 0, n = constraints.length; i < n; i++)
+            constraints[i].setupPose();
     }
     /** Sets the slots and draw order to their setup pose values. */
-    setSlotsToSetupPose() {
-        let slots = this.slots;
-        Utils.arrayCopy(slots, 0, this.drawOrder, 0, slots.length);
+    setupPoseSlots() {
+        this.drawOrder.setupPose();
+        const slots = this.slots;
         for (let i = 0, n = slots.length; i < n; i++)
-            slots[i].setToSetupPose();
+            slots[i].setupPose();
     }
-    /** @returns May return null. */
+    /** Returns the root bone, or null if the skeleton has no bones. */
     getRootBone() {
-        if (this.bones.length == 0)
+        if (this.bones.length === 0)
             return null;
         return this.bones[0];
     }
-    /** @returns May be null. */
+    /** Finds a bone by comparing each bone's name. It is more efficient to cache the results of this method than to call it
+     * repeatedly. */
     findBone(boneName) {
         if (!boneName)
             throw new Error("boneName cannot be null.");
-        let bones = this.bones;
-        for (let i = 0, n = bones.length; i < n; i++) {
-            let bone = bones[i];
-            if (bone.data.name == boneName)
-                return bone;
-        }
+        const bones = this.bones;
+        for (let i = 0, n = bones.length; i < n; i++)
+            if (bones[i].data.name === boneName)
+                return bones[i];
         return null;
     }
     /** Finds a slot by comparing each slot's name. It is more efficient to cache the results of this method than to call it
-     * repeatedly.
-     * @returns May be null. */
+     * repeatedly. */
     findSlot(slotName) {
         if (!slotName)
             throw new Error("slotName cannot be null.");
-        let slots = this.slots;
-        for (let i = 0, n = slots.length; i < n; i++) {
-            let slot = slots[i];
-            if (slot.data.name == slotName)
-                return slot;
-        }
+        const slots = this.slots;
+        for (let i = 0, n = slots.length; i < n; i++)
+            if (slots[i].data.name === slotName)
+                return slots[i];
         return null;
     }
-    /** Sets a skin by name.
-     *
-     * See {@link #setSkin()}. */
+    setSkin(newSkin) {
+        if (typeof newSkin === "string")
+            this.setSkinByName(newSkin);
+        else
+            this.setSkinBySkin(newSkin);
+    }
+    ;
     setSkinByName(skinName) {
-        let skin = this.data.findSkin(skinName);
+        const skin = this.data.findSkin(skinName);
         if (!skin)
-            throw new Error("Skin not found: " + skinName);
+            throw new Error(`Skin not found: ${skinName}`);
         this.setSkin(skin);
     }
-    /** Sets the skin used to look up attachments before looking in the {@link SkeletonData#defaultSkin default skin}. If the
-     * skin is changed, {@link #updateCache()} is called.
-     *
-     * Attachments from the new skin are attached if the corresponding attachment from the old skin was attached. If there was no
-     * old skin, each slot's setup mode attachment is attached from the new skin.
-     *
-     * After changing the skin, the visible attachments can be reset to those attached in the setup pose by calling
-     * {@link #setSlotsToSetupPose()}. Also, often {@link AnimationState#apply()} is called before the next time the
-     * skeleton is rendered to allow any attachment keys in the current animation(s) to hide or show attachments from the new skin.
-     * @param newSkin May be null. */
-    setSkin(newSkin) {
-        if (newSkin == this.skin)
+    setSkinBySkin(newSkin) {
+        if (newSkin === this.skin)
             return;
         if (newSkin) {
             if (this.skin)
                 newSkin.attachAll(this, this.skin);
             else {
-                let slots = this.slots;
+                const slots = this.slots;
                 for (let i = 0, n = slots.length; i < n; i++) {
-                    let slot = slots[i];
-                    let name = slot.data.attachmentName;
+                    const slot = slots[i];
+                    const name = slot.data.attachmentName;
                     if (name) {
-                        let attachment = newSkin.getAttachment(i, name);
+                        const attachment = newSkin.getAttachment(i, name);
                         if (attachment)
-                            slot.setAttachment(attachment);
+                            slot.pose.setAttachment(attachment);
                     }
                 }
             }
@@ -482,180 +311,173 @@ export class Skeleton {
         this.skin = newSkin;
         this.updateCache();
     }
-    /** Finds an attachment by looking in the {@link #skin} and {@link SkeletonData#defaultSkin} using the slot name and attachment
+    getAttachment(slotNameOrIndex, placeholder) {
+        if (typeof slotNameOrIndex === 'string')
+            return this.getAttachmentByName(slotNameOrIndex, placeholder);
+        return this.getAttachmentByIndex(slotNameOrIndex, placeholder);
+    }
+    /** Finds an attachment by looking in the {@link skin} and {@link SkeletonData.defaultSkin} using the slot name and attachment
      * name.
      *
-     * See {@link #getAttachment()}.
+     * See {@link getAttachment}.
      * @returns May be null. */
-    getAttachmentByName(slotName, attachmentName) {
-        let slot = this.data.findSlot(slotName);
+    getAttachmentByName(slotName, placeholder) {
+        const slot = this.data.findSlot(slotName);
         if (!slot)
             throw new Error(`Can't find slot with name ${slotName}`);
-        return this.getAttachment(slot.index, attachmentName);
+        return this.getAttachment(slot.index, placeholder);
     }
-    /** Finds an attachment by looking in the {@link #skin} and {@link SkeletonData#defaultSkin} using the slot index and
+    /** Finds an attachment by looking in the {@link skin} and {@link SkeletonData.defaultSkin} using the slot index and
      * attachment name. First the skin is checked and if the attachment was not found, the default skin is checked.
      *
      * See [Runtime skins](http://esotericsoftware.com/spine-runtime-skins) in the Spine Runtimes Guide.
      * @returns May be null. */
-    getAttachment(slotIndex, attachmentName) {
-        if (!attachmentName)
-            throw new Error("attachmentName cannot be null.");
+    getAttachmentByIndex(slotIndex, placeholder) {
+        if (!placeholder)
+            throw new Error("placeholder cannot be null.");
         if (this.skin) {
-            let attachment = this.skin.getAttachment(slotIndex, attachmentName);
+            const attachment = this.skin.getAttachment(slotIndex, placeholder);
             if (attachment)
                 return attachment;
         }
         if (this.data.defaultSkin)
-            return this.data.defaultSkin.getAttachment(slotIndex, attachmentName);
+            return this.data.defaultSkin.getAttachment(slotIndex, placeholder);
         return null;
     }
-    /** A convenience method to set an attachment by finding the slot with {@link #findSlot()}, finding the attachment with
-     * {@link #getAttachment()}, then setting the slot's {@link Slot#attachment}.
-     * @param attachmentName May be null to clear the slot's attachment. */
-    setAttachment(slotName, attachmentName) {
+    /** A convenience method to set an attachment by finding the slot with {@link findSlot}, finding the attachment with
+     * {@link getAttachment}, then setting the slot's {@link Slot.attachment}.
+     * @param placeholder May be null to clear the slot's attachment. */
+    setAttachment(slotName, placeholder) {
         if (!slotName)
             throw new Error("slotName cannot be null.");
-        let slots = this.slots;
-        for (let i = 0, n = slots.length; i < n; i++) {
-            let slot = slots[i];
-            if (slot.data.name == slotName) {
-                let attachment = null;
-                if (attachmentName) {
-                    attachment = this.getAttachment(i, attachmentName);
-                    if (!attachment)
-                        throw new Error("Attachment not found: " + attachmentName + ", for slot: " + slotName);
-                }
-                slot.setAttachment(attachment);
-                return;
-            }
+        const slot = this.findSlot(slotName);
+        if (!slot)
+            throw new Error(`Slot not found: ${slotName}`);
+        let attachment = null;
+        if (placeholder) {
+            attachment = this.getAttachment(slot.data.index, placeholder);
+            if (!attachment)
+                throw new Error(`Attachment not found: ${placeholder}, for slot: ${slotName}`);
         }
-        throw new Error("Slot not found: " + slotName);
-    }
-    /** Finds an IK constraint by comparing each IK constraint's name. It is more efficient to cache the results of this method
-     * than to call it repeatedly.
-     * @return May be null. */
-    findIkConstraint(constraintName) {
-        if (!constraintName)
-            throw new Error("constraintName cannot be null.");
-        return this.ikConstraints.find((constraint) => constraint.data.name == constraintName) ?? null;
-    }
-    /** Finds a transform constraint by comparing each transform constraint's name. It is more efficient to cache the results of
-     * this method than to call it repeatedly.
-     * @return May be null. */
-    findTransformConstraint(constraintName) {
-        if (!constraintName)
-            throw new Error("constraintName cannot be null.");
-        return this.transformConstraints.find((constraint) => constraint.data.name == constraintName) ?? null;
-    }
-    /** Finds a path constraint by comparing each path constraint's name. It is more efficient to cache the results of this method
-     * than to call it repeatedly.
-     * @return May be null. */
-    findPathConstraint(constraintName) {
-        if (!constraintName)
-            throw new Error("constraintName cannot be null.");
-        return this.pathConstraints.find((constraint) => constraint.data.name == constraintName) ?? null;
+        slot.pose.setAttachment(attachment);
     }
-    /** Finds a physics constraint by comparing each physics constraint's name. It is more efficient to cache the results of this
-     * method than to call it repeatedly. */
-    findPhysicsConstraint(constraintName) {
+    /** Finds a constraint of the specified type by comparing each constraints's name. It is more efficient to cache the results of
+     * this method than to call it multiple times. */
+    // biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types
+    findConstraint(constraintName, type) {
         if (constraintName == null)
             throw new Error("constraintName cannot be null.");
-        return this.physicsConstraints.find((constraint) => constraint.data.name == constraintName) ?? null;
+        if (type == null)
+            throw new Error("type cannot be null.");
+        const constraints = this.constraints;
+        for (let i = 0, n = constraints.length; i < n; i++) {
+            const constraint = constraints[i];
+            if (constraint instanceof type && constraint.data.name === constraintName)
+                return constraint;
+        }
+        return null;
     }
-    /** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the current pose as `{ x: number, y: number, width: number, height: number }`.
-     * Note that this method will create temporary objects which can add to garbage collection pressure. Use `getBounds()` if garbage collection is a concern. */
+    /** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the applied pose.
+     * @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB.
+     * @param size An output value, the width and height of the AABB.
+     * @param temp Working memory to temporarily store attachments' computed world vertices. */
     getBoundsRect(clipper) {
-        let offset = new Vector2();
-        let size = new Vector2();
+        const offset = new Vector2();
+        const size = new Vector2();
         this.getBounds(offset, size, undefined, clipper);
         return { x: offset.x, y: offset.y, width: size.x, height: size.y };
     }
-    /** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the current pose.
+    /** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the applied pose. Optionally applies
+     * clipping.
      * @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB.
      * @param size An output value, the width and height of the AABB.
      * @param temp Working memory to temporarily store attachments' computed world vertices.
-     * @param clipper {@link SkeletonClipping} to use. If <code>null</code>, no clipping is applied. */
+     * @param clipper {@link SkeletonClipping} to use. If `null`, no clipping is applied. */
     getBounds(offset, size, temp = new Array(2), clipper = null) {
         if (!offset)
             throw new Error("offset cannot be null.");
         if (!size)
             throw new Error("size cannot be null.");
-        let drawOrder = this.drawOrder;
+        const drawOrder = this.drawOrder.appliedPose;
+        const slots = drawOrder;
         let minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;
         for (let i = 0, n = drawOrder.length; i < n; i++) {
-            let slot = drawOrder[i];
+            const slot = slots[i];
             if (!slot.bone.active)
                 continue;
             let verticesLength = 0;
             let vertices = null;
             let triangles = null;
-            let attachment = slot.getAttachment();
-            if (attachment instanceof RegionAttachment) {
-                verticesLength = 8;
-                vertices = Utils.setArraySize(temp, verticesLength, 0);
-                attachment.computeWorldVertices(slot, vertices, 0, 2);
-                triangles = Skeleton.quadTriangles;
-            }
-            else if (attachment instanceof MeshAttachment) {
-                let mesh = attachment;
-                verticesLength = mesh.worldVerticesLength;
-                vertices = Utils.setArraySize(temp, verticesLength, 0);
-                mesh.computeWorldVertices(slot, 0, verticesLength, vertices, 0, 2);
-                triangles = mesh.triangles;
-            }
-            else if (attachment instanceof ClippingAttachment && clipper != null) {
-                clipper.clipStart(slot, attachment);
-                continue;
-            }
-            if (vertices && triangles) {
-                if (clipper != null && clipper.isClipping()) {
-                    clipper.clipTriangles(vertices, triangles, triangles.length);
-                    vertices = clipper.clippedVertices;
-                    verticesLength = clipper.clippedVertices.length;
+            const attachment = slot.appliedPose.attachment;
+            if (attachment) {
+                if (attachment instanceof RegionAttachment) {
+                    verticesLength = 8;
+                    vertices = Utils.setArraySize(temp, verticesLength, 0);
+                    attachment.computeWorldVertices(slot, attachment.getOffsets(slot.appliedPose), vertices, 0, 2);
+                    triangles = Skeleton.quadTriangles;
                 }
-                for (let ii = 0, nn = vertices.length; ii < nn; ii += 2) {
-                    let x = vertices[ii], y = vertices[ii + 1];
-                    minX = Math.min(minX, x);
-                    minY = Math.min(minY, y);
-                    maxX = Math.max(maxX, x);
-                    maxY = Math.max(maxY, y);
+                else if (attachment instanceof MeshAttachment) {
+                    verticesLength = attachment.worldVerticesLength;
+                    vertices = Utils.setArraySize(temp, verticesLength, 0);
+                    attachment.computeWorldVertices(this, slot, 0, verticesLength, vertices, 0, 2);
+                    triangles = attachment.triangles;
+                }
+                else if (attachment instanceof ClippingAttachment && clipper) {
+                    clipper.clipEnd(slot);
+                    clipper.clipStart(this, slot, attachment);
+                    continue;
+                }
+                if (vertices && triangles) {
+                    if (clipper?.isClipping() && clipper.clipTriangles(vertices, triangles, triangles.length)) {
+                        vertices = clipper.clippedVertices;
+                        verticesLength = clipper.clippedVertices.length;
+                    }
+                    for (let ii = 0, nn = vertices.length; ii < nn; ii += 2) {
+                        const x = vertices[ii], y = vertices[ii + 1];
+                        minX = Math.min(minX, x);
+                        minY = Math.min(minY, y);
+                        maxX = Math.max(maxX, x);
+                        maxY = Math.max(maxY, y);
+                    }
                 }
             }
-            if (clipper != null)
-                clipper.clipEndWithSlot(slot);
+            if (clipper)
+                clipper.clipEnd(slot);
         }
-        if (clipper != null)
+        if (clipper)
             clipper.clipEnd();
         offset.set(minX, minY);
         size.set(maxX - minX, maxY - minY);
     }
-    /** Increments the skeleton's {@link #time}. */
+    /** Scales the entire skeleton on the X and Y axes.
+     *
+     * Bones that do not inherit scale are still affected by this property. */
+    setScale(scaleX, scaleY) {
+        this.scaleX = scaleX;
+        this.scaleY = scaleY;
+    }
+    /** Sets the skeleton X and Y position, which is added to the root bone worldX and worldY position.
+     *
+     * Bones that do not inherit translation are still affected by this property. */
+    setPosition(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    /** Increments the skeleton's {@link time}. */
     update(delta) {
         this.time += delta;
     }
+    /** Calls {@link PhysicsConstraint.translate} for each physics constraint. */
     physicsTranslate(x, y) {
-        const physicsConstraints = this.physicsConstraints;
-        for (let i = 0, n = physicsConstraints.length; i < n; i++)
-            physicsConstraints[i].translate(x, y);
+        const constraints = this.physics;
+        for (let i = 0, n = constraints.length; i < n; i++)
+            constraints[i].translate(x, y);
     }
-    /** Calls {@link PhysicsConstraint#rotate(float, float, float)} for each physics constraint. */
+    /** Calls {@link PhysicsConstraint.rotate} for each physics constraint. */
     physicsRotate(x, y, degrees) {
-        const physicsConstraints = this.physicsConstraints;
-        for (let i = 0, n = physicsConstraints.length; i < n; i++)
-            physicsConstraints[i].rotate(x, y, degrees);
+        const constraints = this.physics;
+        for (let i = 0, n = constraints.length; i < n; i++)
+            constraints[i].rotate(x, y, degrees);
     }
 }
-/** Determines how physics and other non-deterministic updates are applied. */
-export var Physics;
-(function (Physics) {
-    /** Physics are not updated or applied. */
-    Physics[Physics["none"] = 0] = "none";
-    /** Physics are reset to the current pose. */
-    Physics[Physics["reset"] = 1] = "reset";
-    /** Physics are updated and the pose from physics is applied. */
-    Physics[Physics["update"] = 2] = "update";
-    /** Physics are not updated but the pose from physics is applied. */
-    Physics[Physics["pose"] = 3] = "pose";
-})(Physics || (Physics = {}));
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Skeleton.js","sourceRoot":"","sources":["../src/Skeleton.ts"],"names":[],"mappings":"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","sourcesContent":["/******************************************************************************\n * Spine Runtimes License Agreement\n * Last updated April 5, 2025. Replaces all prior versions.\n *\n * Copyright (c) 2013-2025, Esoteric Software LLC\n *\n * Integration of the Spine Runtimes into software or otherwise creating\n * derivative works of the Spine Runtimes is permitted under the terms and\n * conditions of Section 2 of the Spine Editor License Agreement:\n * http://esotericsoftware.com/spine-editor-license\n *\n * Otherwise, it is permitted to integrate the Spine Runtimes into software\n * or otherwise create derivative works of the Spine Runtimes (collectively,\n * \"Products\"), provided that each user of the Products must obtain their own\n * Spine Editor license and redistribution of the Products in any form must\n * include this license and copyright notice.\n *\n * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC \"AS IS\" AND ANY\n * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY\n * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,\n * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND\n * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *****************************************************************************/\n\nimport { Attachment } from \"./attachments/Attachment.js\";\nimport { ClippingAttachment } from \"./attachments/ClippingAttachment.js\";\nimport { MeshAttachment } from \"./attachments/MeshAttachment.js\";\nimport { PathAttachment } from \"./attachments/PathAttachment.js\";\nimport { RegionAttachment } from \"./attachments/RegionAttachment.js\";\nimport { Bone } from \"./Bone.js\";\nimport { IkConstraint } from \"./IkConstraint.js\";\nimport { PathConstraint } from \"./PathConstraint.js\";\nimport { PhysicsConstraint } from \"./PhysicsConstraint.js\";\nimport { SkeletonClipping } from \"./SkeletonClipping.js\";\nimport { SkeletonData } from \"./SkeletonData.js\";\nimport { Skin } from \"./Skin.js\";\nimport { Slot } from \"./Slot.js\";\nimport { TransformConstraint } from \"./TransformConstraint.js\";\nimport { Updatable } from \"./Updatable.js\";\nimport { Color, Utils, MathUtils, Vector2, NumberArrayLike } from \"./Utils.js\";\n\n/** Stores the current pose for a skeleton.\n *\n * See [Instance objects](http://esotericsoftware.com/spine-runtime-architecture#Instance-objects) in the Spine Runtimes Guide. */\nexport class Skeleton {\n\tprivate static quadTriangles = [0, 1, 2, 2, 3, 0];\n\tstatic yDown = false;\n\n\t/** The skeleton's setup pose data. */\n\tdata: SkeletonData;\n\n\t/** The skeleton's bones, sorted parent first. The root bone is always the first bone. */\n\tbones: Array<Bone>;\n\n\t/** The skeleton's slots in the setup pose draw order. */\n\tslots: Array<Slot>;\n\n\t/** The skeleton's slots in the order they should be drawn. The returned array may be modified to change the draw order. */\n\tdrawOrder: Array<Slot>;\n\n\t/** The skeleton's IK constraints. */\n\tikConstraints: Array<IkConstraint>;\n\n\t/** The skeleton's transform constraints. */\n\ttransformConstraints: Array<TransformConstraint>;\n\n\t/** The skeleton's path constraints. */\n\tpathConstraints: Array<PathConstraint>;\n\n\n\t/** The skeleton's physics constraints. */\n\tphysicsConstraints: Array<PhysicsConstraint>;\n\n\t/** The list of bones and constraints, sorted in the order they should be updated, as computed by {@link #updateCache()}. */\n\t_updateCache = new Array<Updatable>();\n\n\t/** The skeleton's current skin. May be null. */\n\tskin: Skin | null = null;\n\n\t/** The color to tint all the skeleton's attachments. */\n\tcolor: Color;\n\n\t/** Scales the entire skeleton on the X axis. This affects all bones, even if the bone's transform mode disallows scale\n\t  * inheritance. */\n\tscaleX = 1;\n\n\t/** Scales the entire skeleton on the Y axis. This affects all bones, even if the bone's transform mode disallows scale\n\t  * inheritance. */\n\tprivate _scaleY = 1;\n\n\tpublic get scaleY () {\n\t\treturn Skeleton.yDown ? -this._scaleY : this._scaleY;\n\t}\n\n\tpublic set scaleY (scaleY: number) {\n\t\tthis._scaleY = scaleY;\n\t}\n\n\t/** Sets the skeleton X position, which is added to the root bone worldX position. */\n\tx = 0;\n\n\t/** Sets the skeleton Y position, which is added to the root bone worldY position. */\n\ty = 0;\n\n\t/** Returns the skeleton's time. This is used for time-based manipulations, such as {@link PhysicsConstraint}.\n\t * <p>\n\t * See {@link #update(float)}. */\n\ttime = 0;\n\n\tconstructor (data: SkeletonData) {\n\t\tif (!data) throw new Error(\"data cannot be null.\");\n\t\tthis.data = data;\n\n\t\tthis.bones = new Array<Bone>();\n\t\tfor (let i = 0; i < data.bones.length; i++) {\n\t\t\tlet boneData = data.bones[i];\n\t\t\tlet bone: Bone;\n\t\t\tif (!boneData.parent)\n\t\t\t\tbone = new Bone(boneData, this, null);\n\t\t\telse {\n\t\t\t\tlet parent = this.bones[boneData.parent.index];\n\t\t\t\tbone = new Bone(boneData, this, parent);\n\t\t\t\tparent.children.push(bone);\n\t\t\t}\n\t\t\tthis.bones.push(bone);\n\t\t}\n\n\t\tthis.slots = new Array<Slot>();\n\t\tthis.drawOrder = new Array<Slot>();\n\t\tfor (let i = 0; i < data.slots.length; i++) {\n\t\t\tlet slotData = data.slots[i];\n\t\t\tlet bone = this.bones[slotData.boneData.index];\n\t\t\tlet slot = new Slot(slotData, bone);\n\t\t\tthis.slots.push(slot);\n\t\t\tthis.drawOrder.push(slot);\n\t\t}\n\n\t\tthis.ikConstraints = new Array<IkConstraint>();\n\t\tfor (let i = 0; i < data.ikConstraints.length; i++) {\n\t\t\tlet ikConstraintData = data.ikConstraints[i];\n\t\t\tthis.ikConstraints.push(new IkConstraint(ikConstraintData, this));\n\t\t}\n\n\t\tthis.transformConstraints = new Array<TransformConstraint>();\n\t\tfor (let i = 0; i < data.transformConstraints.length; i++) {\n\t\t\tlet transformConstraintData = data.transformConstraints[i];\n\t\t\tthis.transformConstraints.push(new TransformConstraint(transformConstraintData, this));\n\t\t}\n\n\t\tthis.pathConstraints = new Array<PathConstraint>();\n\t\tfor (let i = 0; i < data.pathConstraints.length; i++) {\n\t\t\tlet pathConstraintData = data.pathConstraints[i];\n\t\t\tthis.pathConstraints.push(new PathConstraint(pathConstraintData, this));\n\t\t}\n\n\t\tthis.physicsConstraints = new Array<PhysicsConstraint>();\n\t\tfor (let i = 0; i < data.physicsConstraints.length; i++) {\n\t\t\tlet physicsConstraintData = data.physicsConstraints[i];\n\t\t\tthis.physicsConstraints.push(new PhysicsConstraint(physicsConstraintData, this));\n\t\t}\n\n\t\tthis.color = new Color(1, 1, 1, 1);\n\t\tthis.updateCache();\n\t}\n\n\t/** Caches information about bones and constraints. Must be called if the {@link #getSkin()} is modified or if bones,\n\t * constraints, or weighted path attachments are added or removed. */\n\tupdateCache () {\n\t\tlet updateCache = this._updateCache;\n\t\tupdateCache.length = 0;\n\n\t\tlet bones = this.bones;\n\t\tfor (let i = 0, n = bones.length; i < n; i++) {\n\t\t\tlet bone = bones[i];\n\t\t\tbone.sorted = bone.data.skinRequired;\n\t\t\tbone.active = !bone.sorted;\n\t\t}\n\n\t\tif (this.skin) {\n\t\t\tlet skinBones = this.skin.bones;\n\t\t\tfor (let i = 0, n = this.skin.bones.length; i < n; i++) {\n\t\t\t\tlet bone: Bone | null = this.bones[skinBones[i].index];\n\t\t\t\tdo {\n\t\t\t\t\tbone.sorted = false;\n\t\t\t\t\tbone.active = true;\n\t\t\t\t\tbone = bone.parent;\n\t\t\t\t} while (bone);\n\t\t\t}\n\t\t}\n\n\t\t// IK first, lowest hierarchy depth first.\n\t\tlet ikConstraints = this.ikConstraints;\n\t\tlet transformConstraints = this.transformConstraints;\n\t\tlet pathConstraints = this.pathConstraints;\n\t\tlet physicsConstraints = this.physicsConstraints;\n\t\tlet ikCount = ikConstraints.length, transformCount = transformConstraints.length, pathCount = pathConstraints.length, physicsCount = this.physicsConstraints.length;\n\t\tlet constraintCount = ikCount + transformCount + pathCount + physicsCount;\n\n\t\touter:\n\t\tfor (let i = 0; i < constraintCount; i++) {\n\t\t\tfor (let ii = 0; ii < ikCount; ii++) {\n\t\t\t\tlet constraint = ikConstraints[ii];\n\t\t\t\tif (constraint.data.order == i) {\n\t\t\t\t\tthis.sortIkConstraint(constraint);\n\t\t\t\t\tcontinue outer;\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (let ii = 0; ii < transformCount; ii++) {\n\t\t\t\tlet constraint = transformConstraints[ii];\n\t\t\t\tif (constraint.data.order == i) {\n\t\t\t\t\tthis.sortTransformConstraint(constraint);\n\t\t\t\t\tcontinue outer;\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (let ii = 0; ii < pathCount; ii++) {\n\t\t\t\tlet constraint = pathConstraints[ii];\n\t\t\t\tif (constraint.data.order == i) {\n\t\t\t\t\tthis.sortPathConstraint(constraint);\n\t\t\t\t\tcontinue outer;\n\t\t\t\t}\n\t\t\t}\n\t\t\tfor (let ii = 0; ii < physicsCount; ii++) {\n\t\t\t\tconst constraint = physicsConstraints[ii];\n\t\t\t\tif (constraint.data.order == i) {\n\t\t\t\t\tthis.sortPhysicsConstraint(constraint);\n\t\t\t\t\tcontinue outer;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tfor (let i = 0, n = bones.length; i < n; i++)\n\t\t\tthis.sortBone(bones[i]);\n\t}\n\n\tsortIkConstraint (constraint: IkConstraint) {\n\t\tconstraint.active = constraint.target.isActive() && (!constraint.data.skinRequired || (this.skin && Utils.contains(this.skin.constraints, constraint.data, true)))!;\n\t\tif (!constraint.active) return;\n\n\t\tlet target = constraint.target;\n\t\tthis.sortBone(target);\n\n\t\tlet constrained = constraint.bones;\n\t\tlet parent = constrained[0];\n\t\tthis.sortBone(parent);\n\n\t\tif (constrained.length == 1) {\n\t\t\tthis._updateCache.push(constraint);\n\t\t\tthis.sortReset(parent.children);\n\t\t} else {\n\t\t\tlet child = constrained[constrained.length - 1];\n\t\t\tthis.sortBone(child);\n\n\t\t\tthis._updateCache.push(constraint);\n\n\t\t\tthis.sortReset(parent.children);\n\t\t\tchild.sorted = true;\n\t\t}\n\t}\n\n\tsortPathConstraint (constraint: PathConstraint) {\n\t\tconstraint.active = constraint.target.bone.isActive() && (!constraint.data.skinRequired || (this.skin && Utils.contains(this.skin.constraints, constraint.data, true)))!;\n\t\tif (!constraint.active) return;\n\n\t\tlet slot = constraint.target;\n\t\tlet slotIndex = slot.data.index;\n\t\tlet slotBone = slot.bone;\n\t\tif (this.skin) this.sortPathConstraintAttachment(this.skin, slotIndex, slotBone);\n\t\tif (this.data.defaultSkin && this.data.defaultSkin != this.skin)\n\t\t\tthis.sortPathConstraintAttachment(this.data.defaultSkin, slotIndex, slotBone);\n\t\tfor (let i = 0, n = this.data.skins.length; i < n; i++)\n\t\t\tthis.sortPathConstraintAttachment(this.data.skins[i], slotIndex, slotBone);\n\n\t\tlet attachment = slot.getAttachment();\n\t\tif (attachment instanceof PathAttachment) this.sortPathConstraintAttachmentWith(attachment, slotBone);\n\n\t\tlet constrained = constraint.bones;\n\t\tlet boneCount = constrained.length;\n\t\tfor (let i = 0; i < boneCount; i++)\n\t\t\tthis.sortBone(constrained[i]);\n\n\t\tthis._updateCache.push(constraint);\n\n\t\tfor (let i = 0; i < boneCount; i++)\n\t\t\tthis.sortReset(constrained[i].children);\n\t\tfor (let i = 0; i < boneCount; i++)\n\t\t\tconstrained[i].sorted = true;\n\t}\n\n\tsortTransformConstraint (constraint: TransformConstraint) {\n\t\tconstraint.active = constraint.target.isActive() && (!constraint.data.skinRequired || (this.skin && Utils.contains(this.skin.constraints, constraint.data, true)))!;\n\t\tif (!constraint.active) return;\n\n\t\tthis.sortBone(constraint.target);\n\n\t\tlet constrained = constraint.bones;\n\t\tlet boneCount = constrained.length;\n\t\tif (constraint.data.local) {\n\t\t\tfor (let i = 0; i < boneCount; i++) {\n\t\t\t\tlet child = constrained[i];\n\t\t\t\tthis.sortBone(child.parent!);\n\t\t\t\tthis.sortBone(child);\n\t\t\t}\n\t\t} else {\n\t\t\tfor (let i = 0; i < boneCount; i++) {\n\t\t\t\tthis.sortBone(constrained[i]);\n\t\t\t}\n\t\t}\n\n\t\tthis._updateCache.push(constraint);\n\n\t\tfor (let i = 0; i < boneCount; i++)\n\t\t\tthis.sortReset(constrained[i].children);\n\t\tfor (let i = 0; i < boneCount; i++)\n\t\t\tconstrained[i].sorted = true;\n\t}\n\n\tsortPathConstraintAttachment (skin: Skin, slotIndex: number, slotBone: Bone) {\n\t\tlet attachments = skin.attachments[slotIndex];\n\t\tif (!attachments) return;\n\t\tfor (let key in attachments) {\n\t\t\tthis.sortPathConstraintAttachmentWith(attachments[key], slotBone);\n\t\t}\n\t}\n\n\tsortPathConstraintAttachmentWith (attachment: Attachment, slotBone: Bone) {\n\t\tif (!(attachment instanceof PathAttachment)) return;\n\t\tlet pathBones = (<PathAttachment>attachment).bones;\n\t\tif (!pathBones)\n\t\t\tthis.sortBone(slotBone);\n\t\telse {\n\t\t\tlet bones = this.bones;\n\t\t\tfor (let i = 0, n = pathBones.length; i < n;) {\n\t\t\t\tlet nn = pathBones[i++];\n\t\t\t\tnn += i;\n\t\t\t\twhile (i < nn)\n\t\t\t\t\tthis.sortBone(bones[pathBones[i++]]);\n\t\t\t}\n\t\t}\n\t}\n\n\tsortPhysicsConstraint (constraint: PhysicsConstraint) {\n\t\tconst bone = constraint.bone;\n\t\tconstraint.active = bone.active && (!constraint.data.skinRequired || (this.skin != null && Utils.contains(this.skin.constraints, constraint.data, true)));\n\t\tif (!constraint.active) return;\n\n\t\tthis.sortBone(bone);\n\n\t\tthis._updateCache.push(constraint);\n\n\t\tthis.sortReset(bone.children);\n\t\tbone.sorted = true;\n\t}\n\n\tsortBone (bone: Bone) {\n\t\tif (!bone) return;\n\t\tif (bone.sorted) return;\n\t\tlet parent = bone.parent;\n\t\tif (parent) this.sortBone(parent);\n\t\tbone.sorted = true;\n\t\tthis._updateCache.push(bone);\n\t}\n\n\tsortReset (bones: Array<Bone>) {\n\t\tfor (let i = 0, n = bones.length; i < n; i++) {\n\t\t\tlet bone = bones[i];\n\t\t\tif (!bone.active) continue;\n\t\t\tif (bone.sorted) this.sortReset(bone.children);\n\t\t\tbone.sorted = false;\n\t\t}\n\t}\n\n\t/** Updates the world transform for each bone and applies all constraints.\n\t *\n\t * See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine\n\t * Runtimes Guide. */\n\tupdateWorldTransform (physics: Physics) {\n\t\tif (physics === undefined || physics === null) throw new Error(\"physics is undefined\");\n\t\tlet bones = this.bones;\n\t\tfor (let i = 0, n = bones.length; i < n; i++) {\n\t\t\tlet bone = bones[i];\n\t\t\tbone.ax = bone.x;\n\t\t\tbone.ay = bone.y;\n\t\t\tbone.arotation = bone.rotation;\n\t\t\tbone.ascaleX = bone.scaleX;\n\t\t\tbone.ascaleY = bone.scaleY;\n\t\t\tbone.ashearX = bone.shearX;\n\t\t\tbone.ashearY = bone.shearY;\n\t\t}\n\n\t\tlet updateCache = this._updateCache;\n\t\tfor (let i = 0, n = updateCache.length; i < n; i++)\n\t\t\tupdateCache[i].update(physics);\n\t}\n\n\tupdateWorldTransformWith (physics: Physics, parent: Bone) {\n\t\tif (!parent) throw new Error(\"parent cannot be null.\");\n\n\t\tlet bones = this.bones;\n\t\tfor (let i = 1, n = bones.length; i < n; i++) { // Skip root bone.\n\t\t\tlet bone = bones[i];\n\t\t\tbone.ax = bone.x;\n\t\t\tbone.ay = bone.y;\n\t\t\tbone.arotation = bone.rotation;\n\t\t\tbone.ascaleX = bone.scaleX;\n\t\t\tbone.ascaleY = bone.scaleY;\n\t\t\tbone.ashearX = bone.shearX;\n\t\t\tbone.ashearY = bone.shearY;\n\t\t}\n\n\t\t// Apply the parent bone transform to the root bone. The root bone always inherits scale, rotation and reflection.\n\t\tlet rootBone = this.getRootBone();\n\t\tif (!rootBone) throw new Error(\"Root bone must not be null.\");\n\t\tlet pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d;\n\t\trootBone.worldX = pa * this.x + pb * this.y + parent.worldX;\n\t\trootBone.worldY = pc * this.x + pd * this.y + parent.worldY;\n\n\t\tconst rx = (rootBone.rotation + rootBone.shearX) * MathUtils.degRad;\n\t\tconst ry = (rootBone.rotation + 90 + rootBone.shearY) * MathUtils.degRad;\n\t\tconst la = Math.cos(rx) * rootBone.scaleX;\n\t\tconst lb = Math.cos(ry) * rootBone.scaleY;\n\t\tconst lc = Math.sin(rx) * rootBone.scaleX;\n\t\tconst ld = Math.sin(ry) * rootBone.scaleY;\n\t\trootBone.a = (pa * la + pb * lc) * this.scaleX;\n\t\trootBone.b = (pa * lb + pb * ld) * this.scaleX;\n\t\trootBone.c = (pc * la + pd * lc) * this.scaleY;\n\t\trootBone.d = (pc * lb + pd * ld) * this.scaleY;\n\n\t\t// Update everything except root bone.\n\t\tlet updateCache = this._updateCache;\n\t\tfor (let i = 0, n = updateCache.length; i < n; i++) {\n\t\t\tlet updatable = updateCache[i];\n\t\t\tif (updatable != rootBone) updatable.update(physics);\n\t\t}\n\t}\n\n\t/** Sets the bones, constraints, and slots to their setup pose values. */\n\tsetToSetupPose () {\n\t\tthis.setBonesToSetupPose();\n\t\tthis.setSlotsToSetupPose();\n\t}\n\n\t/** Sets the bones and constraints to their setup pose values. */\n\tsetBonesToSetupPose () {\n\t\tfor (const bone of this.bones) bone.setToSetupPose();\n\t\tfor (const constraint of this.ikConstraints) constraint.setToSetupPose();\n\t\tfor (const constraint of this.transformConstraints) constraint.setToSetupPose();\n\t\tfor (const constraint of this.pathConstraints) constraint.setToSetupPose();\n\t\tfor (const constraint of this.physicsConstraints) constraint.setToSetupPose();\n\t}\n\n\t/** Sets the slots and draw order to their setup pose values. */\n\tsetSlotsToSetupPose () {\n\t\tlet slots = this.slots;\n\t\tUtils.arrayCopy(slots, 0, this.drawOrder, 0, slots.length);\n\t\tfor (let i = 0, n = slots.length; i < n; i++)\n\t\t\tslots[i].setToSetupPose();\n\t}\n\n\t/** @returns May return null. */\n\tgetRootBone () {\n\t\tif (this.bones.length == 0) return null;\n\t\treturn this.bones[0];\n\t}\n\n\t/** @returns May be null. */\n\tfindBone (boneName: string) {\n\t\tif (!boneName) throw new Error(\"boneName cannot be null.\");\n\t\tlet bones = this.bones;\n\t\tfor (let i = 0, n = bones.length; i < n; i++) {\n\t\t\tlet bone = bones[i];\n\t\t\tif (bone.data.name == boneName) return bone;\n\t\t}\n\t\treturn null;\n\t}\n\n\t/** Finds a slot by comparing each slot's name. It is more efficient to cache the results of this method than to call it\n\t * repeatedly.\n\t * @returns May be null. */\n\tfindSlot (slotName: string) {\n\t\tif (!slotName) throw new Error(\"slotName cannot be null.\");\n\t\tlet slots = this.slots;\n\t\tfor (let i = 0, n = slots.length; i < n; i++) {\n\t\t\tlet slot = slots[i];\n\t\t\tif (slot.data.name == slotName) return slot;\n\t\t}\n\t\treturn null;\n\t}\n\n\t/** Sets a skin by name.\n\t *\n\t * See {@link #setSkin()}. */\n\tsetSkinByName (skinName: string) {\n\t\tlet skin = this.data.findSkin(skinName);\n\t\tif (!skin) throw new Error(\"Skin not found: \" + skinName);\n\t\tthis.setSkin(skin);\n\t}\n\n\t/** Sets the skin used to look up attachments before looking in the {@link SkeletonData#defaultSkin default skin}. If the\n\t * skin is changed, {@link #updateCache()} is called.\n\t *\n\t * Attachments from the new skin are attached if the corresponding attachment from the old skin was attached. If there was no\n\t * old skin, each slot's setup mode attachment is attached from the new skin.\n\t *\n\t * After changing the skin, the visible attachments can be reset to those attached in the setup pose by calling\n\t * {@link #setSlotsToSetupPose()}. Also, often {@link AnimationState#apply()} is called before the next time the\n\t * skeleton is rendered to allow any attachment keys in the current animation(s) to hide or show attachments from the new skin.\n\t * @param newSkin May be null. */\n\tsetSkin (newSkin: Skin | null) {\n\t\tif (newSkin == this.skin) return;\n\t\tif (newSkin) {\n\t\t\tif (this.skin)\n\t\t\t\tnewSkin.attachAll(this, this.skin);\n\t\t\telse {\n\t\t\t\tlet slots = this.slots;\n\t\t\t\tfor (let i = 0, n = slots.length; i < n; i++) {\n\t\t\t\t\tlet slot = slots[i];\n\t\t\t\t\tlet name = slot.data.attachmentName;\n\t\t\t\t\tif (name) {\n\t\t\t\t\t\tlet attachment = newSkin.getAttachment(i, name);\n\t\t\t\t\t\tif (attachment) slot.setAttachment(attachment);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.skin = newSkin;\n\t\tthis.updateCache();\n\t}\n\n\n\t/** Finds an attachment by looking in the {@link #skin} and {@link SkeletonData#defaultSkin} using the slot name and attachment\n\t * name.\n\t *\n\t * See {@link #getAttachment()}.\n\t * @returns May be null. */\n\tgetAttachmentByName (slotName: string, attachmentName: string): Attachment | null {\n\t\tlet slot = this.data.findSlot(slotName);\n\t\tif (!slot) throw new Error(`Can't find slot with name ${slotName}`);\n\t\treturn this.getAttachment(slot.index, attachmentName);\n\t}\n\n\t/** Finds an attachment by looking in the {@link #skin} and {@link SkeletonData#defaultSkin} using the slot index and\n\t * attachment name. First the skin is checked and if the attachment was not found, the default skin is checked.\n\t *\n\t * See [Runtime skins](http://esotericsoftware.com/spine-runtime-skins) in the Spine Runtimes Guide.\n\t * @returns May be null. */\n\tgetAttachment (slotIndex: number, attachmentName: string): Attachment | null {\n\t\tif (!attachmentName) throw new Error(\"attachmentName cannot be null.\");\n\t\tif (this.skin) {\n\t\t\tlet attachment = this.skin.getAttachment(slotIndex, attachmentName);\n\t\t\tif (attachment) return attachment;\n\t\t}\n\t\tif (this.data.defaultSkin) return this.data.defaultSkin.getAttachment(slotIndex, attachmentName);\n\t\treturn null;\n\t}\n\n\t/** A convenience method to set an attachment by finding the slot with {@link #findSlot()}, finding the attachment with\n\t * {@link #getAttachment()}, then setting the slot's {@link Slot#attachment}.\n\t * @param attachmentName May be null to clear the slot's attachment. */\n\tsetAttachment (slotName: string, attachmentName: string) {\n\t\tif (!slotName) throw new Error(\"slotName cannot be null.\");\n\t\tlet slots = this.slots;\n\t\tfor (let i = 0, n = slots.length; i < n; i++) {\n\t\t\tlet slot = slots[i];\n\t\t\tif (slot.data.name == slotName) {\n\t\t\t\tlet attachment: Attachment | null = null;\n\t\t\t\tif (attachmentName) {\n\t\t\t\t\tattachment = this.getAttachment(i, attachmentName);\n\t\t\t\t\tif (!attachment) throw new Error(\"Attachment not found: \" + attachmentName + \", for slot: \" + slotName);\n\t\t\t\t}\n\t\t\t\tslot.setAttachment(attachment);\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t\tthrow new Error(\"Slot not found: \" + slotName);\n\t}\n\n\n\t/** Finds an IK constraint by comparing each IK constraint's name. It is more efficient to cache the results of this method\n\t * than to call it repeatedly.\n\t * @return May be null. */\n\tfindIkConstraint (constraintName: string) {\n\t\tif (!constraintName) throw new Error(\"constraintName cannot be null.\");\n\t\treturn this.ikConstraints.find((constraint) => constraint.data.name == constraintName) ?? null;\n\t}\n\n\t/** Finds a transform constraint by comparing each transform constraint's name. It is more efficient to cache the results of\n\t * this method than to call it repeatedly.\n\t * @return May be null. */\n\tfindTransformConstraint (constraintName: string) {\n\t\tif (!constraintName) throw new Error(\"constraintName cannot be null.\");\n\t\treturn this.transformConstraints.find((constraint) => constraint.data.name == constraintName) ?? null;\n\t}\n\n\t/** Finds a path constraint by comparing each path constraint's name. It is more efficient to cache the results of this method\n\t * than to call it repeatedly.\n\t * @return May be null. */\n\tfindPathConstraint (constraintName: string) {\n\t\tif (!constraintName) throw new Error(\"constraintName cannot be null.\");\n\t\treturn this.pathConstraints.find((constraint) => constraint.data.name == constraintName) ?? null;\n\t}\n\n\t/** Finds a physics constraint by comparing each physics constraint's name. It is more efficient to cache the results of this\n\t * method than to call it repeatedly. */\n\tfindPhysicsConstraint (constraintName: string) {\n\t\tif (constraintName == null) throw new Error(\"constraintName cannot be null.\");\n\t\treturn this.physicsConstraints.find((constraint) => constraint.data.name == constraintName) ?? null;\n\t}\n\n\t/** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the current pose as `{ x: number, y: number, width: number, height: number }`.\n\t * Note that this method will create temporary objects which can add to garbage collection pressure. Use `getBounds()` if garbage collection is a concern. */\n\tgetBoundsRect (clipper?: SkeletonClipping) {\n\t\tlet offset = new Vector2();\n\t\tlet size = new Vector2();\n\t\tthis.getBounds(offset, size, undefined, clipper);\n\t\treturn { x: offset.x, y: offset.y, width: size.x, height: size.y };\n\t}\n\n\t/** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the current pose.\n\t * @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB.\n\t * @param size An output value, the width and height of the AABB.\n\t * @param temp Working memory to temporarily store attachments' computed world vertices.\n\t * @param clipper {@link SkeletonClipping} to use. If <code>null</code>, no clipping is applied. */\n\tgetBounds (offset: Vector2, size: Vector2, temp: Array<number> = new Array<number>(2), clipper: SkeletonClipping | null = null) {\n\t\tif (!offset) throw new Error(\"offset cannot be null.\");\n\t\tif (!size) throw new Error(\"size cannot be null.\");\n\t\tlet drawOrder = this.drawOrder;\n\t\tlet minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;\n\t\tfor (let i = 0, n = drawOrder.length; i < n; i++) {\n\t\t\tlet slot = drawOrder[i];\n\t\t\tif (!slot.bone.active) continue;\n\t\t\tlet verticesLength = 0;\n\t\t\tlet vertices: NumberArrayLike | null = null;\n\t\t\tlet triangles: NumberArrayLike | null = null;\n\t\t\tlet attachment = slot.getAttachment();\n\t\t\tif (attachment instanceof RegionAttachment) {\n\t\t\t\tverticesLength = 8;\n\t\t\t\tvertices = Utils.setArraySize(temp, verticesLength, 0);\n\t\t\t\tattachment.computeWorldVertices(slot, vertices, 0, 2);\n\t\t\t\ttriangles = Skeleton.quadTriangles;\n\t\t\t} else if (attachment instanceof MeshAttachment) {\n\t\t\t\tlet mesh = (<MeshAttachment>attachment);\n\t\t\t\tverticesLength = mesh.worldVerticesLength;\n\t\t\t\tvertices = Utils.setArraySize(temp, verticesLength, 0);\n\t\t\t\tmesh.computeWorldVertices(slot, 0, verticesLength, vertices, 0, 2);\n\t\t\t\ttriangles = mesh.triangles;\n\t\t\t} else if (attachment instanceof ClippingAttachment && clipper != null) {\n\t\t\t\tclipper.clipStart(slot, attachment);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif (vertices && triangles) {\n\t\t\t\tif (clipper != null && clipper.isClipping()) {\n\t\t\t\t\tclipper.clipTriangles(vertices, triangles, triangles.length);\n\t\t\t\t\tvertices = clipper.clippedVertices;\n\t\t\t\t\tverticesLength = clipper.clippedVertices.length;\n\t\t\t\t}\n\t\t\t\tfor (let ii = 0, nn = vertices.length; ii < nn; ii += 2) {\n\t\t\t\t\tlet x = vertices[ii], y = vertices[ii + 1];\n\t\t\t\t\tminX = Math.min(minX, x);\n\t\t\t\t\tminY = Math.min(minY, y);\n\t\t\t\t\tmaxX = Math.max(maxX, x);\n\t\t\t\t\tmaxY = Math.max(maxY, y);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (clipper != null) clipper.clipEndWithSlot(slot);\n\t\t}\n\t\tif (clipper != null) clipper.clipEnd();\n\t\toffset.set(minX, minY);\n\t\tsize.set(maxX - minX, maxY - minY);\n\t}\n\n\t/** Increments the skeleton's {@link #time}. */\n\tupdate (delta: number) {\n\t\tthis.time += delta;\n\t}\n\n\tphysicsTranslate (x: number, y: number) {\n\t\tconst physicsConstraints = this.physicsConstraints;\n\t\tfor (let i = 0, n = physicsConstraints.length; i < n; i++)\n\t\t\tphysicsConstraints[i].translate(x, y);\n\t}\n\n\t/** Calls {@link PhysicsConstraint#rotate(float, float, float)} for each physics constraint. */\n\tphysicsRotate (x: number, y: number, degrees: number) {\n\t\tconst physicsConstraints = this.physicsConstraints;\n\t\tfor (let i = 0, n = physicsConstraints.length; i < n; i++)\n\t\t\tphysicsConstraints[i].rotate(x, y, degrees);\n\t}\n}\n\n/** Determines how physics and other non-deterministic updates are applied. */\nexport enum Physics {\n\t/** Physics are not updated or applied. */\n\tnone,\n\n\t/** Physics are reset to the current pose. */\n\treset,\n\n\t/** Physics are updated and the pose from physics is applied. */\n\tupdate,\n\n\t/** Physics are not updated but the pose from physics is applied. */\n\tpose\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Skeleton.js","sourceRoot":"","sources":["../src/Skeleton.ts"],"names":[],"mappings":"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","sourcesContent":["/******************************************************************************\n * Spine Runtimes License Agreement\n * Last updated April 5, 2025. Replaces all prior versions.\n *\n * Copyright (c) 2013-2025, Esoteric Software LLC\n *\n * Integration of the Spine Runtimes into software or otherwise creating\n * derivative works of the Spine Runtimes is permitted under the terms and\n * conditions of Section 2 of the Spine Editor License Agreement:\n * http://esotericsoftware.com/spine-editor-license\n *\n * Otherwise, it is permitted to integrate the Spine Runtimes into software\n * or otherwise create derivative works of the Spine Runtimes (collectively,\n * \"Products\"), provided that each user of the Products must obtain their own\n * Spine Editor license and redistribution of the Products in any form must\n * include this license and copyright notice.\n *\n * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC \"AS IS\" AND ANY\n * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED\n * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY\n * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES\n * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,\n * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND\n * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT\n * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF\n * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *****************************************************************************/\n\nimport type { AnimationState } from \"./AnimationState.js\";\nimport type { Attachment } from \"./attachments/Attachment.js\";\nimport { ClippingAttachment } from \"./attachments/ClippingAttachment.js\";\nimport { MeshAttachment } from \"./attachments/MeshAttachment.js\";\nimport { RegionAttachment } from \"./attachments/RegionAttachment.js\";\nimport { Bone } from \"./Bone.js\";\nimport type { Constraint } from \"./Constraint.js\";\nimport { DrawOrder } from \"./DrawOrder.js\";\nimport type { Physics } from \"./Physics.js\";\nimport { PhysicsConstraint } from \"./PhysicsConstraint.js\";\nimport type { PhysicsConstraintPose } from \"./PhysicsConstraintPose.js\";\nimport type { Posed } from \"./Posed.js\";\nimport type { SkeletonClipping } from \"./SkeletonClipping.js\";\nimport type { SkeletonData } from \"./SkeletonData.js\";\nimport type { Skin } from \"./Skin.js\";\nimport { Slot } from \"./Slot.js\";\nimport { Color, type NumberArrayLike, Utils, Vector2 } from \"./Utils.js\";\n\n/** Stores bones and slots to be posed by animations and application code. Multiple skeleton instances can share the same\n * {@link SkeletonData}, including animations, attachments, and skins.\n *\n * After posing, call {@link updateWorldTransform} to apply constraints and compute world transforms for rendering.\n *\n * See [Instance objects](http://esotericsoftware.com/spine-runtime-architecture#Instance-objects) in the Spine Runtimes Guide. */\nexport class Skeleton {\n\tprivate static quadTriangles = [0, 1, 2, 2, 3, 0];\n\tstatic yDown = false;\n\tstatic get yDir (): number {\n\t\treturn Skeleton.yDown ? -1 : 1;\n\t}\n\n\t/** The skeleton's setup pose data. */\n\treadonly data: SkeletonData;\n\n\t/** The skeleton's bones, sorted parent first. The root bone is always the first bone. */\n\treadonly bones: Array<Bone>;\n\n\t/** The skeleton's slots. To add a slot, also add it to {@link DrawOrder.pose}. */\n\treadonly slots: Array<Slot>;\n\n\t/** The skeleton's draw order. Use {@link DrawOrder.appliedPose} for rendering and {@link DrawOrder.pose} for changing the draw\n\t * order. */\n\treadonly drawOrder: DrawOrder;\n\n\t/** The skeleton's constraints. */\n\t// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types\n\treadonly constraints: Array<Constraint<any, any, any>>;\n\n\t/** The skeleton's physics constraints. */\n\treadonly physics: Array<PhysicsConstraint>;\n\n\t/** The list of bones and constraints, sorted in the order they should be updated, as computed by {@link updateCache}. */\n\t// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types\n\treadonly _updateCache = [] as any[];\n\n\t// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types\n\treadonly resetCache: Array<Posed<any, any>> = [];\n\n\t/** The skeleton's current skin. May be null. */\n\tskin: Skin | null = null;\n\n\t/** The color to tint all the skeleton's attachments. */\n\treadonly color: Color;\n\n\t/** Scales the entire skeleton on the X axis.\n\t *\n\t * Bones that do not inherit scale are still affected by this property. */\n\tscaleX = 1;\n\n\tprivate _scaleY = 1;\n\n\t/** Scales the entire skeleton on the Y axis.\n\t *\n\t * Bones that do not inherit scale are still affected by this property. */\n\tpublic get scaleY () {\n\t\treturn this._scaleY * Skeleton.yDir;\n\t}\n\n\tpublic set scaleY (scaleY: number) {\n\t\tthis._scaleY = scaleY;\n\t}\n\n\t/** Sets the skeleton X position, which is added to the root bone worldX position.\n\t *\n\t * Bones that do not inherit translation are still affected by this property. */\n\tx = 0;\n\n\t/** Sets the skeleton Y position, which is added to the root bone worldY position.\n\t *\n\t * Bones that do not inherit translation are still affected by this property. */\n\ty = 0;\n\n\t/** Returns the skeleton's time, is used for time-based manipulations, such as {@link PhysicsConstraint}.\n\t *\n\t * See {@link _update}. */\n\ttime = 0;\n\n\t/** The x component of a vector that defines the direction {@link PhysicsConstraintPose.wind} is applied. */\n\twindX = 1;\n\n\t/** The y component of a vector that defines the direction {@link PhysicsConstraintPose.wind} is applied. */\n\twindY = 0;\n\n\t/** The x component of a vector that defines the direction {@link PhysicsConstraintPose.gravity} is applied. */\n\tgravityX = 0;\n\n\t/** The y component of a vector that defines the direction {@link PhysicsConstraintPose.gravity} is applied. */\n\tgravityY = 1;\n\n\t_update = 0;\n\n\tconstructor (data: SkeletonData) {\n\t\tif (!data) throw new Error(\"data cannot be null.\");\n\t\tthis.data = data;\n\n\t\tthis.bones = [] as Bone[];\n\t\tfor (let i = 0; i < data.bones.length; i++) {\n\t\t\tconst boneData = data.bones[i];\n\t\t\tlet bone: Bone;\n\t\t\tif (!boneData.parent)\n\t\t\t\tbone = new Bone(boneData, null);\n\t\t\telse {\n\t\t\t\tconst parent = this.bones[boneData.parent.index];\n\t\t\t\tbone = new Bone(boneData, parent);\n\t\t\t\tparent.children.push(bone);\n\t\t\t}\n\t\t\tthis.bones.push(bone);\n\t\t}\n\n\t\tthis.slots = [] as Slot[];\n\t\tfor (const slotData of this.data.slots)\n\t\t\tthis.slots.push(new Slot(slotData, this));\n\t\tthis.drawOrder = new DrawOrder(this.slots);\n\n\t\tthis.physics = [] as PhysicsConstraint[];\n\t\t// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types\n\t\tthis.constraints = [] as Constraint<any, any, any>[];\n\t\tfor (const constraintData of this.data.constraints) {\n\t\t\tconst constraint = constraintData.create(this);\n\t\t\tif (constraint instanceof PhysicsConstraint) this.physics.push(constraint);\n\t\t\tthis.constraints.push(constraint);\n\t\t}\n\n\t\tthis.color = new Color(1, 1, 1, 1);\n\n\t\tthis.updateCache();\n\t}\n\n\t/** Caches information about bones and constraints. Must be called if the {@link skin} is modified or if bones, constraints,\n\t * or weighted path attachments are added or removed. */\n\tupdateCache () {\n\t\tthis._updateCache.length = 0;\n\t\tthis.resetCache.length = 0;\n\n\t\tthis.drawOrder.unconstrained();\n\t\tconst slots = this.slots;\n\t\tfor (let i = 0, n = slots.length; i < n; i++)\n\t\t\tslots[i].unconstrained();\n\n\t\tconst bones = this.bones;\n\t\tconst boneCount = bones.length;\n\t\tfor (let i = 0, n = boneCount; i < n; i++) {\n\t\t\tconst bone = bones[i];\n\t\t\tbone.sorted = bone.data.skinRequired;\n\t\t\tbone.active = !bone.sorted;\n\t\t\tbone.unconstrained();\n\t\t}\n\t\tif (this.skin) {\n\t\t\tconst skinBones = this.skin.bones;\n\t\t\tfor (let i = 0, n = this.skin.bones.length; i < n; i++) {\n\t\t\t\tlet bone: Bone | null = this.bones[skinBones[i].index];\n\t\t\t\tdo {\n\t\t\t\t\tbone.sorted = false;\n\t\t\t\t\tbone.active = true;\n\t\t\t\t\tbone = bone.parent;\n\t\t\t\t} while (bone);\n\t\t\t}\n\t\t}\n\n\t\tconst constraints = this.constraints;\n\t\tlet n = this.constraints.length;\n\t\tfor (let i = 0; i < n; i++)\n\t\t\tconstraints[i].unconstrained();\n\t\tfor (let i = 0; i < n; i++) {\n\t\t\tconst constraint = constraints[i];\n\t\t\tconstraint.active = constraint.isSourceActive()\n\t\t\t\t// biome-ignore lint/complexity/useOptionalChain: changing to this might return undefined\n\t\t\t\t&& (!constraint.data.skinRequired || (this.skin != null && this.skin.constraints.includes(constraint.data)));\n\t\t\tif (constraint.active) constraint.sort(this);\n\t\t}\n\n\t\tfor (let i = 0; i < boneCount; i++)\n\t\t\tthis.sortBone(bones[i]);\n\n\t\tn = this._updateCache.length;\n\t\tfor (let i = 0; i < n; i++) {\n\t\t\tconst updateable = this._updateCache[i];\n\t\t\tif (updateable instanceof Bone) this._updateCache[i] = updateable.appliedPose;\n\t\t}\n\n\t}\n\n\t// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types\n\tconstrained (object: Posed<any, any>) {\n\t\tif (object.pose === object.appliedPose) {\n\t\t\tobject.constrained();\n\t\t\tthis.resetCache.push(object);\n\t\t}\n\t}\n\n\tsortBone (bone: Bone) {\n\t\tif (bone.sorted || !bone.active) return;\n\t\tconst parent = bone.parent;\n\t\tif (parent) this.sortBone(parent);\n\t\tbone.sorted = true;\n\t\tthis._updateCache.push(bone);\n\t}\n\n\tsortReset (bones: Array<Bone>) {\n\t\tfor (let i = 0, n = bones.length; i < n; i++) {\n\t\t\tconst bone = bones[i];\n\t\t\tif (bone.active) {\n\t\t\t\tif (bone.sorted) this.sortReset(bone.children);\n\t\t\t\tbone.sorted = false;\n\t\t\t}\n\t\t}\n\t}\n\n\t/** Updates the world transform for each bone and applies all constraints.\n\t *\n\t * See <a href=\"https://esotericsoftware.com/spine-runtime-skeletons#World-transforms\">World transforms</a> in the Spine\n\t * Runtimes Guide. */\n\tupdateWorldTransform (physics: Physics): void {\n\t\tthis._update++;\n\n\t\tif (this.drawOrder.appliedPose === this.drawOrder.constrainedPose) this.drawOrder.resetConstrained();\n\t\tconst resetCache = this.resetCache;\n\t\tfor (let i = 0, n = this.resetCache.length; i < n; i++)\n\t\t\tresetCache[i].resetConstrained();\n\n\t\tconst updateCache = this._updateCache;\n\t\tfor (let i = 0, n = this._updateCache.length; i < n; i++)\n\t\t\tupdateCache[i].update(this, physics);\n\t}\n\n\t/** Sets the bones, constraints, and slots to their setup pose values. */\n\tsetupPose () {\n\t\tthis.setupPoseBones();\n\t\tthis.setupPoseSlots();\n\t}\n\n\t/** Sets the bones and constraints to their setup pose values. */\n\tsetupPoseBones () {\n\t\tconst bones = this.bones;\n\t\tfor (let i = 0, n = bones.length; i < n; i++)\n\t\t\tbones[i].setupPose();\n\n\t\tconst constraints = this.constraints;\n\t\tfor (let i = 0, n = constraints.length; i < n; i++)\n\t\t\tconstraints[i].setupPose();\n\t}\n\n\t/** Sets the slots and draw order to their setup pose values. */\n\tsetupPoseSlots () {\n\t\tthis.drawOrder.setupPose();\n\t\tconst slots = this.slots;\n\t\tfor (let i = 0, n = slots.length; i < n; i++)\n\t\t\tslots[i].setupPose();\n\t}\n\n\t/** Returns the root bone, or null if the skeleton has no bones. */\n\tgetRootBone () {\n\t\tif (this.bones.length === 0) return null;\n\t\treturn this.bones[0];\n\t}\n\n\t/** Finds a bone by comparing each bone's name. It is more efficient to cache the results of this method than to call it\n\t * repeatedly. */\n\tfindBone (boneName: string) {\n\t\tif (!boneName) throw new Error(\"boneName cannot be null.\");\n\t\tconst bones = this.bones;\n\t\tfor (let i = 0, n = bones.length; i < n; i++)\n\t\t\tif (bones[i].data.name === boneName) return bones[i];\n\t\treturn null;\n\t}\n\n\t/** Finds a slot by comparing each slot's name. It is more efficient to cache the results of this method than to call it\n\t * repeatedly. */\n\tfindSlot (slotName: string) {\n\t\tif (!slotName) throw new Error(\"slotName cannot be null.\");\n\t\tconst slots = this.slots;\n\t\tfor (let i = 0, n = slots.length; i < n; i++)\n\t\t\tif (slots[i].data.name === slotName) return slots[i];\n\t\treturn null;\n\t}\n\n\t/** Sets a skin by name.\n\t *\n\t * See {@link setSkin}. */\n\tsetSkin (skinName: string): void;\n\n\t/** Sets the skin used to look up attachments before looking in {@link SkeletonData.defaultSkin}. If the skin is changed,\n\t * {@link updateCache} is called.\n\t *\n\t * Attachments from the new skin are attached if the corresponding attachment from the old skin was attached. If there was no\n\t * old skin, each slot's setup mode attachment is attached from the new skin.\n\t *\n\t * After changing the skin, the visible attachments can be reset to those attached in the setup pose by calling\n\t * {@link setupPoseSlots}. Also, often {@link AnimationState.apply} is called before the next time the skeleton is\n\t * rendered to allow any attachment keys in the current animation(s) to hide or show attachments from the new skin. */\n\tsetSkin (newSkin: Skin | null): void;\n\n\tsetSkin (newSkin: Skin | null | string): void {\n\t\tif (typeof newSkin === \"string\")\n\t\t\tthis.setSkinByName(newSkin);\n\t\telse\n\t\t\tthis.setSkinBySkin(newSkin);\n\t};\n\n\tprivate setSkinByName (skinName: string) {\n\t\tconst skin = this.data.findSkin(skinName);\n\t\tif (!skin) throw new Error(`Skin not found: ${skinName}`);\n\t\tthis.setSkin(skin);\n\t}\n\n\tprivate setSkinBySkin (newSkin: Skin | null) {\n\t\tif (newSkin === this.skin) return;\n\t\tif (newSkin) {\n\t\t\tif (this.skin)\n\t\t\t\tnewSkin.attachAll(this, this.skin);\n\t\t\telse {\n\t\t\t\tconst slots = this.slots;\n\t\t\t\tfor (let i = 0, n = slots.length; i < n; i++) {\n\t\t\t\t\tconst slot = slots[i];\n\t\t\t\t\tconst name = slot.data.attachmentName;\n\t\t\t\t\tif (name) {\n\t\t\t\t\t\tconst attachment = newSkin.getAttachment(i, name);\n\t\t\t\t\t\tif (attachment) slot.pose.setAttachment(attachment);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tthis.skin = newSkin;\n\t\tthis.updateCache();\n\t}\n\n\t/** Finds an attachment by looking in the {@link skin} and {@link SkeletonData.defaultSkin} using the slot name and attachment\n\t * name.\n\t *\n\t * See {@link getAttachment}. */\n\tgetAttachment (slotName: string, placeholder: string): Attachment | null;\n\n\t/** Finds an attachment by looking in the {@link skin} and {@link SkeletonData.defaultSkin} using the slot index and\n\t * attachment name. First the skin is checked and if the attachment was not found, the default skin is checked.\n\t *\n\t * See <a href=\"https://esotericsoftware.com/spine-runtime-skins\">Runtime skins</a> in the Spine Runtimes Guide. */\n\tgetAttachment (slotIndex: number, placeholder: string): Attachment | null;\n\n\tgetAttachment (slotNameOrIndex: string | number, placeholder: string): Attachment | null {\n\t\tif (typeof slotNameOrIndex === 'string')\n\t\t\treturn this.getAttachmentByName(slotNameOrIndex, placeholder);\n\t\treturn this.getAttachmentByIndex(slotNameOrIndex, placeholder);\n\t}\n\n\t/** Finds an attachment by looking in the {@link skin} and {@link SkeletonData.defaultSkin} using the slot name and attachment\n\t * name.\n\t *\n\t * See {@link getAttachment}.\n\t * @returns May be null. */\n\tprivate getAttachmentByName (slotName: string, placeholder: string): Attachment | null {\n\t\tconst slot = this.data.findSlot(slotName);\n\t\tif (!slot) throw new Error(`Can't find slot with name ${slotName}`);\n\t\treturn this.getAttachment(slot.index, placeholder);\n\t}\n\n\t/** Finds an attachment by looking in the {@link skin} and {@link SkeletonData.defaultSkin} using the slot index and\n\t * attachment name. First the skin is checked and if the attachment was not found, the default skin is checked.\n\t *\n\t * See [Runtime skins](http://esotericsoftware.com/spine-runtime-skins) in the Spine Runtimes Guide.\n\t * @returns May be null. */\n\tprivate getAttachmentByIndex (slotIndex: number, placeholder: string): Attachment | null {\n\t\tif (!placeholder) throw new Error(\"placeholder cannot be null.\");\n\t\tif (this.skin) {\n\t\t\tconst attachment = this.skin.getAttachment(slotIndex, placeholder);\n\t\t\tif (attachment) return attachment;\n\t\t}\n\t\tif (this.data.defaultSkin) return this.data.defaultSkin.getAttachment(slotIndex, placeholder);\n\t\treturn null;\n\t}\n\n\t/** A convenience method to set an attachment by finding the slot with {@link findSlot}, finding the attachment with\n\t * {@link getAttachment}, then setting the slot's {@link Slot.attachment}.\n\t * @param placeholder May be null to clear the slot's attachment. */\n\tsetAttachment (slotName: string, placeholder: string | null) {\n\t\tif (!slotName) throw new Error(\"slotName cannot be null.\");\n\t\tconst slot = this.findSlot(slotName);\n\t\tif (!slot) throw new Error(`Slot not found: ${slotName}`);\n\t\tlet attachment: Attachment | null = null;\n\t\tif (placeholder) {\n\t\t\tattachment = this.getAttachment(slot.data.index, placeholder);\n\t\t\tif (!attachment)\n\t\t\t\tthrow new Error(`Attachment not found: ${placeholder}, for slot: ${slotName}`);\n\t\t}\n\t\tslot.pose.setAttachment(attachment);\n\t}\n\n\t/** Finds a constraint of the specified type by comparing each constraints's name. It is more efficient to cache the results of\n\t * this method than to call it multiple times. */\n\t// biome-ignore lint/suspicious/noExplicitAny: reference runtime does not restrict to specific types\n\tfindConstraint<T extends Constraint<any, any, any>> (constraintName: string, type: new () => T): T | null {\n\t\tif (constraintName == null) throw new Error(\"constraintName cannot be null.\");\n\t\tif (type == null) throw new Error(\"type cannot be null.\");\n\t\tconst constraints = this.constraints;\n\t\tfor (let i = 0, n = constraints.length; i < n; i++) {\n\t\t\tconst constraint = constraints[i];\n\t\t\tif (constraint instanceof type && constraint.data.name === constraintName) return constraint as T;\n\t\t}\n\t\treturn null;\n\t}\n\n\t/** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the applied pose.\n\t * @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB.\n\t * @param size An output value, the width and height of the AABB.\n\t * @param temp Working memory to temporarily store attachments' computed world vertices. */\n\tgetBoundsRect (clipper?: SkeletonClipping) {\n\t\tconst offset = new Vector2();\n\t\tconst size = new Vector2();\n\t\tthis.getBounds(offset, size, undefined, clipper);\n\t\treturn { x: offset.x, y: offset.y, width: size.x, height: size.y };\n\t}\n\n\t/** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the applied pose. Optionally applies\n\t * clipping.\n\t * @param offset An output value, the distance from the skeleton origin to the bottom left corner of the AABB.\n\t * @param size An output value, the width and height of the AABB.\n\t * @param temp Working memory to temporarily store attachments' computed world vertices.\n\t * @param clipper {@link SkeletonClipping} to use. If `null`, no clipping is applied. */\n\tgetBounds (offset: Vector2, size: Vector2, temp: Array<number> = new Array<number>(2), clipper: SkeletonClipping | null = null) {\n\t\tif (!offset) throw new Error(\"offset cannot be null.\");\n\t\tif (!size) throw new Error(\"size cannot be null.\");\n\t\tconst drawOrder = this.drawOrder.appliedPose;\n\t\tconst slots = drawOrder;\n\t\tlet minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;\n\t\tfor (let i = 0, n = drawOrder.length; i < n; i++) {\n\t\t\tconst slot = slots[i];\n\t\t\tif (!slot.bone.active) continue;\n\t\t\tlet verticesLength = 0;\n\t\t\tlet vertices: NumberArrayLike | null = null;\n\t\t\tlet triangles: NumberArrayLike | null = null;\n\t\t\tconst attachment = slot.appliedPose.attachment;\n\t\t\tif (attachment) {\n\t\t\t\tif (attachment instanceof RegionAttachment) {\n\t\t\t\t\tverticesLength = 8;\n\t\t\t\t\tvertices = Utils.setArraySize(temp, verticesLength, 0);\n\t\t\t\t\tattachment.computeWorldVertices(slot, attachment.getOffsets(slot.appliedPose), vertices, 0, 2);\n\t\t\t\t\ttriangles = Skeleton.quadTriangles;\n\t\t\t\t} else if (attachment instanceof MeshAttachment) {\n\t\t\t\t\tverticesLength = attachment.worldVerticesLength;\n\t\t\t\t\tvertices = Utils.setArraySize(temp, verticesLength, 0);\n\t\t\t\t\tattachment.computeWorldVertices(this, slot, 0, verticesLength, vertices, 0, 2);\n\t\t\t\t\ttriangles = attachment.triangles;\n\t\t\t\t} else if (attachment instanceof ClippingAttachment && clipper) {\n\t\t\t\t\tclipper.clipEnd(slot);\n\t\t\t\t\tclipper.clipStart(this, slot, attachment);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tif (vertices && triangles) {\n\t\t\t\t\tif (clipper?.isClipping() && clipper.clipTriangles(vertices, triangles, triangles.length)) {\n\t\t\t\t\t\tvertices = clipper.clippedVertices;\n\t\t\t\t\t\tverticesLength = clipper.clippedVertices.length;\n\t\t\t\t\t}\n\t\t\t\t\tfor (let ii = 0, nn = vertices.length; ii < nn; ii += 2) {\n\t\t\t\t\t\tconst x = vertices[ii], y = vertices[ii + 1];\n\t\t\t\t\t\tminX = Math.min(minX, x);\n\t\t\t\t\t\tminY = Math.min(minY, y);\n\t\t\t\t\t\tmaxX = Math.max(maxX, x);\n\t\t\t\t\t\tmaxY = Math.max(maxY, y);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (clipper) clipper.clipEnd(slot);\n\t\t}\n\t\tif (clipper) clipper.clipEnd();\n\t\toffset.set(minX, minY);\n\t\tsize.set(maxX - minX, maxY - minY);\n\t}\n\n\t/** Scales the entire skeleton on the X and Y axes.\n\t *\n\t * Bones that do not inherit scale are still affected by this property. */\n\tpublic setScale (scaleX: number, scaleY: number) {\n\t\tthis.scaleX = scaleX;\n\t\tthis.scaleY = scaleY;\n\t}\n\n\t/** Sets the skeleton X and Y position, which is added to the root bone worldX and worldY position.\n\t *\n\t * Bones that do not inherit translation are still affected by this property. */\n\tpublic setPosition (x: number, y: number) {\n\t\tthis.x = x;\n\t\tthis.y = y;\n\t}\n\n\t/** Increments the skeleton's {@link time}. */\n\tupdate (delta: number) {\n\t\tthis.time += delta;\n\t}\n\n\t/** Calls {@link PhysicsConstraint.translate} for each physics constraint. */\n\tphysicsTranslate (x: number, y: number) {\n\t\tconst constraints = this.physics;\n\t\tfor (let i = 0, n = constraints.length; i < n; i++)\n\t\t\tconstraints[i].translate(x, y);\n\t}\n\n\t/** Calls {@link PhysicsConstraint.rotate} for each physics constraint. */\n\tphysicsRotate (x: number, y: number, degrees: number) {\n\t\tconst constraints = this.physics;\n\t\tfor (let i = 0, n = constraints.length; i < n; i++)\n\t\t\tconstraints[i].rotate(x, y, degrees);\n\t}\n}\n"]}