@esotericsoftware/spine-pixi-v8 4.2.63

package/dist/Spine.js

@@ -0,0 +1,629 @@
+/** ****************************************************************************
+ * Spine Runtimes License Agreement
+ * Last updated July 28, 2023. Replaces all prior versions.
+ *
+ * Copyright (c) 2013-2023, Esoteric Software LLC
+ *
+ * Integration of the Spine Runtimes into software or otherwise creating
+ * derivative works of the Spine Runtimes is permitted under the terms and
+ * conditions of Section 2 of the Spine Editor License Agreement:
+ * http://esotericsoftware.com/spine-editor-license
+ *
+ * Otherwise, it is permitted to integrate the Spine Runtimes into software or
+ * otherwise create derivative works of the Spine Runtimes (collectively,
+ * "Products"), provided that each user of the Products must obtain their own
+ * Spine Editor license and redistribution of the Products in any form must
+ * include this license and copyright notice.
+ *
+ * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
+ * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE
+ * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *****************************************************************************/
+import { Assets, Cache, Container, DEG_TO_RAD, fastCopy, Graphics, Texture, Ticker, ViewContainer, } from 'pixi.js';
+import { AnimationState, AnimationStateData, AtlasAttachmentLoader, ClippingAttachment, Color, MeshAttachment, Physics, Pool, RegionAttachment, Skeleton, SkeletonBinary, SkeletonBounds, SkeletonClipping, SkeletonData, SkeletonJson, Vector2, } from '@esotericsoftware/spine-core';
+;
+const vectorAux = new Vector2();
+Skeleton.yDown = true;
+const clipper = new SkeletonClipping();
+;
+const maskPool = new Pool(() => new Graphics);
+/**
+ * The class to instantiate a {@link Spine} game object in Pixi.
+ * The static method {@link Spine.from} should be used to instantiate a Spine game object.
+ */
+export class Spine extends ViewContainer {
+    // Pixi properties
+    batched = true;
+    buildId = 0;
+    renderPipeId = 'spine';
+    _didSpineUpdate = false;
+    beforeUpdateWorldTransforms = () => { };
+    afterUpdateWorldTransforms = () => { };
+    // Spine properties
+    /** The skeleton for this Spine game object. */
+    skeleton;
+    /** The animation state for this Spine game object. */
+    state;
+    skeletonBounds;
+    darkTint = false;
+    _debug = undefined;
+    _slotsObject = Object.create(null);
+    clippingSlotToPixiMasks = Object.create(null);
+    getSlotFromRef(slotRef) {
+        let slot;
+        if (typeof slotRef === 'number')
+            slot = this.skeleton.slots[slotRef];
+        else if (typeof slotRef === 'string')
+            slot = this.skeleton.findSlot(slotRef);
+        else
+            slot = slotRef;
+        if (!slot)
+            throw new Error(`No slot found with the given slot reference: ${slotRef}`);
+        return slot;
+    }
+    spineAttachmentsDirty = true;
+    spineTexturesDirty = true;
+    _lastAttachments = [];
+    _stateChanged = true;
+    attachmentCacheData = [];
+    get debug() {
+        return this._debug;
+    }
+    /** Pass a {@link SpineDebugRenderer} or create your own {@link ISpineDebugRenderer} to render bones, meshes, ...
+     * @example spineGO.debug = new SpineDebugRenderer();
+     */
+    set debug(value) {
+        if (this._debug) {
+            this._debug.unregisterSpine(this);
+        }
+        if (value) {
+            value.registerSpine(this);
+        }
+        this._debug = value;
+    }
+    autoUpdateWarned = false;
+    _autoUpdate = true;
+    get autoUpdate() {
+        return this._autoUpdate;
+    }
+    /** When `true`, the Spine AnimationState and the Skeleton will be automatically updated using the {@link Ticker.shared} instance. */
+    set autoUpdate(value) {
+        if (value) {
+            Ticker.shared.add(this.internalUpdate, this);
+            this.autoUpdateWarned = false;
+        }
+        else {
+            Ticker.shared.remove(this.internalUpdate, this);
+        }
+        this._autoUpdate = value;
+    }
+    constructor(options) {
+        if (options instanceof SkeletonData) {
+            options = {
+                skeletonData: options,
+            };
+        }
+        super();
+        const skeletonData = options instanceof SkeletonData ? options : options.skeletonData;
+        this.skeleton = new Skeleton(skeletonData);
+        this.state = new AnimationState(new AnimationStateData(skeletonData));
+        this.autoUpdate = options?.autoUpdate ?? true;
+        // dark tint can be enabled by options, otherwise is enable if at least one slot has tint black
+        this.darkTint = options?.darkTint === undefined
+            ? this.skeleton.slots.some(slot => !!slot.data.darkColor)
+            : options?.darkTint;
+        const slots = this.skeleton.slots;
+        for (let i = 0; i < slots.length; i++) {
+            this.attachmentCacheData[i] = Object.create(null);
+        }
+        this._updateState(0);
+    }
+    /** If {@link Spine.autoUpdate} is `false`, this method allows to update the AnimationState and the Skeleton with the given delta. */
+    update(dt) {
+        if (this.autoUpdate && !this.autoUpdateWarned) {
+            console.warn('You are calling update on a Spine instance that has autoUpdate set to true. This is probably not what you want.');
+            this.autoUpdateWarned = true;
+        }
+        this.internalUpdate(0, dt);
+    }
+    internalUpdate(_deltaFrame, deltaSeconds) {
+        // Because reasons, pixi uses deltaFrames at 60fps.
+        // We ignore the default deltaFrames and use the deltaSeconds from pixi ticker.
+        this._updateState(deltaSeconds ?? Ticker.shared.deltaMS / 1000);
+    }
+    get bounds() {
+        if (this._boundsDirty) {
+            this.updateBounds();
+        }
+        return this._bounds;
+    }
+    /**
+     * Set the position of the bone given in input through a {@link IPointData}.
+     * @param bone: the bone name or the bone instance to set the position
+     * @param outPos: the new position of the bone.
+     * @throws {Error}: if the given bone is not found in the skeleton, an error is thrown
+     */
+    setBonePosition(bone, position) {
+        const boneAux = bone;
+        if (typeof bone === 'string') {
+            bone = this.skeleton.findBone(bone);
+        }
+        if (!bone)
+            throw Error(`Cant set bone position, bone ${String(boneAux)} not found`);
+        vectorAux.set(position.x, position.y);
+        if (bone.parent) {
+            const aux = bone.parent.worldToLocal(vectorAux);
+            bone.x = aux.x;
+            bone.y = -aux.y;
+        }
+        else {
+            bone.x = vectorAux.x;
+            bone.y = vectorAux.y;
+        }
+    }
+    /**
+     * Return the position of the bone given in input into an {@link IPointData}.
+     * @param bone: the bone name or the bone instance to get the position from
+     * @param outPos: an optional {@link IPointData} to use to return the bone position, rathern than instantiating a new object.
+     * @returns {IPointData | undefined}: the position of the bone, or undefined if no matching bone is found in the skeleton
+     */
+    getBonePosition(bone, outPos) {
+        const boneAux = bone;
+        if (typeof bone === 'string') {
+            bone = this.skeleton.findBone(bone);
+        }
+        if (!bone) {
+            console.error(`Cant set bone position! Bone ${String(boneAux)} not found`);
+            return outPos;
+        }
+        if (!outPos) {
+            outPos = { x: 0, y: 0 };
+        }
+        outPos.x = bone.worldX;
+        outPos.y = bone.worldY;
+        return outPos;
+    }
+    /**
+     * Will update the state based on the specified time, this will not apply the state to the skeleton
+     * as this is differed until the `applyState` method is called.
+     *
+     * @param time the time at which to set the state
+     * @internal
+     */
+    _updateState(time) {
+        this.state.update(time);
+        this.skeleton.update(time);
+        this._stateChanged = true;
+        this._boundsDirty = true;
+        this.onViewUpdate();
+    }
+    /**
+     * Applies the state to this spine instance.
+     * - updates the state to the skeleton
+     * - updates its world transform (spine world transform)
+     * - validates the attachments - to flag if the attachments have changed this state
+     * - transforms the attachments - to update the vertices of the attachments based on the new positions
+     * - update the slot attachments - to update the position, rotation, scale, and visibility of the attached containers
+     * @internal
+     */
+    _applyState() {
+        if (!this._stateChanged)
+            return;
+        this._stateChanged = false;
+        const { skeleton } = this;
+        this.state.apply(skeleton);
+        this.beforeUpdateWorldTransforms(this);
+        skeleton.updateWorldTransform(Physics.update);
+        this.afterUpdateWorldTransforms(this);
+        this.validateAttachments();
+        this.transformAttachments();
+        this.updateSlotObjects();
+    }
+    validateAttachments() {
+        const currentDrawOrder = this.skeleton.drawOrder;
+        const lastAttachments = this._lastAttachments;
+        let index = 0;
+        let spineAttachmentsDirty = false;
+        for (let i = 0; i < currentDrawOrder.length; i++) {
+            const slot = currentDrawOrder[i];
+            const attachment = slot.getAttachment();
+            if (attachment) {
+                if (attachment !== lastAttachments[index]) {
+                    spineAttachmentsDirty = true;
+                    lastAttachments[index] = attachment;
+                }
+                index++;
+            }
+        }
+        if (index !== lastAttachments.length) {
+            spineAttachmentsDirty = true;
+            lastAttachments.length = index;
+        }
+        this.spineAttachmentsDirty = spineAttachmentsDirty;
+    }
+    updateAndSetPixiMask(slot, last) {
+        // assign/create the currentClippingSlot
+        const attachment = slot.attachment;
+        if (attachment && attachment instanceof ClippingAttachment) {
+            const clip = (this.clippingSlotToPixiMasks[slot.data.name] ||= { slot, vertices: new Array() });
+            clip.maskComputed = false;
+            this.currentClippingSlot = this.clippingSlotToPixiMasks[slot.data.name];
+            return;
+        }
+        // assign the currentClippingSlot mask to the slot object
+        let currentClippingSlot = this.currentClippingSlot;
+        let slotObject = this._slotsObject[slot.data.name];
+        if (currentClippingSlot && slotObject) {
+            let slotClipping = currentClippingSlot.slot;
+            let clippingAttachment = slotClipping.attachment;
+            // create the pixi mask, only the first time and if the clipped slot is the first one clipped by this currentClippingSlot
+            let mask = currentClippingSlot.mask;
+            if (!mask) {
+                mask = maskPool.obtain();
+                currentClippingSlot.mask = mask;
+                this.addChild(mask);
+            }
+            // compute the pixi mask polygon, if the clipped slot is the first one clipped by this currentClippingSlot
+            if (!currentClippingSlot.maskComputed) {
+                currentClippingSlot.maskComputed = true;
+                const worldVerticesLength = clippingAttachment.worldVerticesLength;
+                const vertices = currentClippingSlot.vertices;
+                clippingAttachment.computeWorldVertices(slotClipping, 0, worldVerticesLength, vertices, 0, 2);
+                mask.clear().poly(vertices).stroke({ width: 0 }).fill({ alpha: .25 });
+            }
+            slotObject.container.mask = mask;
+        }
+        else if (slotObject?.container.mask) {
+            // remove the mask, if slot object has a mask, but currentClippingSlot is undefined
+            slotObject.container.mask = null;
+        }
+        // if current slot is the ending one of the currentClippingSlot mask, set currentClippingSlot to undefined
+        if (currentClippingSlot && currentClippingSlot.slot.attachment.endSlot == slot.data) {
+            this.currentClippingSlot = undefined;
+        }
+        // clean up unused masks
+        if (last) {
+            for (const key in this.clippingSlotToPixiMasks) {
+                const clippingSlotToPixiMask = this.clippingSlotToPixiMasks[key];
+                if ((!(clippingSlotToPixiMask.slot.attachment instanceof ClippingAttachment) || !clippingSlotToPixiMask.maskComputed) && clippingSlotToPixiMask.mask) {
+                    this.removeChild(clippingSlotToPixiMask.mask);
+                    maskPool.free(clippingSlotToPixiMask.mask);
+                    clippingSlotToPixiMask.mask = undefined;
+                }
+            }
+        }
+    }
+    currentClippingSlot;
+    transformAttachments() {
+        const currentDrawOrder = this.skeleton.drawOrder;
+        for (let i = 0; i < currentDrawOrder.length; i++) {
+            const slot = currentDrawOrder[i];
+            this.updateAndSetPixiMask(slot, i === currentDrawOrder.length - 1);
+            const attachment = slot.getAttachment();
+            if (attachment) {
+                if (attachment instanceof MeshAttachment || attachment instanceof RegionAttachment) {
+                    const cacheData = this._getCachedData(slot, attachment);
+                    if (attachment instanceof RegionAttachment) {
+                        attachment.computeWorldVertices(slot, cacheData.vertices, 0, 2);
+                    }
+                    else {
+                        attachment.computeWorldVertices(slot, 0, attachment.worldVerticesLength, cacheData.vertices, 0, 2);
+                    }
+                    fastCopy(attachment.uvs.buffer, cacheData.uvs.buffer);
+                    const skeleton = slot.bone.skeleton;
+                    const skeletonColor = skeleton.color;
+                    const slotColor = slot.color;
+                    const attachmentColor = attachment.color;
+                    cacheData.color.set(skeletonColor.r * slotColor.r * attachmentColor.r, skeletonColor.g * slotColor.g * attachmentColor.g, skeletonColor.b * slotColor.b * attachmentColor.b, skeletonColor.a * slotColor.a * attachmentColor.a);
+                    if (slot.darkColor) {
+                        cacheData.darkColor.setFromColor(slot.darkColor);
+                    }
+                    cacheData.skipRender = cacheData.clipped = false;
+                    const texture = attachment.region?.texture.texture || Texture.EMPTY;
+                    if (cacheData.texture !== texture) {
+                        cacheData.texture = texture;
+                        this.spineTexturesDirty = true;
+                    }
+                    if (clipper.isClipping()) {
+                        this.updateClippingData(cacheData);
+                    }
+                }
+                else if (attachment instanceof ClippingAttachment) {
+                    clipper.clipStart(slot, attachment);
+                    continue;
+                }
+            }
+            clipper.clipEndWithSlot(slot);
+        }
+        clipper.clipEnd();
+    }
+    updateClippingData(cacheData) {
+        cacheData.clipped = true;
+        clipper.clipTrianglesUnpacked(cacheData.vertices, cacheData.indices, cacheData.indices.length, cacheData.uvs);
+        const { clippedVertices, clippedUVs, clippedTriangles } = clipper;
+        const verticesCount = clippedVertices.length / 2;
+        const indicesCount = clippedTriangles.length;
+        if (!cacheData.clippedData) {
+            cacheData.clippedData = {
+                vertices: new Float32Array(verticesCount * 2),
+                uvs: new Float32Array(verticesCount * 2),
+                vertexCount: verticesCount,
+                indices: new Uint16Array(indicesCount),
+                indicesCount,
+            };
+            this.spineAttachmentsDirty = true;
+        }
+        const clippedData = cacheData.clippedData;
+        const sizeChange = clippedData.vertexCount !== verticesCount || indicesCount !== clippedData.indicesCount;
+        cacheData.skipRender = verticesCount === 0;
+        if (sizeChange) {
+            this.spineAttachmentsDirty = true;
+            if (clippedData.vertexCount < verticesCount) {
+                // buffer reuse!
+                clippedData.vertices = new Float32Array(verticesCount * 2);
+                clippedData.uvs = new Float32Array(verticesCount * 2);
+            }
+            if (clippedData.indices.length < indicesCount) {
+                clippedData.indices = new Uint16Array(indicesCount);
+            }
+        }
+        const { vertices, uvs, indices } = clippedData;
+        for (let i = 0; i < verticesCount; i++) {
+            vertices[i * 2] = clippedVertices[i * 2];
+            vertices[(i * 2) + 1] = clippedVertices[(i * 2) + 1];
+            uvs[i * 2] = clippedUVs[(i * 2)];
+            uvs[(i * 2) + 1] = clippedUVs[(i * 2) + 1];
+        }
+        clippedData.vertexCount = verticesCount;
+        for (let i = 0; i < indicesCount; i++) {
+            if (indices[i] !== clippedTriangles[i]) {
+                this.spineAttachmentsDirty = true;
+                indices[i] = clippedTriangles[i];
+            }
+        }
+        clippedData.indicesCount = indicesCount;
+    }
+    /**
+     * ensure that attached containers map correctly to their slots
+     * along with their position, rotation, scale, and visibility.
+     */
+    updateSlotObjects() {
+        for (const i in this._slotsObject) {
+            const slotAttachment = this._slotsObject[i];
+            if (!slotAttachment)
+                continue;
+            this.updateSlotObject(slotAttachment);
+        }
+    }
+    updateSlotObject(slotAttachment) {
+        const { slot, container } = slotAttachment;
+        container.visible = this.skeleton.drawOrder.includes(slot);
+        if (container.visible) {
+            const bone = slot.bone;
+            container.position.set(bone.worldX, bone.worldY);
+            container.scale.x = bone.getWorldScaleX();
+            container.scale.y = bone.getWorldScaleY();
+            container.rotation = bone.getWorldRotationX() * DEG_TO_RAD;
+            container.alpha = this.skeleton.color.a * slot.color.a;
+        }
+    }
+    /** @internal */
+    _getCachedData(slot, attachment) {
+        return this.attachmentCacheData[slot.data.index][attachment.name] || this.initCachedData(slot, attachment);
+    }
+    initCachedData(slot, attachment) {
+        let vertices;
+        if (attachment instanceof RegionAttachment) {
+            vertices = new Float32Array(8);
+            this.attachmentCacheData[slot.data.index][attachment.name] = {
+                id: `${slot.data.index}-${attachment.name}`,
+                vertices,
+                clipped: false,
+                indices: [0, 1, 2, 0, 2, 3],
+                uvs: new Float32Array(attachment.uvs.length),
+                color: new Color(1, 1, 1, 1),
+                darkColor: new Color(0, 0, 0, 0),
+                darkTint: this.darkTint,
+                skipRender: false,
+                texture: attachment.region?.texture.texture,
+            };
+        }
+        else {
+            vertices = new Float32Array(attachment.worldVerticesLength);
+            this.attachmentCacheData[slot.data.index][attachment.name] = {
+                id: `${slot.data.index}-${attachment.name}`,
+                vertices,
+                clipped: false,
+                indices: attachment.triangles,
+                uvs: new Float32Array(attachment.uvs.length),
+                color: new Color(1, 1, 1, 1),
+                darkColor: new Color(0, 0, 0, 0),
+                darkTint: this.darkTint,
+                skipRender: false,
+                texture: attachment.region?.texture.texture,
+            };
+        }
+        return this.attachmentCacheData[slot.data.index][attachment.name];
+    }
+    onViewUpdate() {
+        // increment from the 12th bit!
+        this._didChangeId += 1 << 12;
+        this._boundsDirty = true;
+        if (this.didViewUpdate)
+            return;
+        this.didViewUpdate = true;
+        const renderGroup = this.renderGroup || this.parentRenderGroup;
+        if (renderGroup) {
+            renderGroup.onChildViewUpdate(this);
+        }
+        this.debug?.renderDebug(this);
+    }
+    /**
+     * Attaches a PixiJS container to a specified slot. This will map the world transform of the slots bone
+     * to the attached container. A container can only be attached to one slot at a time.
+     *
+     * @param container - The container to attach to the slot
+     * @param slotRef - The slot id or  slot to attach to
+     */
+    addSlotObject(slot, container) {
+        slot = this.getSlotFromRef(slot);
+        // need to check in on the container too...
+        for (const i in this._slotsObject) {
+            if (this._slotsObject[i]?.container === container) {
+                this.removeSlotObject(this._slotsObject[i].slot);
+            }
+        }
+        this.removeSlotObject(slot);
+        container.includeInBuild = false;
+        // TODO only add once??
+        this.addChild(container);
+        const slotObject = { container, slot };
+        this._slotsObject[slot.data.name] = slotObject;
+        this.updateSlotObject(slotObject);
+    }
+    /**
+     * Removes a PixiJS container from the slot it is attached to.
+     *
+     * @param container - The container to detach from the slot
+     * @param slotOrContainer - The container, slot id or slot to detach from
+     */
+    removeSlotObject(slotOrContainer) {
+        let containerToRemove;
+        if (slotOrContainer instanceof Container) {
+            for (const i in this._slotsObject) {
+                if (this._slotsObject[i]?.container === slotOrContainer) {
+                    this._slotsObject[i] = null;
+                    containerToRemove = slotOrContainer;
+                    break;
+                }
+            }
+        }
+        else {
+            const slot = this.getSlotFromRef(slotOrContainer);
+            containerToRemove = this._slotsObject[slot.data.name]?.container;
+            this._slotsObject[slot.data.name] = null;
+        }
+        if (containerToRemove) {
+            this.removeChild(containerToRemove);
+            containerToRemove.includeInBuild = true;
+        }
+    }
+    /**
+     * Returns a container attached to a slot, or undefined if no container is attached.
+     *
+     * @param slotRef - The slot id or slot to get the attachment from
+     * @returns - The container attached to the slot
+     */
+    getSlotObject(slot) {
+        slot = this.getSlotFromRef(slot);
+        return this._slotsObject[slot.data.name]?.container;
+    }
+    updateBounds() {
+        this._boundsDirty = false;
+        this.skeletonBounds ||= new SkeletonBounds();
+        const skeletonBounds = this.skeletonBounds;
+        skeletonBounds.update(this.skeleton, true);
+        if (skeletonBounds.minX === Infinity) {
+            this._applyState();
+            const drawOrder = this.skeleton.drawOrder;
+            const bounds = this._bounds;
+            bounds.clear();
+            for (let i = 0; i < drawOrder.length; i++) {
+                const slot = drawOrder[i];
+                const attachment = slot.getAttachment();
+                if (attachment && (attachment instanceof RegionAttachment || attachment instanceof MeshAttachment)) {
+                    const cacheData = this._getCachedData(slot, attachment);
+                    bounds.addVertexData(cacheData.vertices, 0, cacheData.vertices.length);
+                }
+            }
+        }
+        else {
+            this._bounds.minX = skeletonBounds.minX;
+            this._bounds.minY = skeletonBounds.minY;
+            this._bounds.maxX = skeletonBounds.maxX;
+            this._bounds.maxY = skeletonBounds.maxY;
+        }
+    }
+    /** @internal */
+    addBounds(bounds) {
+        bounds.addBounds(this.bounds);
+    }
+    /**
+     * Destroys this sprite renderable and optionally its texture.
+     * @param options - Options parameter. A boolean will act as if all options
+     *  have been set to that value
+     * @param {boolean} [options.texture=false] - Should it destroy the current texture of the renderable as well
+     * @param {boolean} [options.textureSource=false] - Should it destroy the textureSource of the renderable as well
+     */
+    destroy(options = false) {
+        super.destroy(options);
+        Ticker.shared.remove(this.internalUpdate, this);
+        this.state.clearListeners();
+        this.debug = undefined;
+        this.skeleton = null;
+        this.state = null;
+        this._slotsObject = null;
+        this._lastAttachments.length = 0;
+        this.attachmentCacheData = null;
+    }
+    /** Converts a point from the skeleton coordinate system to the Pixi world coordinate system. */
+    skeletonToPixiWorldCoordinates(point) {
+        this.worldTransform.apply(point, point);
+    }
+    /** Converts a point from the Pixi world coordinate system to the skeleton coordinate system. */
+    pixiWorldCoordinatesToSkeleton(point) {
+        this.worldTransform.applyInverse(point, point);
+    }
+    /** Converts a point from the Pixi world coordinate system to the bone's local coordinate system. */
+    pixiWorldCoordinatesToBone(point, bone) {
+        this.pixiWorldCoordinatesToSkeleton(point);
+        if (bone.parent) {
+            bone.parent.worldToLocal(point);
+        }
+        else {
+            bone.worldToLocal(point);
+        }
+    }
+    /**
+     * Use this method to instantiate a Spine game object.
+     * Before instantiating a Spine game object, the skeleton (`.skel` or `.json`) and the atlas text files must be loaded into the Assets. For example:
+     * ```
+     * PIXI.Assets.add("sackData", "./assets/sack-pro.skel");
+     * PIXI.Assets.add("sackAtlas", "./assets/sack-pma.atlas");
+     * await PIXI.Assets.load(["sackData", "sackAtlas"]);
+     * ```
+     * Once a Spine game object is created, its skeleton data is cached into {@link Cache} using the key:
+     * `${skeletonAssetName}-${atlasAssetName}-${options?.scale ?? 1}`
+     *
+     * @param options - Options to configure the Spine game object. See {@link SpineFromOptions}
+     * @returns {Spine} The Spine game object instantiated
+     */
+    static from({ skeleton, atlas, scale = 1, darkTint, autoUpdate = true }) {
+        const cacheKey = `${skeleton}-${atlas}-${scale}`;
+        if (Cache.has(cacheKey)) {
+            return new Spine(Cache.get(cacheKey));
+        }
+        const skeletonAsset = Assets.get(skeleton);
+        const atlasAsset = Assets.get(atlas);
+        const attachmentLoader = new AtlasAttachmentLoader(atlasAsset);
+        const parser = skeletonAsset instanceof Uint8Array
+            ? new SkeletonBinary(attachmentLoader)
+            : new SkeletonJson(attachmentLoader);
+        parser.scale = scale;
+        const skeletonData = parser.readSkeletonData(skeletonAsset);
+        Cache.set(cacheKey, skeletonData);
+        return new Spine({
+            skeletonData,
+            darkTint,
+            autoUpdate,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Spine.js","sourceRoot":"","sources":["../src/Spine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;+EA2B+E;AAE/E,OAAO,EACN,MAAM,EAEN,KAAK,EACL,SAAS,EAET,UAAU,EAEV,QAAQ,EACR,QAAQ,EAER,OAAO,EACP,MAAM,EACN,aAAa,GACb,MAAM,SAAS,CAAC;AAEjB,OAAO,EACN,cAAc,EACd,kBAAkB,EAClB,qBAAqB,EAGrB,kBAAkB,EAClB,KAAK,EACL,cAAc,EACd,OAAO,EACP,IAAI,EACJ,gBAAgB,EAChB,QAAQ,EACR,cAAc,EACd,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,YAAY,EAIZ,OAAO,GACP,MAAM,8BAA8B,CAAC;AAwBrC,CAAC;AAEF,MAAM,SAAS,GAAG,IAAI,OAAO,EAAE,CAAC;AAEhC,QAAQ,CAAC,KAAK,GAAG,IAAI,CAAC;AAEtB,MAAM,OAAO,GAAG,IAAI,gBAAgB,EAAE,CAAC;AAkDtC,CAAC;AAEF,MAAM,QAAQ,GAAG,IAAI,IAAI,CAAW,GAAG,EAAE,CAAC,IAAI,QAAQ,CAAC,CAAC;AAExD;;;GAGG;AACH,MAAM,OAAO,KAAM,SAAQ,aAAa;IACvC,kBAAkB;IACX,OAAO,GAAG,IAAI,CAAC;IACf,OAAO,GAAG,CAAC,CAAC;IACM,YAAY,GAAG,OAAO,CAAC;IACzC,eAAe,GAAG,KAAK,CAAC;IAExB,2BAA2B,GAA4B,GAAG,EAAE,GAAU,CAAC,CAAC;IACxE,0BAA0B,GAA4B,GAAG,EAAE,GAAU,CAAC,CAAC;IAE9E,mBAAmB;IACnB,+CAA+C;IACxC,QAAQ,CAAW;IAC1B,sDAAsD;IAC/C,KAAK,CAAiB;IACtB,cAAc,CAAkB;IAE/B,QAAQ,GAAG,KAAK,CAAC;IACjB,MAAM,GAAqC,SAAS,CAAC;IAEpD,YAAY,GAAgE,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACjG,uBAAuB,GAAoC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAE/E,cAAc,CAAE,OAA+B;QACtD,IAAI,IAAiB,CAAC;QAEtB,IAAI,OAAO,OAAO,KAAK,QAAQ;YAAE,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;aAChE,IAAI,OAAO,OAAO,KAAK,QAAQ;YAAE,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;;YACxE,IAAI,GAAG,OAAO,CAAC;QAEpB,IAAI,CAAC,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,gDAAgD,OAAO,EAAE,CAAC,CAAC;QAEtF,OAAO,IAAI,CAAC;IACb,CAAC;IAEM,qBAAqB,GAAG,IAAI,CAAC;IAC7B,kBAAkB,GAAG,IAAI,CAAC;IAEzB,gBAAgB,GAAiB,EAAE,CAAC;IAEpC,aAAa,GAAG,IAAI,CAAC;IACrB,mBAAmB,GAA0C,EAAE,CAAC;IAExE,IAAW,KAAK;QACf,OAAO,IAAI,CAAC,MAAM,CAAC;IACpB,CAAC;IAED;;OAEG;IACH,IAAW,KAAK,CAAE,KAAsC;QACvD,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QACnC,CAAC;QACD,IAAI,KAAK,EAAE,CAAC;YACX,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QAC3B,CAAC;QACD,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACrB,CAAC;IAEO,gBAAgB,GAAG,KAAK,CAAC;IACzB,WAAW,GAAG,IAAI,CAAC;IAE3B,IAAW,UAAU;QACpB,OAAO,IAAI,CAAC,WAAW,CAAC;IACzB,CAAC;IACD,qIAAqI;IACrI,IAAW,UAAU,CAAE,KAAc;QACpC,IAAI,KAAK,EAAE,CAAC;YACX,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;YAC7C,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;QAC/B,CAAC;aACI,CAAC;YACL,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;QACjD,CAAC;QAED,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC1B,CAAC;IAED,YAAa,OAAoC;QAChD,IAAI,OAAO,YAAY,YAAY,EAAE,CAAC;YACrC,OAAO,GAAG;gBACT,YAAY,EAAE,OAAO;aACrB,CAAC;QACH,CAAC;QAED,KAAK,EAAE,CAAC;QAER,MAAM,YAAY,GAAG,OAAO,YAAY,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,YAAY,CAAC;QAEtF,IAAI,CAAC,QAAQ,GAAG,IAAI,QAAQ,CAAC,YAAY,CAAC,CAAC;QAC3C,IAAI,CAAC,KAAK,GAAG,IAAI,cAAc,CAAC,IAAI,kBAAkB,CAAC,YAAY,CAAC,CAAC,CAAC;QACtE,IAAI,CAAC,UAAU,GAAG,OAAO,EAAE,UAAU,IAAI,IAAI,CAAC;QAE9C,+FAA+F;QAC/F,IAAI,CAAC,QAAQ,GAAG,OAAO,EAAE,QAAQ,KAAK,SAAS;YAC9C,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC;YACzD,CAAC,CAAC,OAAO,EAAE,QAAQ,CAAC;QAErB,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;QAElC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACvC,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACnD,CAAC;QAED,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;IACtB,CAAC;IAED,qIAAqI;IAC9H,MAAM,CAAE,EAAU;QACxB,IAAI,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC/C,OAAO,CAAC,IAAI,CAAC,iHAAiH,CAAC,CAAC;YAChI,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC9B,CAAC;QAED,IAAI,CAAC,cAAc,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAC5B,CAAC;IAES,cAAc,CAAE,WAAgB,EAAE,YAAqB;QAChE,mDAAmD;QACnD,+EAA+E;QAC/E,IAAI,CAAC,YAAY,CAAC,YAAY,IAAI,MAAM,CAAC,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC,CAAC;IACjE,CAAC;IAED,IAAI,MAAM;QACT,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,IAAI,CAAC,YAAY,EAAE,CAAC;QACrB,CAAC;QAED,OAAO,IAAI,CAAC,OAAO,CAAC;IACrB,CAAC;IAED;;;;;OAKG;IACI,eAAe,CAAE,IAAmB,EAAE,QAAmB;QAC/D,MAAM,OAAO,GAAG,IAAI,CAAC;QAErB,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC9B,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAS,CAAC;QAC7C,CAAC;QAED,IAAI,CAAC,IAAI;YAAE,MAAM,KAAK,CAAC,gCAAgC,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;QACpF,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;QAEtC,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;YAEhD,IAAI,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;YACf,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;QACjB,CAAC;aACI,CAAC;YACL,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;YACrB,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC;QACtB,CAAC;IACF,CAAC;IAED;;;;;OAKG;IACI,eAAe,CAAE,IAAmB,EAAE,MAAkB;QAC9D,MAAM,OAAO,GAAG,IAAI,CAAC;QAErB,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC9B,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAS,CAAC;QAC7C,CAAC;QAED,IAAI,CAAC,IAAI,EAAE,CAAC;YACX,OAAO,CAAC,KAAK,CAAC,gCAAgC,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;YAE3E,OAAO,MAAM,CAAC;QACf,CAAC;QAED,IAAI,CAAC,MAAM,EAAE,CAAC;YACb,MAAM,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;QACzB,CAAC;QAED,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;QACvB,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;QAEvB,OAAO,MAAM,CAAC;IACf,CAAC;IAED;;;;;;OAMG;IACH,YAAY,CAAE,IAAY;QACzB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QACxB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAE3B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAE1B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAEzB,IAAI,CAAC,YAAY,EAAE,CAAC;IACrB,CAAC;IAED;;;;;;;;OAQG;IACH,WAAW;QACV,IAAI,CAAC,IAAI,CAAC,aAAa;YAAE,OAAO;QAChC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;QAE3B,MAAM,EAAE,QAAQ,EAAE,GAAG,IAAI,CAAC;QAE1B,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;QAE3B,IAAI,CAAC,2BAA2B,CAAC,IAAI,CAAC,CAAC;QACvC,QAAQ,CAAC,oBAAoB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QAC9C,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,CAAC;QAEtC,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAE3B,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAE5B,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC1B,CAAC;IAEO,mBAAmB;QAC1B,MAAM,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;QAEjD,MAAM,eAAe,GAAG,IAAI,CAAC,gBAAgB,CAAC;QAE9C,IAAI,KAAK,GAAG,CAAC,CAAC;QAEd,IAAI,qBAAqB,GAAG,KAAK,CAAC;QAElC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAClD,MAAM,IAAI,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;YACjC,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YAExC,IAAI,UAAU,EAAE,CAAC;gBAChB,IAAI,UAAU,KAAK,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;oBAC3C,qBAAqB,GAAG,IAAI,CAAC;oBAC7B,eAAe,CAAC,KAAK,CAAC,GAAG,UAAU,CAAC;gBACrC,CAAC;gBAED,KAAK,EAAE,CAAC;YACT,CAAC;QACF,CAAC;QAED,IAAI,KAAK,KAAK,eAAe,CAAC,MAAM,EAAE,CAAC;YACtC,qBAAqB,GAAG,IAAI,CAAC;YAC7B,eAAe,CAAC,MAAM,GAAG,KAAK,CAAC;QAChC,CAAC;QAED,IAAI,CAAC,qBAAqB,GAAG,qBAAqB,CAAC;IACpD,CAAC;IAEO,oBAAoB,CAAE,IAAU,EAAE,IAAa;QACtD,wCAAwC;QACxC,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;QACnC,IAAI,UAAU,IAAI,UAAU,YAAY,kBAAkB,EAAE,CAAC;YAC5D,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,KAAK,EAAU,EAAE,CAAC,CAAC;YACxG,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;YAC1B,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACxE,OAAO;QACR,CAAC;QAED,yDAAyD;QACzD,IAAI,mBAAmB,GAAG,IAAI,CAAC,mBAAmB,CAAC;QACnD,IAAI,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnD,IAAI,mBAAmB,IAAI,UAAU,EAAE,CAAC;YACvC,IAAI,YAAY,GAAG,mBAAmB,CAAC,IAAI,CAAC;YAC5C,IAAI,kBAAkB,GAAG,YAAY,CAAC,UAAgC,CAAC;YAEvE,yHAAyH;YACzH,IAAI,IAAI,GAAG,mBAAmB,CAAC,IAAgB,CAAC;YAChD,IAAI,CAAC,IAAI,EAAE,CAAC;gBACX,IAAI,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC;gBACzB,mBAAmB,CAAC,IAAI,GAAG,IAAI,CAAC;gBAChC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YACrB,CAAC;YAED,0GAA0G;YAC1G,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,CAAC;gBACvC,mBAAmB,CAAC,YAAY,GAAG,IAAI,CAAC;gBACxC,MAAM,mBAAmB,GAAG,kBAAkB,CAAC,mBAAmB,CAAC;gBACnE,MAAM,QAAQ,GAAG,mBAAmB,CAAC,QAAQ,CAAC;gBAC9C,kBAAkB,CAAC,oBAAoB,CAAC,YAAY,EAAE,CAAC,EAAE,mBAAmB,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC9F,IAAI,CAAC,KAAK,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;YACvE,CAAC;YACD,UAAU,CAAC,SAAS,CAAC,IAAI,GAAG,IAAI,CAAC;QAClC,CAAC;aAAM,IAAI,UAAU,EAAE,SAAS,CAAC,IAAI,EAAE,CAAC;YACvC,mFAAmF;YACnF,UAAU,CAAC,SAAS,CAAC,IAAI,GAAG,IAAI,CAAC;QAClC,CAAC;QAED,0GAA0G;QAC1G,IAAI,mBAAmB,IAAK,mBAAmB,CAAC,IAAI,CAAC,UAAiC,CAAC,OAAO,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;YAC7G,IAAI,CAAC,mBAAmB,GAAG,SAAS,CAAC;QACtC,CAAC;QAED,wBAAwB;QACxB,IAAI,IAAI,EAAE,CAAC;YACV,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,uBAAuB,EAAE,CAAC;gBAChD,MAAM,sBAAsB,GAAG,IAAI,CAAC,uBAAuB,CAAC,GAAG,CAAC,CAAC;gBACjE,IAAI,CAAC,CAAC,CAAC,sBAAsB,CAAC,IAAI,CAAC,UAAU,YAAY,kBAAkB,CAAC,IAAI,CAAC,sBAAsB,CAAC,YAAY,CAAC,IAAI,sBAAsB,CAAC,IAAI,EAAE,CAAC;oBACtJ,IAAI,CAAC,WAAW,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;oBAC9C,QAAQ,CAAC,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;oBAC3C,sBAAsB,CAAC,IAAI,GAAG,SAAS,CAAC;gBACzC,CAAC;YACF,CAAC;QACF,CAAC;IACF,CAAC;IAEO,mBAAmB,CAA8B;IACjD,oBAAoB;QAC3B,MAAM,gBAAgB,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;QAEjD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAClD,MAAM,IAAI,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;YAEjC,IAAI,CAAC,oBAAoB,CAAC,IAAI,EAAE,CAAC,KAAK,gBAAgB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YAEnE,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;YAExC,IAAI,UAAU,EAAE,CAAC;gBAChB,IAAI,UAAU,YAAY,cAAc,IAAI,UAAU,YAAY,gBAAgB,EAAE,CAAC;oBACpF,MAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;oBAExD,IAAI,UAAU,YAAY,gBAAgB,EAAE,CAAC;wBAC5C,UAAU,CAAC,oBAAoB,CAAC,IAAI,EAAE,SAAS,CAAC,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;oBACjE,CAAC;yBACI,CAAC;wBACL,UAAU,CAAC,oBAAoB,CAC9B,IAAI,EACJ,CAAC,EACD,UAAU,CAAC,mBAAmB,EAC9B,SAAS,CAAC,QAAQ,EAClB,CAAC,EACD,CAAC,CACD,CAAC;oBACH,CAAC;oBAED,QAAQ,CAAE,UAAU,CAAC,GAAoB,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;oBAExE,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;oBACpC,MAAM,aAAa,GAAG,QAAQ,CAAC,KAAK,CAAC;oBACrC,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC;oBAE7B,MAAM,eAAe,GAAG,UAAU,CAAC,KAAK,CAAC;oBAEzC,SAAS,CAAC,KAAK,CAAC,GAAG,CAClB,aAAa,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,EACjD,aAAa,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,EACjD,aAAa,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,EACjD,aAAa,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CACjD,CAAC;oBAEF,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;wBACpB,SAAS,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;oBAClD,CAAC;oBAED,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC,OAAO,GAAG,KAAK,CAAC;oBAEjD,MAAM,OAAO,GAAG,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC;oBAEpE,IAAI,SAAS,CAAC,OAAO,KAAK,OAAO,EAAE,CAAC;wBACnC,SAAS,CAAC,OAAO,GAAG,OAAO,CAAC;wBAC5B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;oBAChC,CAAC;oBAED,IAAI,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC;wBAC1B,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;oBACpC,CAAC;gBACF,CAAC;qBACI,IAAI,UAAU,YAAY,kBAAkB,EAAE,CAAC;oBACnD,OAAO,CAAC,SAAS,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;oBACpC,SAAS;gBACV,CAAC;YACF,CAAC;YACD,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAC/B,CAAC;QACD,OAAO,CAAC,OAAO,EAAE,CAAC;IACnB,CAAC;IAEO,kBAAkB,CAAE,SAA8B;QACzD,SAAS,CAAC,OAAO,GAAG,IAAI,CAAC;QAEzB,OAAO,CAAC,qBAAqB,CAC5B,SAAS,CAAC,QAAQ,EAClB,SAAS,CAAC,OAAO,EACjB,SAAS,CAAC,OAAO,CAAC,MAAM,EACxB,SAAS,CAAC,GAAG,CACb,CAAC;QAEF,MAAM,EAAE,eAAe,EAAE,UAAU,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC;QAElE,MAAM,aAAa,GAAG,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC;QACjD,MAAM,YAAY,GAAG,gBAAgB,CAAC,MAAM,CAAC;QAE7C,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC;YAC5B,SAAS,CAAC,WAAW,GAAG;gBACvB,QAAQ,EAAE,IAAI,YAAY,CAAC,aAAa,GAAG,CAAC,CAAC;gBAC7C,GAAG,EAAE,IAAI,YAAY,CAAC,aAAa,GAAG,CAAC,CAAC;gBACxC,WAAW,EAAE,aAAa;gBAC1B,OAAO,EAAE,IAAI,WAAW,CAAC,YAAY,CAAC;gBACtC,YAAY;aACZ,CAAC;YAEF,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;QACnC,CAAC;QAED,MAAM,WAAW,GAAG,SAAS,CAAC,WAAW,CAAC;QAE1C,MAAM,UAAU,GAAG,WAAW,CAAC,WAAW,KAAK,aAAa,IAAI,YAAY,KAAK,WAAW,CAAC,YAAY,CAAC;QAE1G,SAAS,CAAC,UAAU,GAAG,aAAa,KAAK,CAAC,CAAC;QAE3C,IAAI,UAAU,EAAE,CAAC;YAChB,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;YAElC,IAAI,WAAW,CAAC,WAAW,GAAG,aAAa,EAAE,CAAC;gBAC7C,gBAAgB;gBAChB,WAAW,CAAC,QAAQ,GAAG,IAAI,YAAY,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;gBAC3D,WAAW,CAAC,GAAG,GAAG,IAAI,YAAY,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC;YACvD,CAAC;YAED,IAAI,WAAW,CAAC,OAAO,CAAC,MAAM,GAAG,YAAY,EAAE,CAAC;gBAC/C,WAAW,CAAC,OAAO,GAAG,IAAI,WAAW,CAAC,YAAY,CAAC,CAAC;YACrD,CAAC;QACF,CAAC;QAED,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,WAAW,CAAC;QAE/C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YACzC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAErD,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YACjC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC5C,CAAC;QAED,WAAW,CAAC,WAAW,GAAG,aAAa,CAAC;QAExC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,YAAY,EAAE,CAAC,EAAE,EAAE,CAAC;YACvC,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;gBACxC,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;gBAClC,OAAO,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;YAClC,CAAC;QACF,CAAC;QAED,WAAW,CAAC,YAAY,GAAG,YAAY,CAAC;IACzC,CAAC;IAED;;;OAGG;IACK,iBAAiB;QACxB,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACnC,MAAM,cAAc,GAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;YAE5C,IAAI,CAAC,cAAc;gBAAE,SAAS;YAE9B,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC,CAAC;QACvC,CAAC;IACF,CAAC;IAEO,gBAAgB,CAAE,cAAoD;QAC7E,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,cAAc,CAAC;QAE3C,SAAS,CAAC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAE3D,IAAI,SAAS,CAAC,OAAO,EAAE,CAAC;YACvB,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;YAEvB,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;YAEjD,SAAS,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;YAC1C,SAAS,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;YAE1C,SAAS,CAAC,QAAQ,GAAG,IAAI,CAAC,iBAAiB,EAAE,GAAG,UAAU,CAAC;YAE3D,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;QACxD,CAAC;IACF,CAAC;IAED,gBAAgB;IAChB,cAAc,CAAE,IAAU,EAAE,UAA6C;QACxE,OAAO,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAC5G,CAAC;IAEO,cAAc,CAAE,IAAU,EAAE,UAA6C;QAChF,IAAI,QAAsB,CAAC;QAE3B,IAAI,UAAU,YAAY,gBAAgB,EAAE,CAAC;YAC5C,QAAQ,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC;YAE/B,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG;gBAC5D,EAAE,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,UAAU,CAAC,IAAI,EAAE;gBAC3C,QAAQ;gBACR,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;gBAC3B,GAAG,EAAE,IAAI,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC;gBAC5C,KAAK,EAAE,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;gBAC5B,SAAS,EAAE,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;gBAChC,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,UAAU,EAAE,KAAK;gBACjB,OAAO,EAAE,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO;aAC3C,CAAC;QACH,CAAC;aACI,CAAC;YACL,QAAQ,GAAG,IAAI,YAAY,CAAC,UAAU,CAAC,mBAAmB,CAAC,CAAC;YAE5D,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG;gBAC5D,EAAE,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,UAAU,CAAC,IAAI,EAAE;gBAC3C,QAAQ;gBACR,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,UAAU,CAAC,SAAS;gBAC7B,GAAG,EAAE,IAAI,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC;gBAC5C,KAAK,EAAE,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;gBAC5B,SAAS,EAAE,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;gBAChC,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,UAAU,EAAE,KAAK;gBACjB,OAAO,EAAE,UAAU,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO;aAC3C,CAAC;QACH,CAAC;QAED,OAAO,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;IACnE,CAAC;IAES,YAAY;QACrB,+BAA+B;QAC/B,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,EAAE,CAAC;QAE7B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAEzB,IAAI,IAAI,CAAC,aAAa;YAAE,OAAO;QAC/B,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAE1B,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,iBAAiB,CAAC;QAE/D,IAAI,WAAW,EAAE,CAAC;YACjB,WAAW,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QACrC,CAAC;QAED,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;;OAMG;IACI,aAAa,CAAE,IAA4B,EAAE,SAAoB;QACvE,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QAEjC,2CAA2C;QAC3C,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACnC,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,SAAS,KAAK,SAAS,EAAE,CAAC;gBACnD,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YAClD,CAAC;QACF,CAAC;QAED,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;QAE5B,SAAS,CAAC,cAAc,GAAG,KAAK,CAAC;QAEjC,uBAAuB;QACvB,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QAEzB,MAAM,UAAU,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;QACvC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,UAAU,CAAC;QAE/C,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACI,gBAAgB,CAAE,eAAmD;QAC3E,IAAI,iBAAwC,CAAC;QAE7C,IAAI,eAAe,YAAY,SAAS,EAAE,CAAC;YAC1C,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;gBACnC,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,SAAS,KAAK,eAAe,EAAE,CAAC;oBACzD,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;oBAE5B,iBAAiB,GAAG,eAAe,CAAC;oBACpC,MAAM;gBACP,CAAC;YACF,CAAC;QACF,CAAC;aACI,CAAC;YACL,MAAM,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC,eAAe,CAAC,CAAC;YAElD,iBAAiB,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC;YACjE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QAC1C,CAAC;QAED,IAAI,iBAAiB,EAAE,CAAC;YACvB,IAAI,CAAC,WAAW,CAAC,iBAAiB,CAAC,CAAC;YAEpC,iBAAiB,CAAC,cAAc,GAAG,IAAI,CAAC;QACzC,CAAC;IACF,CAAC;IAED;;;;;OAKG;IACI,aAAa,CAAE,IAA4B;QACjD,IAAI,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QAEjC,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC;IACrD,CAAC;IAEO,YAAY;QACnB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAE1B,IAAI,CAAC,cAAc,KAAK,IAAI,cAAc,EAAE,CAAC;QAE7C,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,CAAC;QAE3C,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QAE3C,IAAI,cAAc,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YACtC,IAAI,CAAC,WAAW,EAAE,CAAC;YAEnB,MAAM,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC;YAC1C,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC;YAE5B,MAAM,CAAC,KAAK,EAAE,CAAC;YAEf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC3C,MAAM,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;gBAE1B,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;gBAExC,IAAI,UAAU,IAAI,CAAC,UAAU,YAAY,gBAAgB,IAAI,UAAU,YAAY,cAAc,CAAC,EAAE,CAAC;oBACpG,MAAM,SAAS,GAAG,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;oBAExD,MAAM,CAAC,aAAa,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;gBACxE,CAAC;YACF,CAAC;QACF,CAAC;aACI,CAAC;YACL,IAAI,CAAC,OAAO,CAAC,IAAI,GAAG,cAAc,CAAC,IAAI,CAAC;YACxC,IAAI,CAAC,OAAO,CAAC,IAAI,GAAG,cAAc,CAAC,IAAI,CAAC;YACxC,IAAI,CAAC,OAAO,CAAC,IAAI,GAAG,cAAc,CAAC,IAAI,CAAC;YACxC,IAAI,CAAC,OAAO,CAAC,IAAI,GAAG,cAAc,CAAC,IAAI,CAAC;QACzC,CAAC;IACF,CAAC;IAED,gBAAgB;IAChB,SAAS,CAAE,MAAc;QACxB,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC/B,CAAC;IAED;;;;;;OAMG;IACa,OAAO,CAAE,UAA0B,KAAK;QACvD,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAEvB,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,CAAC;QAChD,IAAI,CAAC,KAAK,CAAC,cAAc,EAAE,CAAC;QAC5B,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC;QACvB,IAAI,CAAC,QAAQ,GAAG,IAAW,CAAC;QAC5B,IAAI,CAAC,KAAK,GAAG,IAAW,CAAC;QACxB,IAAI,CAAC,YAAoB,GAAG,IAAI,CAAC;QAClC,IAAI,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,CAAC;QACjC,IAAI,CAAC,mBAAmB,GAAG,IAAW,CAAC;IACxC,CAAC;IAED,gGAAgG;IACzF,8BAA8B,CAAE,KAA+B;QACrE,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACzC,CAAC;IAED,gGAAgG;IACzF,8BAA8B,CAAE,KAA+B;QACrE,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAChD,CAAC;IAED,oGAAoG;IAC7F,0BAA0B,CAAE,KAA+B,EAAE,IAAU;QAC7E,IAAI,CAAC,8BAA8B,CAAC,KAAK,CAAC,CAAC;QAC3C,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,KAAgB,CAAC,CAAC;QAC5C,CAAC;aACI,CAAC;YACL,IAAI,CAAC,YAAY,CAAC,KAAgB,CAAC,CAAC;QACrC,CAAC;IACF,CAAC;IAED;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,IAAI,CAAE,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,GAAG,CAAC,EAAE,QAAQ,EAAE,UAAU,GAAG,IAAI,EAAoB;QACzF,MAAM,QAAQ,GAAG,GAAG,QAAQ,IAAI,KAAK,IAAI,KAAK,EAAE,CAAC;QAEjD,IAAI,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;YACzB,OAAO,IAAI,KAAK,CAAC,KAAK,CAAC,GAAG,CAAe,QAAQ,CAAC,CAAC,CAAC;QACrD,CAAC;QAED,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAmB,QAAQ,CAAC,CAAC;QAE7D,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAe,KAAK,CAAC,CAAC;QACnD,MAAM,gBAAgB,GAAG,IAAI,qBAAqB,CAAC,UAAU,CAAC,CAAC;QAC/D,MAAM,MAAM,GAAG,aAAa,YAAY,UAAU;YACjD,CAAC,CAAC,IAAI,cAAc,CAAC,gBAAgB,CAAC;YACtC,CAAC,CAAC,IAAI,YAAY,CAAC,gBAAgB,CAAC,CAAC;QAEtC,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC;QACrB,MAAM,YAAY,GAAG,MAAM,CAAC,gBAAgB,CAAC,aAAa,CAAC,CAAC;QAE5D,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QAElC,OAAO,IAAI,KAAK,CAAC;YAChB,YAAY;YACZ,QAAQ;YACR,UAAU;SACV,CAAC,CAAC;IACJ,CAAC;CACD","sourcesContent":["/** ****************************************************************************\n * Spine Runtimes License Agreement\n * Last updated July 28, 2023. Replaces all prior versions.\n *\n * Copyright (c) 2013-2023, 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 or\n * 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 THE\n * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n *****************************************************************************/\n\nimport {\n\tAssets,\n\tBounds,\n\tCache,\n\tContainer,\n\tContainerOptions,\n\tDEG_TO_RAD,\n\tDestroyOptions,\n\tfastCopy,\n\tGraphics,\n\tPointData,\n\tTexture,\n\tTicker,\n\tViewContainer,\n} from 'pixi.js';\nimport { ISpineDebugRenderer } from './SpineDebugRenderer';\nimport {\n\tAnimationState,\n\tAnimationStateData,\n\tAtlasAttachmentLoader,\n\tAttachment,\n\tBone,\n\tClippingAttachment,\n\tColor,\n\tMeshAttachment,\n\tPhysics,\n\tPool,\n\tRegionAttachment,\n\tSkeleton,\n\tSkeletonBinary,\n\tSkeletonBounds,\n\tSkeletonClipping,\n\tSkeletonData,\n\tSkeletonJson,\n\tSlot,\n\ttype TextureAtlas,\n\tTrackEntry,\n\tVector2,\n} from '@esotericsoftware/spine-core';\n\n/**\n * Options to create a {@link Spine} using {@link Spine.from}.\n */\nexport interface SpineFromOptions {\n\t/** the asset name for the skeleton `.skel` or `.json` file previously loaded into the Assets */\n\tskeleton: string;\n\n\t/** the asset name for the atlas file previously loaded into the Assets */\n\tatlas: string;\n\n\t/**  The value passed to the skeleton reader. If omitted, 1 is passed. See {@link SkeletonBinary.scale} for details. */\n\tscale?: number;\n\n\t/**  Set the {@link Spine.autoUpdate} value. If omitted, it is set to `true`. */\n\tautoUpdate?: boolean;\n\n\t/**\n\t * If `true`, use the dark tint renderer to render the skeleton\n\t * If `false`, use the default pixi renderer to render the skeleton\n\t * If `undefined`, use the dark tint renderer if at least one slot has tint black\n\t */\n\tdarkTint?: boolean;\n};\n\nconst vectorAux = new Vector2();\n\nSkeleton.yDown = true;\n\nconst clipper = new SkeletonClipping();\n\nexport interface SpineOptions extends ContainerOptions {\n\t/** the {@link SkeletonData} used to instantiate the skeleton */\n\tskeletonData: SkeletonData;\n\n\t/**  See {@link SpineFromOptions.autoUpdate}. */\n\tautoUpdate?: boolean;\n\n\t/**  See {@link SpineFromOptions.darkTint}. */\n\tdarkTint?: boolean;\n}\n\n/**\n * AnimationStateListener {@link https://en.esotericsoftware.com/spine-api-reference#AnimationStateListener events} exposed for Pixi.\n */\nexport interface SpineEvents {\n\tcomplete: [trackEntry: TrackEntry];\n\tdispose: [trackEntry: TrackEntry];\n\tend: [trackEntry: TrackEntry];\n\tevent: [trackEntry: TrackEntry, event: Event];\n\tinterrupt: [trackEntry: TrackEntry];\n\tstart: [trackEntry: TrackEntry];\n}\n\nexport interface AttachmentCacheData {\n\tid: string;\n\tclipped: boolean;\n\tvertices: Float32Array;\n\tuvs: Float32Array;\n\tindices: number[];\n\tcolor: Color;\n\tdarkColor: Color;\n\tdarkTint: boolean;\n\tskipRender: boolean;\n\ttexture: Texture;\n\tclippedData?: {\n\t\tvertices: Float32Array;\n\t\tuvs: Float32Array;\n\t\tindices: Uint16Array;\n\t\tvertexCount: number;\n\t\tindicesCount: number;\n\t};\n}\n\ninterface SlotsToClipping {\n\tslot: Slot,\n\tmask?: Graphics,\n\tmaskComputed?: boolean,\n\tvertices: Array<number>,\n};\n\nconst maskPool = new Pool<Graphics>(() => new Graphics);\n\n/**\n * The class to instantiate a {@link Spine} game object in Pixi.\n * The static method {@link Spine.from} should be used to instantiate a Spine game object.\n */\nexport class Spine extends ViewContainer {\n\t// Pixi properties\n\tpublic batched = true;\n\tpublic buildId = 0;\n\tpublic override readonly renderPipeId = 'spine';\n\tpublic _didSpineUpdate = false;\n\n\tpublic beforeUpdateWorldTransforms: (object: Spine) => void = () => { /** */ };\n\tpublic afterUpdateWorldTransforms: (object: Spine) => void = () => { /** */ };\n\n\t// Spine properties\n\t/** The skeleton for this Spine game object. */\n\tpublic skeleton: Skeleton;\n\t/** The animation state for this Spine game object. */\n\tpublic state: AnimationState;\n\tpublic skeletonBounds?: SkeletonBounds;\n\n\tprivate darkTint = false;\n\tprivate _debug?: ISpineDebugRenderer | undefined = undefined;\n\n\treadonly _slotsObject: Record<string, { slot: Slot, container: Container } | null> = Object.create(null);\n\tprivate clippingSlotToPixiMasks: Record<string, SlotsToClipping> = Object.create(null);\n\n\tprivate getSlotFromRef (slotRef: number | string | Slot): Slot {\n\t\tlet slot: Slot | null;\n\n\t\tif (typeof slotRef === 'number') slot = this.skeleton.slots[slotRef];\n\t\telse if (typeof slotRef === 'string') slot = this.skeleton.findSlot(slotRef);\n\t\telse slot = slotRef;\n\n\t\tif (!slot) throw new Error(`No slot found with the given slot reference: ${slotRef}`);\n\n\t\treturn slot;\n\t}\n\n\tpublic spineAttachmentsDirty = true;\n\tpublic spineTexturesDirty = true;\n\n\tprivate _lastAttachments: Attachment[] = [];\n\n\tprivate _stateChanged = true;\n\tprivate attachmentCacheData: Record<string, AttachmentCacheData>[] = [];\n\n\tpublic get debug (): ISpineDebugRenderer | undefined {\n\t\treturn this._debug;\n\t}\n\n\t/** Pass a {@link SpineDebugRenderer} or create your own {@link ISpineDebugRenderer} to render bones, meshes, ...\n\t * @example spineGO.debug = new SpineDebugRenderer();\n\t */\n\tpublic set debug (value: ISpineDebugRenderer | undefined) {\n\t\tif (this._debug) {\n\t\t\tthis._debug.unregisterSpine(this);\n\t\t}\n\t\tif (value) {\n\t\t\tvalue.registerSpine(this);\n\t\t}\n\t\tthis._debug = value;\n\t}\n\n\tprivate autoUpdateWarned = false;\n\tprivate _autoUpdate = true;\n\n\tpublic get autoUpdate (): boolean {\n\t\treturn this._autoUpdate;\n\t}\n\t/** When `true`, the Spine AnimationState and the Skeleton will be automatically updated using the {@link Ticker.shared} instance. */\n\tpublic set autoUpdate (value: boolean) {\n\t\tif (value) {\n\t\t\tTicker.shared.add(this.internalUpdate, this);\n\t\t\tthis.autoUpdateWarned = false;\n\t\t}\n\t\telse {\n\t\t\tTicker.shared.remove(this.internalUpdate, this);\n\t\t}\n\n\t\tthis._autoUpdate = value;\n\t}\n\n\tconstructor (options: SpineOptions | SkeletonData) {\n\t\tif (options instanceof SkeletonData) {\n\t\t\toptions = {\n\t\t\t\tskeletonData: options,\n\t\t\t};\n\t\t}\n\n\t\tsuper();\n\n\t\tconst skeletonData = options instanceof SkeletonData ? options : options.skeletonData;\n\n\t\tthis.skeleton = new Skeleton(skeletonData);\n\t\tthis.state = new AnimationState(new AnimationStateData(skeletonData));\n\t\tthis.autoUpdate = options?.autoUpdate ?? true;\n\n\t\t// dark tint can be enabled by options, otherwise is enable if at least one slot has tint black\n\t\tthis.darkTint = options?.darkTint === undefined\n\t\t\t? this.skeleton.slots.some(slot => !!slot.data.darkColor)\n\t\t\t: options?.darkTint;\n\n\t\tconst slots = this.skeleton.slots;\n\n\t\tfor (let i = 0; i < slots.length; i++) {\n\t\t\tthis.attachmentCacheData[i] = Object.create(null);\n\t\t}\n\n\t\tthis._updateState(0);\n\t}\n\n\t/** If {@link Spine.autoUpdate} is `false`, this method allows to update the AnimationState and the Skeleton with the given delta. */\n\tpublic update (dt: number): void {\n\t\tif (this.autoUpdate && !this.autoUpdateWarned) {\n\t\t\tconsole.warn('You are calling update on a Spine instance that has autoUpdate set to true. This is probably not what you want.');\n\t\t\tthis.autoUpdateWarned = true;\n\t\t}\n\n\t\tthis.internalUpdate(0, dt);\n\t}\n\n\tprotected internalUpdate (_deltaFrame: any, deltaSeconds?: number): void {\n\t\t// Because reasons, pixi uses deltaFrames at 60fps.\n\t\t// We ignore the default deltaFrames and use the deltaSeconds from pixi ticker.\n\t\tthis._updateState(deltaSeconds ?? Ticker.shared.deltaMS / 1000);\n\t}\n\n\tget bounds () {\n\t\tif (this._boundsDirty) {\n\t\t\tthis.updateBounds();\n\t\t}\n\n\t\treturn this._bounds;\n\t}\n\n\t/**\n\t * Set the position of the bone given in input through a {@link IPointData}.\n\t * @param bone: the bone name or the bone instance to set the position\n\t * @param outPos: the new position of the bone.\n\t * @throws {Error}: if the given bone is not found in the skeleton, an error is thrown\n\t */\n\tpublic setBonePosition (bone: string | Bone, position: PointData): void {\n\t\tconst boneAux = bone;\n\n\t\tif (typeof bone === 'string') {\n\t\t\tbone = this.skeleton.findBone(bone) as Bone;\n\t\t}\n\n\t\tif (!bone) throw Error(`Cant set bone position, bone ${String(boneAux)} not found`);\n\t\tvectorAux.set(position.x, position.y);\n\n\t\tif (bone.parent) {\n\t\t\tconst aux = bone.parent.worldToLocal(vectorAux);\n\n\t\t\tbone.x = aux.x;\n\t\t\tbone.y = -aux.y;\n\t\t}\n\t\telse {\n\t\t\tbone.x = vectorAux.x;\n\t\t\tbone.y = vectorAux.y;\n\t\t}\n\t}\n\n\t/**\n\t * Return the position of the bone given in input into an {@link IPointData}.\n\t * @param bone: the bone name or the bone instance to get the position from\n\t * @param outPos: an optional {@link IPointData} to use to return the bone position, rathern than instantiating a new object.\n\t * @returns {IPointData | undefined}: the position of the bone, or undefined if no matching bone is found in the skeleton\n\t */\n\tpublic getBonePosition (bone: string | Bone, outPos?: PointData): PointData | undefined {\n\t\tconst boneAux = bone;\n\n\t\tif (typeof bone === 'string') {\n\t\t\tbone = this.skeleton.findBone(bone) as Bone;\n\t\t}\n\n\t\tif (!bone) {\n\t\t\tconsole.error(`Cant set bone position! Bone ${String(boneAux)} not found`);\n\n\t\t\treturn outPos;\n\t\t}\n\n\t\tif (!outPos) {\n\t\t\toutPos = { x: 0, y: 0 };\n\t\t}\n\n\t\toutPos.x = bone.worldX;\n\t\toutPos.y = bone.worldY;\n\n\t\treturn outPos;\n\t}\n\n\t/**\n\t * Will update the state based on the specified time, this will not apply the state to the skeleton\n\t * as this is differed until the `applyState` method is called.\n\t *\n\t * @param time the time at which to set the state\n\t * @internal\n\t */\n\t_updateState (time: number) {\n\t\tthis.state.update(time);\n\t\tthis.skeleton.update(time);\n\n\t\tthis._stateChanged = true;\n\n\t\tthis._boundsDirty = true;\n\n\t\tthis.onViewUpdate();\n\t}\n\n\t/**\n\t * Applies the state to this spine instance.\n\t * - updates the state to the skeleton\n\t * - updates its world transform (spine world transform)\n\t * - validates the attachments - to flag if the attachments have changed this state\n\t * - transforms the attachments - to update the vertices of the attachments based on the new positions\n\t * - update the slot attachments - to update the position, rotation, scale, and visibility of the attached containers\n\t * @internal\n\t */\n\t_applyState () {\n\t\tif (!this._stateChanged) return;\n\t\tthis._stateChanged = false;\n\n\t\tconst { skeleton } = this;\n\n\t\tthis.state.apply(skeleton);\n\n\t\tthis.beforeUpdateWorldTransforms(this);\n\t\tskeleton.updateWorldTransform(Physics.update);\n\t\tthis.afterUpdateWorldTransforms(this);\n\n\t\tthis.validateAttachments();\n\n\t\tthis.transformAttachments();\n\n\t\tthis.updateSlotObjects();\n\t}\n\n\tprivate validateAttachments () {\n\t\tconst currentDrawOrder = this.skeleton.drawOrder;\n\n\t\tconst lastAttachments = this._lastAttachments;\n\n\t\tlet index = 0;\n\n\t\tlet spineAttachmentsDirty = false;\n\n\t\tfor (let i = 0; i < currentDrawOrder.length; i++) {\n\t\t\tconst slot = currentDrawOrder[i];\n\t\t\tconst attachment = slot.getAttachment();\n\n\t\t\tif (attachment) {\n\t\t\t\tif (attachment !== lastAttachments[index]) {\n\t\t\t\t\tspineAttachmentsDirty = true;\n\t\t\t\t\tlastAttachments[index] = attachment;\n\t\t\t\t}\n\n\t\t\t\tindex++;\n\t\t\t}\n\t\t}\n\n\t\tif (index !== lastAttachments.length) {\n\t\t\tspineAttachmentsDirty = true;\n\t\t\tlastAttachments.length = index;\n\t\t}\n\n\t\tthis.spineAttachmentsDirty = spineAttachmentsDirty;\n\t}\n\n\tprivate updateAndSetPixiMask (slot: Slot, last: boolean) {\n\t\t// assign/create the currentClippingSlot\n\t\tconst attachment = slot.attachment;\n\t\tif (attachment && attachment instanceof ClippingAttachment) {\n\t\t\tconst clip = (this.clippingSlotToPixiMasks[slot.data.name] ||= { slot, vertices: new Array<number>() });\n\t\t\tclip.maskComputed = false;\n\t\t\tthis.currentClippingSlot = this.clippingSlotToPixiMasks[slot.data.name];\n\t\t\treturn;\n\t\t}\n\n\t\t// assign the currentClippingSlot mask to the slot object\n\t\tlet currentClippingSlot = this.currentClippingSlot;\n\t\tlet slotObject = this._slotsObject[slot.data.name];\n\t\tif (currentClippingSlot && slotObject) {\n\t\t\tlet slotClipping = currentClippingSlot.slot;\n\t\t\tlet clippingAttachment = slotClipping.attachment as ClippingAttachment;\n\n\t\t\t// create the pixi mask, only the first time and if the clipped slot is the first one clipped by this currentClippingSlot\n\t\t\tlet mask = currentClippingSlot.mask as Graphics;\n\t\t\tif (!mask) {\n\t\t\t\tmask = maskPool.obtain();\n\t\t\t\tcurrentClippingSlot.mask = mask;\n\t\t\t\tthis.addChild(mask);\n\t\t\t}\n\n\t\t\t// compute the pixi mask polygon, if the clipped slot is the first one clipped by this currentClippingSlot\n\t\t\tif (!currentClippingSlot.maskComputed) {\n\t\t\t\tcurrentClippingSlot.maskComputed = true;\n\t\t\t\tconst worldVerticesLength = clippingAttachment.worldVerticesLength;\n\t\t\t\tconst vertices = currentClippingSlot.vertices;\n\t\t\t\tclippingAttachment.computeWorldVertices(slotClipping, 0, worldVerticesLength, vertices, 0, 2);\n\t\t\t\tmask.clear().poly(vertices).stroke({ width: 0 }).fill({ alpha: .25 });\n\t\t\t}\n\t\t\tslotObject.container.mask = mask;\n\t\t} else if (slotObject?.container.mask) {\n\t\t\t// remove the mask, if slot object has a mask, but currentClippingSlot is undefined\n\t\t\tslotObject.container.mask = null;\n\t\t}\n\n\t\t// if current slot is the ending one of the currentClippingSlot mask, set currentClippingSlot to undefined\n\t\tif (currentClippingSlot && (currentClippingSlot.slot.attachment as ClippingAttachment).endSlot == slot.data) {\n\t\t\tthis.currentClippingSlot = undefined;\n\t\t}\n\n\t\t// clean up unused masks\n\t\tif (last) {\n\t\t\tfor (const key in this.clippingSlotToPixiMasks) {\n\t\t\t\tconst clippingSlotToPixiMask = this.clippingSlotToPixiMasks[key];\n\t\t\t\tif ((!(clippingSlotToPixiMask.slot.attachment instanceof ClippingAttachment) || !clippingSlotToPixiMask.maskComputed) && clippingSlotToPixiMask.mask) {\n\t\t\t\t\tthis.removeChild(clippingSlotToPixiMask.mask);\n\t\t\t\t\tmaskPool.free(clippingSlotToPixiMask.mask);\n\t\t\t\t\tclippingSlotToPixiMask.mask = undefined;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate currentClippingSlot: SlotsToClipping | undefined;\n\tprivate transformAttachments () {\n\t\tconst currentDrawOrder = this.skeleton.drawOrder;\n\n\t\tfor (let i = 0; i < currentDrawOrder.length; i++) {\n\t\t\tconst slot = currentDrawOrder[i];\n\n\t\t\tthis.updateAndSetPixiMask(slot, i === currentDrawOrder.length - 1);\n\n\t\t\tconst attachment = slot.getAttachment();\n\n\t\t\tif (attachment) {\n\t\t\t\tif (attachment instanceof MeshAttachment || attachment instanceof RegionAttachment) {\n\t\t\t\t\tconst cacheData = this._getCachedData(slot, attachment);\n\n\t\t\t\t\tif (attachment instanceof RegionAttachment) {\n\t\t\t\t\t\tattachment.computeWorldVertices(slot, cacheData.vertices, 0, 2);\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tattachment.computeWorldVertices(\n\t\t\t\t\t\t\tslot,\n\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\tattachment.worldVerticesLength,\n\t\t\t\t\t\t\tcacheData.vertices,\n\t\t\t\t\t\t\t0,\n\t\t\t\t\t\t\t2,\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\n\t\t\t\t\tfastCopy((attachment.uvs as Float32Array).buffer, cacheData.uvs.buffer);\n\n\t\t\t\t\tconst skeleton = slot.bone.skeleton;\n\t\t\t\t\tconst skeletonColor = skeleton.color;\n\t\t\t\t\tconst slotColor = slot.color;\n\n\t\t\t\t\tconst attachmentColor = attachment.color;\n\n\t\t\t\t\tcacheData.color.set(\n\t\t\t\t\t\tskeletonColor.r * slotColor.r * attachmentColor.r,\n\t\t\t\t\t\tskeletonColor.g * slotColor.g * attachmentColor.g,\n\t\t\t\t\t\tskeletonColor.b * slotColor.b * attachmentColor.b,\n\t\t\t\t\t\tskeletonColor.a * slotColor.a * attachmentColor.a,\n\t\t\t\t\t);\n\n\t\t\t\t\tif (slot.darkColor) {\n\t\t\t\t\t\tcacheData.darkColor.setFromColor(slot.darkColor);\n\t\t\t\t\t}\n\n\t\t\t\t\tcacheData.skipRender = cacheData.clipped = false;\n\n\t\t\t\t\tconst texture = attachment.region?.texture.texture || Texture.EMPTY;\n\n\t\t\t\t\tif (cacheData.texture !== texture) {\n\t\t\t\t\t\tcacheData.texture = texture;\n\t\t\t\t\t\tthis.spineTexturesDirty = true;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (clipper.isClipping()) {\n\t\t\t\t\t\tthis.updateClippingData(cacheData);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse if (attachment instanceof ClippingAttachment) {\n\t\t\t\t\tclipper.clipStart(slot, attachment);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t}\n\t\t\tclipper.clipEndWithSlot(slot);\n\t\t}\n\t\tclipper.clipEnd();\n\t}\n\n\tprivate updateClippingData (cacheData: AttachmentCacheData) {\n\t\tcacheData.clipped = true;\n\n\t\tclipper.clipTrianglesUnpacked(\n\t\t\tcacheData.vertices,\n\t\t\tcacheData.indices,\n\t\t\tcacheData.indices.length,\n\t\t\tcacheData.uvs,\n\t\t);\n\n\t\tconst { clippedVertices, clippedUVs, clippedTriangles } = clipper;\n\n\t\tconst verticesCount = clippedVertices.length / 2;\n\t\tconst indicesCount = clippedTriangles.length;\n\n\t\tif (!cacheData.clippedData) {\n\t\t\tcacheData.clippedData = {\n\t\t\t\tvertices: new Float32Array(verticesCount * 2),\n\t\t\t\tuvs: new Float32Array(verticesCount * 2),\n\t\t\t\tvertexCount: verticesCount,\n\t\t\t\tindices: new Uint16Array(indicesCount),\n\t\t\t\tindicesCount,\n\t\t\t};\n\n\t\t\tthis.spineAttachmentsDirty = true;\n\t\t}\n\n\t\tconst clippedData = cacheData.clippedData;\n\n\t\tconst sizeChange = clippedData.vertexCount !== verticesCount || indicesCount !== clippedData.indicesCount;\n\n\t\tcacheData.skipRender = verticesCount === 0;\n\n\t\tif (sizeChange) {\n\t\t\tthis.spineAttachmentsDirty = true;\n\n\t\t\tif (clippedData.vertexCount < verticesCount) {\n\t\t\t\t// buffer reuse!\n\t\t\t\tclippedData.vertices = new Float32Array(verticesCount * 2);\n\t\t\t\tclippedData.uvs = new Float32Array(verticesCount * 2);\n\t\t\t}\n\n\t\t\tif (clippedData.indices.length < indicesCount) {\n\t\t\t\tclippedData.indices = new Uint16Array(indicesCount);\n\t\t\t}\n\t\t}\n\n\t\tconst { vertices, uvs, indices } = clippedData;\n\n\t\tfor (let i = 0; i < verticesCount; i++) {\n\t\t\tvertices[i * 2] = clippedVertices[i * 2];\n\t\t\tvertices[(i * 2) + 1] = clippedVertices[(i * 2) + 1];\n\n\t\t\tuvs[i * 2] = clippedUVs[(i * 2)];\n\t\t\tuvs[(i * 2) + 1] = clippedUVs[(i * 2) + 1];\n\t\t}\n\n\t\tclippedData.vertexCount = verticesCount;\n\n\t\tfor (let i = 0; i < indicesCount; i++) {\n\t\t\tif (indices[i] !== clippedTriangles[i]) {\n\t\t\t\tthis.spineAttachmentsDirty = true;\n\t\t\t\tindices[i] = clippedTriangles[i];\n\t\t\t}\n\t\t}\n\n\t\tclippedData.indicesCount = indicesCount;\n\t}\n\n\t/**\n\t * ensure that attached containers map correctly to their slots\n\t * along with their position, rotation, scale, and visibility.\n\t */\n\tprivate updateSlotObjects () {\n\t\tfor (const i in this._slotsObject) {\n\t\t\tconst slotAttachment = this._slotsObject[i];\n\n\t\t\tif (!slotAttachment) continue;\n\n\t\t\tthis.updateSlotObject(slotAttachment);\n\t\t}\n\t}\n\n\tprivate updateSlotObject (slotAttachment: { slot: Slot, container: Container }) {\n\t\tconst { slot, container } = slotAttachment;\n\n\t\tcontainer.visible = this.skeleton.drawOrder.includes(slot);\n\n\t\tif (container.visible) {\n\t\t\tconst bone = slot.bone;\n\n\t\t\tcontainer.position.set(bone.worldX, bone.worldY);\n\n\t\t\tcontainer.scale.x = bone.getWorldScaleX();\n\t\t\tcontainer.scale.y = bone.getWorldScaleY();\n\n\t\t\tcontainer.rotation = bone.getWorldRotationX() * DEG_TO_RAD;\n\n\t\t\tcontainer.alpha = this.skeleton.color.a * slot.color.a;\n\t\t}\n\t}\n\n\t/** @internal */\n\t_getCachedData (slot: Slot, attachment: RegionAttachment | MeshAttachment): AttachmentCacheData {\n\t\treturn this.attachmentCacheData[slot.data.index][attachment.name] || this.initCachedData(slot, attachment);\n\t}\n\n\tprivate initCachedData (slot: Slot, attachment: RegionAttachment | MeshAttachment): AttachmentCacheData {\n\t\tlet vertices: Float32Array;\n\n\t\tif (attachment instanceof RegionAttachment) {\n\t\t\tvertices = new Float32Array(8);\n\n\t\t\tthis.attachmentCacheData[slot.data.index][attachment.name] = {\n\t\t\t\tid: `${slot.data.index}-${attachment.name}`,\n\t\t\t\tvertices,\n\t\t\t\tclipped: false,\n\t\t\t\tindices: [0, 1, 2, 0, 2, 3],\n\t\t\t\tuvs: new Float32Array(attachment.uvs.length),\n\t\t\t\tcolor: new Color(1, 1, 1, 1),\n\t\t\t\tdarkColor: new Color(0, 0, 0, 0),\n\t\t\t\tdarkTint: this.darkTint,\n\t\t\t\tskipRender: false,\n\t\t\t\ttexture: attachment.region?.texture.texture,\n\t\t\t};\n\t\t}\n\t\telse {\n\t\t\tvertices = new Float32Array(attachment.worldVerticesLength);\n\n\t\t\tthis.attachmentCacheData[slot.data.index][attachment.name] = {\n\t\t\t\tid: `${slot.data.index}-${attachment.name}`,\n\t\t\t\tvertices,\n\t\t\t\tclipped: false,\n\t\t\t\tindices: attachment.triangles,\n\t\t\t\tuvs: new Float32Array(attachment.uvs.length),\n\t\t\t\tcolor: new Color(1, 1, 1, 1),\n\t\t\t\tdarkColor: new Color(0, 0, 0, 0),\n\t\t\t\tdarkTint: this.darkTint,\n\t\t\t\tskipRender: false,\n\t\t\t\ttexture: attachment.region?.texture.texture,\n\t\t\t};\n\t\t}\n\n\t\treturn this.attachmentCacheData[slot.data.index][attachment.name];\n\t}\n\n\tprotected onViewUpdate () {\n\t\t// increment from the 12th bit!\n\t\tthis._didChangeId += 1 << 12;\n\n\t\tthis._boundsDirty = true;\n\n\t\tif (this.didViewUpdate) return;\n\t\tthis.didViewUpdate = true;\n\n\t\tconst renderGroup = this.renderGroup || this.parentRenderGroup;\n\n\t\tif (renderGroup) {\n\t\t\trenderGroup.onChildViewUpdate(this);\n\t\t}\n\n\t\tthis.debug?.renderDebug(this);\n\t}\n\n\t/**\n\t * Attaches a PixiJS container to a specified slot. This will map the world transform of the slots bone\n\t * to the attached container. A container can only be attached to one slot at a time.\n\t *\n\t * @param container - The container to attach to the slot\n\t * @param slotRef - The slot id or  slot to attach to\n\t */\n\tpublic addSlotObject (slot: number | string | Slot, container: Container) {\n\t\tslot = this.getSlotFromRef(slot);\n\n\t\t// need to check in on the container too...\n\t\tfor (const i in this._slotsObject) {\n\t\t\tif (this._slotsObject[i]?.container === container) {\n\t\t\t\tthis.removeSlotObject(this._slotsObject[i].slot);\n\t\t\t}\n\t\t}\n\n\t\tthis.removeSlotObject(slot);\n\n\t\tcontainer.includeInBuild = false;\n\n\t\t// TODO only add once??\n\t\tthis.addChild(container);\n\n\t\tconst slotObject = { container, slot };\n\t\tthis._slotsObject[slot.data.name] = slotObject;\n\n\t\tthis.updateSlotObject(slotObject);\n\t}\n\n\t/**\n\t * Removes a PixiJS container from the slot it is attached to.\n\t *\n\t * @param container - The container to detach from the slot\n\t * @param slotOrContainer - The container, slot id or slot to detach from\n\t */\n\tpublic removeSlotObject (slotOrContainer: number | string | Slot | Container) {\n\t\tlet containerToRemove: Container | undefined;\n\n\t\tif (slotOrContainer instanceof Container) {\n\t\t\tfor (const i in this._slotsObject) {\n\t\t\t\tif (this._slotsObject[i]?.container === slotOrContainer) {\n\t\t\t\t\tthis._slotsObject[i] = null;\n\n\t\t\t\t\tcontainerToRemove = slotOrContainer;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tconst slot = this.getSlotFromRef(slotOrContainer);\n\n\t\t\tcontainerToRemove = this._slotsObject[slot.data.name]?.container;\n\t\t\tthis._slotsObject[slot.data.name] = null;\n\t\t}\n\n\t\tif (containerToRemove) {\n\t\t\tthis.removeChild(containerToRemove);\n\n\t\t\tcontainerToRemove.includeInBuild = true;\n\t\t}\n\t}\n\n\t/**\n\t * Returns a container attached to a slot, or undefined if no container is attached.\n\t *\n\t * @param slotRef - The slot id or slot to get the attachment from\n\t * @returns - The container attached to the slot\n\t */\n\tpublic getSlotObject (slot: number | string | Slot) {\n\t\tslot = this.getSlotFromRef(slot);\n\n\t\treturn this._slotsObject[slot.data.name]?.container;\n\t}\n\n\tprivate updateBounds () {\n\t\tthis._boundsDirty = false;\n\n\t\tthis.skeletonBounds ||= new SkeletonBounds();\n\n\t\tconst skeletonBounds = this.skeletonBounds;\n\n\t\tskeletonBounds.update(this.skeleton, true);\n\n\t\tif (skeletonBounds.minX === Infinity) {\n\t\t\tthis._applyState();\n\n\t\t\tconst drawOrder = this.skeleton.drawOrder;\n\t\t\tconst bounds = this._bounds;\n\n\t\t\tbounds.clear();\n\n\t\t\tfor (let i = 0; i < drawOrder.length; i++) {\n\t\t\t\tconst slot = drawOrder[i];\n\n\t\t\t\tconst attachment = slot.getAttachment();\n\n\t\t\t\tif (attachment && (attachment instanceof RegionAttachment || attachment instanceof MeshAttachment)) {\n\t\t\t\t\tconst cacheData = this._getCachedData(slot, attachment);\n\n\t\t\t\t\tbounds.addVertexData(cacheData.vertices, 0, cacheData.vertices.length);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tthis._bounds.minX = skeletonBounds.minX;\n\t\t\tthis._bounds.minY = skeletonBounds.minY;\n\t\t\tthis._bounds.maxX = skeletonBounds.maxX;\n\t\t\tthis._bounds.maxY = skeletonBounds.maxY;\n\t\t}\n\t}\n\n\t/** @internal */\n\taddBounds (bounds: Bounds) {\n\t\tbounds.addBounds(this.bounds);\n\t}\n\n\t/**\n\t * Destroys this sprite renderable and optionally its texture.\n\t * @param options - Options parameter. A boolean will act as if all options\n\t *  have been set to that value\n\t * @param {boolean} [options.texture=false] - Should it destroy the current texture of the renderable as well\n\t * @param {boolean} [options.textureSource=false] - Should it destroy the textureSource of the renderable as well\n\t */\n\tpublic override destroy (options: DestroyOptions = false) {\n\t\tsuper.destroy(options);\n\n\t\tTicker.shared.remove(this.internalUpdate, this);\n\t\tthis.state.clearListeners();\n\t\tthis.debug = undefined;\n\t\tthis.skeleton = null as any;\n\t\tthis.state = null as any;\n\t\t(this._slotsObject as any) = null;\n\t\tthis._lastAttachments.length = 0;\n\t\tthis.attachmentCacheData = null as any;\n\t}\n\n\t/** Converts a point from the skeleton coordinate system to the Pixi world coordinate system. */\n\tpublic skeletonToPixiWorldCoordinates (point: { x: number; y: number }) {\n\t\tthis.worldTransform.apply(point, point);\n\t}\n\n\t/** Converts a point from the Pixi world coordinate system to the skeleton coordinate system. */\n\tpublic pixiWorldCoordinatesToSkeleton (point: { x: number; y: number }) {\n\t\tthis.worldTransform.applyInverse(point, point);\n\t}\n\n\t/** Converts a point from the Pixi world coordinate system to the bone's local coordinate system. */\n\tpublic pixiWorldCoordinatesToBone (point: { x: number; y: number }, bone: Bone) {\n\t\tthis.pixiWorldCoordinatesToSkeleton(point);\n\t\tif (bone.parent) {\n\t\t\tbone.parent.worldToLocal(point as Vector2);\n\t\t}\n\t\telse {\n\t\t\tbone.worldToLocal(point as Vector2);\n\t\t}\n\t}\n\n\t/**\n\t * Use this method to instantiate a Spine game object.\n\t * Before instantiating a Spine game object, the skeleton (`.skel` or `.json`) and the atlas text files must be loaded into the Assets. For example:\n\t * ```\n\t * PIXI.Assets.add(\"sackData\", \"./assets/sack-pro.skel\");\n\t * PIXI.Assets.add(\"sackAtlas\", \"./assets/sack-pma.atlas\");\n\t * await PIXI.Assets.load([\"sackData\", \"sackAtlas\"]);\n\t * ```\n\t * Once a Spine game object is created, its skeleton data is cached into {@link Cache} using the key:\n\t * `${skeletonAssetName}-${atlasAssetName}-${options?.scale ?? 1}`\n\t *\n\t * @param options - Options to configure the Spine game object. See {@link SpineFromOptions}\n\t * @returns {Spine} The Spine game object instantiated\n\t */\n\tstatic from ({ skeleton, atlas, scale = 1, darkTint, autoUpdate = true }: SpineFromOptions) {\n\t\tconst cacheKey = `${skeleton}-${atlas}-${scale}`;\n\n\t\tif (Cache.has(cacheKey)) {\n\t\t\treturn new Spine(Cache.get<SkeletonData>(cacheKey));\n\t\t}\n\n\t\tconst skeletonAsset = Assets.get<any | Uint8Array>(skeleton);\n\n\t\tconst atlasAsset = Assets.get<TextureAtlas>(atlas);\n\t\tconst attachmentLoader = new AtlasAttachmentLoader(atlasAsset);\n\t\tconst parser = skeletonAsset instanceof Uint8Array\n\t\t\t? new SkeletonBinary(attachmentLoader)\n\t\t\t: new SkeletonJson(attachmentLoader);\n\n\t\tparser.scale = scale;\n\t\tconst skeletonData = parser.readSkeletonData(skeletonAsset);\n\n\t\tCache.set(cacheKey, skeletonData);\n\n\t\treturn new Spine({\n\t\t\tskeletonData,\n\t\t\tdarkTint,\n\t\t\tautoUpdate,\n\t\t});\n\t}\n}\n"]}