{"version":3,"sources":["../../src/core/AttachmentType.ts","../../src/core/IAnimation.ts","../../src/core/IConstraint.ts","../../src/core/ISkeleton.ts","../../src/core/BinaryInput.ts","../../../../common/temp/node_modules/.pnpm/registry.npmjs.org/tslib/2.2.0/node_modules/tslib/tslib.es6.js","../../src/core/TextureRegion.ts","../../src/core/Utils.ts","../../src/core/TextureAtlas.ts","../../src/settings.ts","../../src/SpineBase.ts","../../src/loaders.ts","../../src/core/Animation.ts","../../src/core/attachments/Attachment.ts","../../src/core/attachments/BoundingBoxAttachment.ts","../../src/core/attachments/ClippingAttachment.ts","../../src/core/attachments/MeshAttachment.ts","../../src/core/attachments/PathAttachment.ts","../../src/core/attachments/PointAttachment.ts","../../src/core/attachments/RegionAttachment.ts","../../src/core/vertexeffects/JitterEffect.ts","../../src/core/vertexeffects/SwirlEffect.ts","../../src/core/AnimationState.ts","../../src/core/PathConstraintData.ts","../../src/core/AnimationStateData.ts","../../src/core/AtlasAttachmentLoader.ts","../../src/core/Bone.ts","../../src/core/BoneData.ts","../../src/core/Constraint.ts","../../src/core/Event.ts","../../src/core/EventData.ts","../../src/core/IkConstraint.ts","../../src/core/IkConstraintData.ts","../../src/core/PathConstraint.ts","../../src/core/Slot.ts","../../src/core/TransformConstraint.ts","../../src/core/Skeleton.ts","../../src/core/SkeletonData.ts","../../src/core/SlotData.ts","../../src/core/TransformConstraintData.ts","../../src/core/Skin.ts","../../src/core/SkeletonBinary.ts","../../src/core/SkeletonBounds.ts","../../src/core/SkeletonJson.ts","../../src/Spine.ts","../../src/index.ts"],"names":["AttachmentType","MixBlend","MixDirection","PositionMode","RotateMode","TransformMode","data","strings","index","buffer","Array","DataView","readByte","this","getInt8","readUnsignedByte","getUint8","readShort","value","getInt16","readInt32","getInt32","readInt","optimizePositive","b","result","readStringRef","readString","byteCount","chars","i","String","fromCharCode","readFloat","getFloat32","readBoolean","TextureFilter","TextureWrap","d","Object","setPrototypeOf","__proto__","p","prototype","hasOwnProperty","call","__extends","TypeError","__","constructor","create","filterFromString","text","toLowerCase","Nearest","Linear","MipMap","MipMapNearestNearest","MipMapLinearNearest","MipMapNearestLinear","MipMapLinearLinear","Error","wrapFromString","MirroredRepeat","ClampToEdge","Repeat","array","size","names","values","tex","texture","trim","width","orig","height","_uvs","x0","y0","x2","y2","x","spineOffsetY","y","originalHeight","frame","rotate","offsetX","offsetY","originalWidth","atlasText","textureLoader","callback","pages","regions","addSpineAtlas","addTexture","name","page","length","baseTexture","realWidth","realHeight","minFilter","magFilter","uWrap","vWrap","push","region","TextureAtlasRegion","addTextureHash","textures","stripExtension","key","indexOf","substr","lastIndexOf","load","reader","TextureAtlasReader","entry","pageFields","parseInt","pma","regionFields","rotateValue","toLocaleLowerCase","parseFloat","line","readLine","readEntry","iterateParser","field","splice","alphaMode","PMA","valid","setSize","setFilters","console","log","RegionFields","atlasRegion","count","entryValues","resolution","swapWH","updateUvs","findRegion","dispose","lines","split","colon","lastMatch","comma","filter","scaleMode","LINEAR","NEAREST","mipmap","POW2","TextureRegion","fround_polyfill","Float32Array","fround","Math","add","contains","undefined","remove","clear","entries","addAll","oldSize","n","r","g","a","set","clamp","setFromColor","c","setFromString","hex","charAt","rgba8888ToColor","color","rgb888ToColor","fromString","Color","WHITE","RED","GREEN","BLUE","MAGENTA","min","max","cosDeg","degrees","cos","MathUtils","degRad","sinDeg","sin","signum","toInt","floor","ceil","cbrt","pow","abs","randomTriangular","randomTriangularWith","mode","u","random","sqrt","PI","PI2","radiansToDegrees","radDeg","degreesToRadians","apply","start","end","applyInternal","power","Interpolation","Pow","arrayCopy","source","sourceStart","dest","destStart","numElements","j","arrayFill","fromIndex","toIndex","setArraySize","ensureArrayCapacity","Utils","newArray","defaultValue","newFloatArray","SUPPORTS_TYPED_ARRAYS","newShortArray","Int16Array","toFloatArray","toSinglePrecision","webkit602BugfixHelper","alpha","blend","element","identity","enumValue","type","toUpperCase","slice","logBones","skeleton","bones","bone","mat","matrix","tx","ty","instantiator","items","obtain","pop","free","item","reset","freeAll","normalize","len","maxDelta","framesPerSecond","delta","totalTime","lastTime","Date","now","frameCount","frameTime","update","windowSize","addedValues","lastValue","mean","dirty","hasEnoughData","addValue","getMean","settings","yDown","FAIL_ON_NON_EXISTING_SKIN","GLOBAL_AUTO_UPDATE","GLOBAL_DELAY_LIMIT","tempRgb","attachment","vertices","uvs","indices","drawMode","spineData","createSkeleton","slotContainers","tempClipContainers","slots","slot","getAttachment","slotContainer","newContainer","addChild","Region","spriteName","sprite","createSprite","currentSprite","currentSpriteName","Mesh","mesh","createMesh","currentMesh","currentMeshId","id","currentMeshName","Clipping","createGraphics","clippingContainer","currentGraphics","tintRgb","autoUpdate","visible","_autoUpdate","updateTransform","SpineBase","autoUpdateTransform","localDelayLimit","Number","MAX_VALUE","dt","delayLimit","state","updateWorldTransform","globalClr","light","dark","spriteColor","attColor","ar","hackRegion","setSpriteRegion","sprites","transform","setFromMatrix","tint","blendMode","_parentID","_worldID","meshId","meshes","computeWorldVerticesOld","updateGraphics","r0","g0","b0","setLight","darkColor","setDark","drawOrder","clippingAttachment","parent","removeChild","children","endSlot","renderable","rotation","position","scale","scaleX","scaleY","setMeshRegion","uvBuffer","regionUVs","timeDelta","defName","hackAttachment","newSprite","anchor","strip","newMesh","Uint16Array","triangles","TRIANGLES","_canvasPadding","clip","graphics","newGraphics","poly","beginFill","drawPolygon","mask","geom","geometry","graphicsData","shape","points","worldVerticesLength","computeWorldVertices","invalidate","hackTextureBySlotIndex","slotIndex","hackTextureBySlotName","slotName","findSlotIndex","hackTextureAttachment","attachmentName","getAttachmentByName","currentAttachment","SpineSprite","SpineMesh","transformHack","hackAttachmentGroups","nameSuffix","group","outGroup","list_d","list_n","target","endsWith","parentGroup","destroy","options","stateData","clippingPolygon","defineProperty","get","_visible","setExtensionXhrType","XHR_RESPONSE_TYPE","BUFFER","genMiddleware","self","use","resource","next","isJsonSpineModel","TYPE","JSON","isJson","isBinarySpineModel","xhrType","isBuffer","extension","metadata","spineMetadata","parser","dataToParse","createJsonParser","createBinaryParser","ArrayBuffer","Uint8Array","metadataSkeletonScale","spineSkeletonScale","metadataAtlas","spineAtlas","parseData","metadataAtlasSuffix","spineAtlasSuffix","atlasPath","url","queryStringPos","spineAtlasFile","replace","baseUrl","atlasOptions","crossOrigin","TEXT","parentResource","imageOptions","imageMetadata","namePrefix","imageNamePrefix","adapter","images","staticImageLoader","image","imageLoader","loader","cachedResource","resources","done","onAfterMiddleware","error","imageLoaderAdapter","createSkeletonWithRawAtlas","rawData","atlasRawData","atlasResource","TimelineType","VertexAttachment","nextID","deformAttachment","worldVertices","offset","stride","deformArray","deform","v","skip","skeletonBones","w","wx","wy","vx","vy","weight","f","copyTo","Attachment","BoundingBox","copy","BoundingBoxAttachment","ClippingAttachment","tempColor","getParentMesh","parentMesh","setParentMesh","hullLength","newLinkedMesh","MeshAttachment","path","edges","Path","closed","constantSpeed","PathAttachment","lengths","Point","computeWorldPosition","point","worldX","worldY","computeWorldRotation","atan2","PointAttachment","updateOffset","regionScaleX","regionScaleY","localX","localY","localX2","localY2","radians","localXCos","localXSin","localYCos","localYSin","localX2Cos","localX2Sin","localY2Cos","localY2Sin","RegionAttachment","OX1","OY1","OX2","OY2","OX3","OY3","OX4","OY4","setRegion","v2","u2","vertexOffset","rendererObject","X1","Y1","C1R","C1G","C1B","C1A","U1","V1","X2","Y2","C2R","C2G","C2B","C2A","U2","V2","X3","Y3","C3R","C3G","C3B","C3A","U3","V3","X4","Y4","C4R","C4G","C4B","C4A","U4","V4","jitterX","jitterY","begin","uv","radius","centerX","centerY","angle","radAngle","dist","theta","SwirlEffect","interpolation","PowOut","timelines","duration","timelineIds","getPropertyId","hasTimeline","time","loop","events","direction","binarySearch","step","low","high","current","linearSearch","last","EventType","curves","CurveTimeline","BEZIER_SIZE","getFrameCount","setLinear","frameIndex","setStepped","STEPPED","getCurveType","BEZIER","setCurve","cx1","cy1","cx2","cy2","tmpx","tmpy","dddfx","dddfy","ddfx","ddfy","dfx","dfy","getCurvePercent","percent","prevX","prevY","frames","boneIndex","setFrame","RotateTimeline","ROTATION","active","setup","first","ENTRIES","PREV_ROTATION","Animation","prevRotation","PREV_TIME","TranslateTimeline","translate","X","Y","PREV_X","PREV_Y","ScaleTimeline","bx","by","mixOut","shear","shearX","shearY","ShearTimeline","ColorTimeline","R","G","B","A","PREV_R","PREV_G","PREV_B","PREV_A","TwoColorTimeline","twoColor","r2","g2","b2","R2","G2","B2","setupLight","setupDark","PREV_R2","PREV_G2","PREV_B2","attachmentNames","setAttachment","zeros","frameVertices","firedEvents","slotAttachment","vertexCount","vertexAttachment","setupVertices","lastVertices","prevVertices","nextVertices","prev","event","drawOrders","drawOrderToSetupIndex","IkConstraintTimeline","ikConstraint","ikConstraintIndex","mix","softness","bendDirection","compress","stretch","MIX","SOFTNESS","BEND_DIRECTION","COMPRESS","STRETCH","constraint","ikConstraints","PREV_MIX","PREV_SOFTNESS","PREV_BEND_DIRECTION","PREV_COMPRESS","PREV_STRETCH","mixIn","TransformConstraintTimeline","transformConstraint","transformConstraintIndex","rotateMix","translateMix","scaleMix","shearMix","ROTATE","TRANSLATE","SCALE","SHEAR","transformConstraints","PREV_ROTATE","PREV_TRANSLATE","PREV_SCALE","PREV_SHEAR","PathConstraintPositionTimeline","pathConstraintPosition","pathConstraintIndex","VALUE","pathConstraints","PREV_VALUE","pathConstraintSpacing","spacing","PathConstraintSpacingTimeline","PathConstraintMixTimeline","pathConstraintMix","tracks","timeScale","unkeyedState","listeners","queue","propertyIDs","IntSet","animationsChanged","trackEntryPool","Pool","animationLast","nextAnimationLast","trackLast","nextTrackLast","currentDelta","delay","nextTime","trackTime","setCurrent","mixingFrom","mixTime","trackEnd","disposeNext","updateMixingFrom","from","mixingTo","drain","to","finished","mixDuration","totalAlpha","interruptAlpha","_animationsChanged","applied","mixBlend","applyMixingFrom","animationTime","getAnimationTime","timelineCount","animation","ii","timeline","applyAttachmentTimeline","timelineMode","firstFrame","timelinesRotation","timelineBlend","AnimationState","SUBSEQUENT","applyRotateTimeline","queueEvents","setupState","SETUP","attachmentState","eventThreshold","attachments","attachmentThreshold","drawOrderThreshold","alphaHold","alphaMix","timelineHoldMix","FIRST","HOLD_SUBSEQUENT","HOLD_FIRST","holdMix","CURRENT","rotateTimeline","r1","total","diff","lastTotal","lastDiff","dir","animationStart","animationEnd","trackLastWrapped","complete","clearTracks","oldDrainDisabled","drainDisabled","clearTrack","trackIndex","interrupt","expandToIndex","setAnimation","animationName","skeletonData","findAnimation","setAnimationWith","trackEntry","addAnimation","addAnimationWith","getMix","setEmptyAnimation","emptyAnimation","addEmptyAnimation","setEmptyAnimations","holdPrevious","computeHold","timelinesCount","timelineDipMix","outer","HOLD_MIX","getCurrent","addListener","listener","removeListener","clearListeners","clearListenerNotifications","setAnimationByName","deprecatedWarning1","warn","addAnimationByName","deprecatedWarning2","hasAnimation","hasAnimationByName","deprecatedWarning3","setAnimationLast","isComplete","resetRotationDirections","TrackEntry","loopsCount","animState","objects","deprecateStuff","EventQueue","onStart","onEnd","onComplete","onEvent","SpacingMode","animationToMixTime","defaultMix","setMix","fromName","toName","setMixWith","setMixByName","AnimationStateData","atlas","newRegionAttachment","skin","newMeshAttachment","newBoundingBoxAttachment","newPathAttachment","newPointAttachment","newClippingAttachment","ax","ay","arotation","ascaleX","ascaleY","ashearX","ashearY","appliedValid","sorted","setToSetupPose","isActive","updateWorldTransformWith","m","sx","sy","rotationY","pa","pb","pc","pd","transformMode","Normal","la","lb","lc","ld","OnlyTranslation","NoRotationOrReflection","prx","s","rx","ry","NoScale","NoScaleOrReflection","za","zc","zb","zd","getWorldRotationX","getWorldRotationY","getWorldScaleX","getWorldScaleY","updateAppliedTransform","pm","pid","dx","dy","ia","ib","ic","ra","rb","rc","rd","det","worldToLocal","world","invDet","localToWorld","local","worldToLocalRotation","worldRotation","localToWorldRotation","localRotation","rotateWorld","skinRequired","order","findBone","apply1","uniform","apply2","targetX","targetY","rotationIK","sa","sc","dd","child","bendDir","px","py","psx","psy","csx","pmat","os1","os2","s2","cx","cy","cwx","cwy","pp","a1","a2","l1","l2","td","sd","acos","aa","bb","ta","c1","c2","q","minAngle","minX","minDist","minY","maxAngle","maxX","maxDist","maxY","os","ConstraintData","spaces","positions","segments","findSlot","spacingMode","lengthSpacing","Length","rotateMode","tangents","Tangent","ChainScale","boneCount","spacesCount","setupLength","PathConstraint","epsilon","computeWorldPositions","positionMode","Percent","boneX","boneY","offsetRotation","tip","Chain","percentPosition","percentSpacing","out","verticesLength","curveCount","prevCurve","NONE","o","curve","space","BEFORE","addBeforePosition","AFTER","addAfterPosition","addCurvePosition","pathLength","x1","y1","curveLength","segment","temp","isNaN","tt","ttt","uu","uuu","ut","ut3","uut3","utt3","attachmentTime","setAttachmentTime","getAttachmentTime","Vector2","relative","applyRelativeLocal","applyAbsoluteLocal","applyRelativeWorld","applyAbsoluteWorld","targetMat","tb","tc","degRadReflect","offsetShearY","modified","ts","offsetScaleX","offsetScaleY","_updateCache","updateCacheReset","boneData","slotData","ikConstraintData","transformConstraintData","pathConstraintData","updateCache","skinBones","ikCount","transformCount","pathCount","constraintCount","sortIkConstraint","sortTransformConstraint","sortPathConstraint","sortBone","constraints","constrained","sortReset","slotBone","sortPathConstraintAttachment","defaultSkin","skins","sortPathConstraintAttachmentWith","pathBones","setBonesToSetupPose","setSlotsToSetupPose","getRootBone","boneName","findBoneIndex","setSkinByName","skinName","findSkin","setSkin","newSkin","attachAll","findIkConstraint","constraintName","findTransformConstraint","findPathConstraint","getBounds","POSITIVE_INFINITY","NEGATIVE_INFINITY","nn","Skeleton","animations","fps","findEvent","eventDataName","findPathConstraintIndex","pathConstraintName","addSkin","contained","getAttachments","copySkin","dictionary","removeAttachment","slotAttachments","SkinEntry","getAttachmentsForSlot","oldSkin","attachmentLoader","linkedMeshes","readSkeletonData","binary","SkeletonData","input","BinaryInput","hash","version","nonessential","imagesPath","audioPath","SkeletonBinary","TransformModeValues","BlendModeValues","IkConstraintData","TransformConstraintData","PathConstraintData","PositionModeValues","SpacingModeValues","RotateModeValues","Fixed","readSkin","linkedMesh","inheritDeform","EventData","intValue","floatValue","stringValue","volume","balance","readAnimation","slotCount","Skin","readAttachment","typeIndex","AttachmentTypeValues","readVertices","box","readFloatArray","readShortArray","LinkedMesh","endSlotIndex","Vertices","weights","bonesArray","tempColor1","tempColor2","timelineType","SLOT_ATTACHMENT","SLOT_COLOR","readCurve","SLOT_TWO_COLOR","BONE_ROTATE","BONE_TRANSLATE","BONE_SCALE","BONE_SHEAR","timelineScale","PATH_POSITION","PATH_SPACING","PATH_MIX","iii","nnn","weighted","deformLength","vn","drawOrderCount","offsetCount","unchanged","originalIndex","unchangedIndex","eventCount","eventData","Event","CURVE_STEPPED","CURVE_BEZIER","NORMAL","ADD","MULTIPLY","SCREEN","CURVE_LINEAR","boundingBoxes","polygons","polygonPool","updateAabb","boundingBox","polygon","aabbCompute","aabbContainsPoint","aabbIntersectsSegment","aabbIntersectsSkeleton","bounds","containsPoint","containsPointPolygon","prevIndex","inside","vertexY","vertexX","intersectsSegment","intersectsSegmentPolygon","width12","height12","det1","x3","y3","x4","y4","det2","width34","height34","det3","getPolygon","getWidth","getHeight","json","root","parse","skeletonMap","spine","boneMap","parentName","getValue","SkeletonJson","transformModeFromString","slotMap","blendModeFromString","ik","constraintMap","targetName","positionModeFromString","spacingModeFromString","rotateModeFromString","skinMap","entryName","eventName","eventMap","animationMap","map","scaledVertices","timelineName","timelineMap","valueMap","deformName","deformMap","verticesValue","drawOrderNode","draworder","drawOrderMap","offsets","offsetMap","prop","str","Spine","registerLoaderPlugin"],"mappings":"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","file":"static/js/83.4fbc4a34.chunk.js","sourcesContent":["\r\n/**\r\n * @public\r\n */\r\nexport enum AttachmentType {\r\n    Region, BoundingBox, Mesh, LinkedMesh, Path, Point, Clipping\r\n}\r\n","import {ISkeleton, ISkeletonData} from './ISkeleton';\r\nimport type {Map} from './Utils';\r\n\r\n// Those enums were moved from Animation.ts of spine 3.8 and 4.0\r\n\r\n/** Controls how a timeline value is mixed with the setup pose value or current pose value when a timeline's `alpha`\r\n * < 1.\r\n *\r\n * See Timeline {@link Timeline#apply(Skeleton, float, float, Array, float, MixBlend, MixDirection)}.\r\n * @public\r\n * */\r\nexport enum MixBlend {\r\n    /** Transitions from the setup value to the timeline value (the current value is not used). Before the first key, the setup\r\n     * value is set. */\r\n    setup,\r\n    /** Transitions from the current value to the timeline value. Before the first key, transitions from the current value to\r\n     * the setup value. Timelines which perform instant transitions, such as DrawOrderTimeline or\r\n     * AttachmentTimeline, use the setup value before the first key.\r\n     *\r\n     * `first` is intended for the first animations applied, not for animations layered on top of those. */\r\n    first,\r\n    /** Transitions from the current value to the timeline value. No change is made before the first key (the current value is\r\n     * kept until the first key).\r\n     *\r\n     * `replace` is intended for animations layered on top of others, not for the first animations applied. */\r\n    replace,\r\n    /** Transitions from the current value to the current value plus the timeline value. No change is made before the first key\r\n     * (the current value is kept until the first key).\r\n     *\r\n     * `add` is intended for animations layered on top of others, not for the first animations applied. Properties\r\n     * keyed by additive animations must be set manually or by another animation before applying the additive animations, else\r\n     * the property values will increase continually. */\r\n    add\r\n}\r\n\r\n/** Indicates whether a timeline's `alpha` is mixing out over time toward 0 (the setup or current pose value) or\r\n * mixing in toward 1 (the timeline's value).\r\n *\r\n * See Timeline {@link Timeline#apply(Skeleton, float, float, Array, float, MixBlend, MixDirection)}.\r\n * @public\r\n * */\r\nexport enum MixDirection {\r\n    mixIn, mixOut\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface IAnimation<Timeline extends ITimeline = ITimeline> {\r\n    name: string;\r\n    timelines: Timeline[];\r\n    duration: number;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\n export interface IAnimationState<AnimationStateData extends IAnimationStateData = IAnimationStateData> {\r\n    data: AnimationStateData;\r\n    tracks: ITrackEntry[];\r\n    listeners: IAnimationStateListener[];\r\n    timeScale: number;\r\n\r\n    update(dt: number): void;\r\n    apply(skeleton: ISkeleton): boolean;\r\n\r\n    setAnimation (trackIndex: number, animationName: string, loop: boolean): ITrackEntry;\r\n    addAnimation (trackIndex: number, animationName: string, loop: boolean, delay: number): ITrackEntry;\r\n    addEmptyAnimation (trackIndex: number, mixDuration: number, delay: number): ITrackEntry;\r\n    setEmptyAnimation (trackIndex: number, mixDuration: number): ITrackEntry;\r\n    setEmptyAnimations (mixDuration: number): void;\r\n    hasAnimation(animationName: string): boolean;\r\n    addListener (listener: IAnimationStateListener): void;\r\n    removeListener (listener: IAnimationStateListener): void;\r\n    clearListeners (): void;\r\n    clearTracks (): void;\r\n    clearTrack (index: number): void;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\n export interface IAnimationStateData<SkeletonData extends ISkeletonData = ISkeletonData, Animation extends IAnimation = IAnimation> {\r\n    skeletonData: SkeletonData;\r\n    animationToMixTime: Map<number>;\r\n    defaultMix: number;\r\n    setMix (fromName: string, toName: string, duration: number): void;\r\n    setMixWith (from: Animation, to: Animation, duration: number): void;\r\n    getMix (from: Animation, to: Animation): number;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\n export interface IAnimationStateListener {\r\n    start? (entry: ITrackEntry): void;\r\n    interrupt? (entry: ITrackEntry): void;\r\n    end? (entry: ITrackEntry): void;\r\n    dispose? (entry: ITrackEntry): void;\r\n    complete? (entry: ITrackEntry): void;\r\n    event? (entry: ITrackEntry, event: IEvent): void;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface ITimeline {\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\n export interface ITrackEntry {\r\n    trackIndex: number;\r\n    loop: boolean;\r\n    animationEnd: number;\r\n    listener: IAnimationStateListener;\r\n\r\n    delay: number; trackTime: number; trackLast: number; nextTrackLast: number; trackEnd: number; timeScale: number;\r\n    alpha: number; mixTime: number; mixDuration: number; interruptAlpha: number; totalAlpha: number;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface IEventData {\r\n    name: string;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface IEvent {\r\n    time: number;\r\n    data: IEventData;\r\n}\r\n","\r\n// These enums were moved from PathConstraintData.ts of spine 3.7, 3.8 and 4.0\r\n\r\n/** Controls how the first bone is positioned along the path.\r\n *\r\n * See [Position mode](http://esotericsoftware.com/spine-path-constraints#Position-mode) in the Spine User Guide.\r\n * @public\r\n * */\r\nexport enum PositionMode {\r\n    Fixed, Percent\r\n}\r\n\r\n/** Controls how bones are rotated, translated, and scaled to match the path.\r\n *\r\n * [Rotate mode](http://esotericsoftware.com/spine-path-constraints#Rotate-mod) in the Spine User Guide.\r\n * @public\r\n * */\r\nexport enum RotateMode {\r\n    Tangent, Chain, ChainScale\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface IConstraintData {\r\n    name: string;\r\n    order: number;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface IIkConstraint {\r\n    data: IIkConstraintData;\r\n    /** -1 | 0 | 1 */\r\n    bendDirection: number;\r\n    compress: boolean;\r\n    stretch: boolean;\r\n\r\n    /** A percentage (0-1) */\r\n    mix: number;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface IIkConstraintData extends IConstraintData {\r\n    /** -1 | 0 | 1 */\r\n    bendDirection: number;\r\n    compress: boolean;\r\n    stretch: boolean;\r\n    uniform: boolean;\r\n\r\n    /** A percentage (0-1) */\r\n    mix: number;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface IPathConstraint {\r\n    data: IPathConstraintData;\r\n    position: number;\r\n    spacing: number;\r\n\r\n    spaces: number[];\r\n    positions: number[];\r\n    world: number[];\r\n    curves: number[];\r\n    lengths: number[];\r\n    segments: number[];\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface IPathConstraintData extends IConstraintData {\r\n    positionMode: PositionMode;\r\n    rotateMode: RotateMode;\r\n    offsetRotation: number;\r\n    position: number;\r\n    spacing: number;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface ITransformConstraint {\r\n    data: ITransformConstraintData;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface ITransformConstraintData extends IConstraintData {\r\n    offsetRotation: number;\r\n    offsetX: number;\r\n    offsetY: number;\r\n    offsetScaleX: number;\r\n    offsetScaleY: number;\r\n    offsetShearY: number;\r\n    relative: boolean;\r\n    local: boolean;\r\n}\r\n","import {AttachmentType} from './AttachmentType';\r\nimport {IAnimation, IEventData} from \"./IAnimation\";\r\nimport {IIkConstraintData, IPathConstraintData, ITransformConstraintData} from './IConstraint';\r\nimport type {Color, Vector2, Map} from './Utils';\r\nimport type {TextureRegion} from './TextureRegion';\r\n\r\nimport type {Matrix} from '@pixi/math';\r\nimport {BLEND_MODES} from '@pixi/constants';\r\n\r\n// This enum was moved from BoneData.ts of spine 3.7, 3.8 and 4.0\r\n\r\n/** Determines how a bone inherits world transforms from parent bones.\r\n * @public\r\n * */\r\n export enum TransformMode {\r\n    Normal,\r\n    OnlyTranslation,\r\n    NoRotationOrReflection,\r\n    NoScale,\r\n    NoScaleOrReflection\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface IBone {\r\n    data: { name: string };\r\n    matrix: Matrix;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface ISkin {\r\n    name: string;\r\n    attachments: Array<Map<IAttachment>>;\r\n\r\n    getAttachment (slotIndex: number, name: string): IAttachment | null;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface IAttachment {\r\n    name: string;\r\n    type: AttachmentType;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface IVertexAttachment<Slot extends ISlot = ISlot> extends IAttachment {\r\n    id: number;\r\n    computeWorldVerticesOld(slot: Slot, worldVertices: ArrayLike<number>): void;\r\n    computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;\r\n    worldVerticesLength: number;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface IClippingAttachment extends IVertexAttachment {\r\n    endSlot?: ISlotData;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface IRegionAttachment extends IAttachment {\r\n    region: TextureRegion;\r\n    color: Color;\r\n    x, y, scaleX, scaleY, rotation, width, height: number;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface IMeshAttachment extends IVertexAttachment {\r\n    region: TextureRegion;\r\n    color: Color;\r\n    regionUVs: Float32Array,\r\n    triangles: number[],\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface ISlotData {\r\n    index: number;\r\n    name: string;\r\n    boneData: IBoneData;\r\n    color: Color;\r\n    darkColor: Color;\r\n    attachmentName: string;\r\n    blendMode: BLEND_MODES;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface IBoneData {\r\n    index: number;\r\n    name: string;\r\n    parent: IBoneData;\r\n    length: number;\r\n    x: number;\r\n    y: number;\r\n    rotation: number;\r\n    scaleX: number;\r\n    scaleY: number;\r\n    shearX: number;\r\n    shearY: number;\r\n    transformMode: TransformMode;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface ISlot {\r\n    getAttachment(): IAttachment;\r\n    data: ISlotData;\r\n    color: Color;\r\n    darkColor: Color;\r\n    blendMode: number;\r\n    bone: IBone;\r\n\r\n    sprites?: any;\r\n    currentSprite?: any;\r\n    currentSpriteName?: string;\r\n\r\n    meshes?: any;\r\n    currentMesh?: any;\r\n    currentMeshName?: string;\r\n    currentMeshId?: number;\r\n\r\n    currentGraphics?: any;\r\n    clippingContainer?: any;\r\n\r\n    hackRegion?: TextureRegion;\r\n    hackAttachment?: IAttachment;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface ISkeleton<SkeletonData extends ISkeletonData = ISkeletonData,\r\n                           Bone extends IBone = IBone,\r\n                           Slot extends ISlot = ISlot,\r\n                           Skin extends ISkin = ISkin> {\r\n    bones: Bone[]\r\n    slots: Slot[]\r\n    drawOrder: Slot[]\r\n    skin: Skin;\r\n    data: SkeletonData;\r\n    updateWorldTransform (): void;\r\n    setToSetupPose (): void;\r\n    findSlotIndex (slotName: string): number;\r\n    getAttachmentByName (slotName: string, attachmentName: string): IAttachment;\r\n\r\n    setBonesToSetupPose (): void;\r\n    setSlotsToSetupPose (): void;\r\n    findBone (boneName: string): Bone;\r\n    findSlot (slotName: string): Slot;\r\n    findBoneIndex (boneName: string): number;\r\n    findSlotIndex (slotName: string): number;\r\n    setSkinByName (skinName: string): void;\r\n    setAttachment (slotName: string, attachmentName: string): void;\r\n    getBounds (offset: Vector2, size: Vector2, temp: Array<number>): void;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface ISkeletonParser {\r\n    scale: number;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface ISkeletonData<BoneData extends IBoneData = IBoneData,\r\n                               SlotData extends ISlotData = ISlotData,\r\n                               Skin extends ISkin = ISkin,\r\n                               Animation extends IAnimation = IAnimation,\r\n                               EventData extends IEventData = IEventData,\r\n                               IkConstraintData extends IIkConstraintData = IIkConstraintData,\r\n                               TransformConstraintData extends ITransformConstraintData = ITransformConstraintData,\r\n                               PathConstraintData extends IPathConstraintData = IPathConstraintData> {\r\n    name: string;\r\n    bones: BoneData[];\r\n    slots: SlotData[];\r\n    skins: Skin[];\r\n    defaultSkin: Skin;\r\n    events: EventData[];\r\n    animations: Animation[];\r\n    version: string;\r\n    hash: string;\r\n    width: number;\r\n    height: number;\r\n    ikConstraints: IkConstraintData[];\r\n    transformConstraints: TransformConstraintData[];\r\n    pathConstraints: PathConstraintData[];\r\n\r\n    findBone(boneName: string): BoneData | null;\r\n    findBoneIndex(boneName: string): number;\r\n    findSlot(slotName: string): SlotData | null;\r\n    findSlotIndex (slotName: string): number;\r\n    findSkin (skinName: string): Skin | null;\r\n\r\n    findEvent (eventDataName: string): EventData | null;\r\n    findAnimation (animationName: string): Animation | null;\r\n    findIkConstraint (constraintName: string): IkConstraintData | null;\r\n    findTransformConstraint (constraintName: string): TransformConstraintData | null;\r\n    findPathConstraint (constraintName: string): PathConstraintData | null;\r\n}\r\n","/**\r\n * @public\r\n */\r\nexport class BinaryInput {\r\n    constructor(data: Uint8Array, public strings = new Array<string>(), private index: number = 0, private buffer = new DataView(data.buffer)) {\r\n\r\n    }\r\n\r\n    readByte(): number {\r\n        return this.buffer.getInt8(this.index++);\r\n    }\r\n\r\n    readUnsignedByte(): number {\r\n        return this.buffer.getUint8(this.index++);\r\n    }\r\n\r\n    readShort(): number {\r\n        let value = this.buffer.getInt16(this.index);\r\n        this.index += 2;\r\n        return value;\r\n    }\r\n\r\n    readInt32(): number {\r\n        let value = this.buffer.getInt32(this.index)\r\n        this.index += 4;\r\n        return value;\r\n    }\r\n\r\n    readInt(optimizePositive: boolean) {\r\n        let b = this.readByte();\r\n        let result = b & 0x7F;\r\n        if ((b & 0x80) != 0) {\r\n            b = this.readByte();\r\n            result |= (b & 0x7F) << 7;\r\n            if ((b & 0x80) != 0) {\r\n                b = this.readByte();\r\n                result |= (b & 0x7F) << 14;\r\n                if ((b & 0x80) != 0) {\r\n                    b = this.readByte();\r\n                    result |= (b & 0x7F) << 21;\r\n                    if ((b & 0x80) != 0) {\r\n                        b = this.readByte();\r\n                        result |= (b & 0x7F) << 28;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        return optimizePositive ? result : ((result >>> 1) ^ -(result & 1));\r\n    }\r\n\r\n    readStringRef (): string {\r\n        let index = this.readInt(true);\r\n        return index == 0 ? null : this.strings[index - 1];\r\n    }\r\n\r\n    readString (): string {\r\n        let byteCount = this.readInt(true);\r\n        switch (byteCount) {\r\n            case 0:\r\n                return null;\r\n            case 1:\r\n                return \"\";\r\n        }\r\n        byteCount--;\r\n        let chars = \"\";\r\n        for (let i = 0; i < byteCount;) {\r\n            let b = this.readByte();\r\n            switch (b >> 4) {\r\n                case 12:\r\n                case 13:\r\n                    chars += String.fromCharCode(((b & 0x1F) << 6 | this.readByte() & 0x3F));\r\n                    i += 2;\r\n                    break;\r\n                case 14:\r\n                    chars += String.fromCharCode(((b & 0x0F) << 12 | (this.readByte() & 0x3F) << 6 | this.readByte() & 0x3F));\r\n                    i += 3;\r\n                    break;\r\n                default:\r\n                    chars += String.fromCharCode(b);\r\n                    i++;\r\n            }\r\n        }\r\n        return chars;\r\n    }\r\n\r\n    readFloat (): number {\r\n        let value = this.buffer.getFloat32(this.index);\r\n        this.index += 4;\r\n        return value;\r\n    }\r\n\r\n    readBoolean (): boolean {\r\n        return this.readByte() != 0;\r\n    }\r\n}\r\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from) {\r\n    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)\r\n        to[j] = from[i];\r\n    return to;\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n","\nimport { Texture } from '@pixi/core';\nimport { Rectangle } from '@pixi/math';\n\n/**\n * @public\n */\nexport function filterFromString (text: string): TextureFilter {\n    switch (text.toLowerCase()) {\n        case \"nearest\": return TextureFilter.Nearest;\n        case \"linear\": return TextureFilter.Linear;\n        case \"mipmap\": return TextureFilter.MipMap;\n        case \"mipmapnearestnearest\": return TextureFilter.MipMapNearestNearest;\n        case \"mipmaplinearnearest\": return TextureFilter.MipMapLinearNearest;\n        case \"mipmapnearestlinear\": return TextureFilter.MipMapNearestLinear;\n        case \"mipmaplinearlinear\": return TextureFilter.MipMapLinearLinear;\n        default: throw new Error(`Unknown texture filter ${text}`);\n    }\n}\n\n/**\n * @public\n */\nexport function wrapFromString (text: string): TextureWrap {\n    switch (text.toLowerCase()) {\n        case \"mirroredtepeat\": return TextureWrap.MirroredRepeat;\n        case \"clamptoedge\": return TextureWrap.ClampToEdge;\n        case \"repeat\": return TextureWrap.Repeat;\n        default: throw new Error(`Unknown texture wrap ${text}`);\n    }\n}\n\n/**\n * @public\n */\nexport enum TextureFilter {\n    Nearest = 9728, // WebGLRenderingContext.NEAREST\n    Linear = 9729, // WebGLRenderingContext.LINEAR\n    MipMap = 9987, // WebGLRenderingContext.LINEAR_MIPMAP_LINEAR\n    MipMapNearestNearest = 9984, // WebGLRenderingContext.NEAREST_MIPMAP_NEAREST\n    MipMapLinearNearest = 9985, // WebGLRenderingContext.LINEAR_MIPMAP_NEAREST\n    MipMapNearestLinear = 9986, // WebGLRenderingContext.NEAREST_MIPMAP_LINEAR\n    MipMapLinearLinear = 9987 // WebGLRenderingContext.LINEAR_MIPMAP_LINEAR\n}\n\n/**\n * @public\n */\nexport enum TextureWrap {\n    MirroredRepeat = 33648, // WebGLRenderingContext.MIRRORED_REPEAT\n    ClampToEdge = 33071, // WebGLRenderingContext.CLAMP_TO_EDGE\n    Repeat = 10497 // WebGLRenderingContext.REPEAT\n}\n\n/**\n * @public\n */\nexport class TextureRegion {\n    texture: Texture;\n\n    //thats for overrides\n    size: Rectangle = null;\n\n    names: string[] = null;\n    values: number[][] = null;\n\n    get width(): number {\n        const tex = this.texture;\n        if (tex.trim) {\n            return tex.trim.width;\n        }\n        return tex.orig.width;\n    }\n\n    get height(): number {\n        const tex = this.texture;\n        if (tex.trim) {\n            return tex.trim.height;\n        }\n        return tex.orig.height;\n    }\n\n    get u(): number {\n        return (this.texture as any)._uvs.x0;\n    }\n\n    get v(): number {\n        return (this.texture as any)._uvs.y0;\n    }\n\n    get u2(): number {\n        return (this.texture as any)._uvs.x2;\n    }\n\n    get v2(): number {\n        return (this.texture as any)._uvs.y2;\n    }\n\n    get offsetX(): number {\n        const tex = this.texture;\n        return tex.trim ? tex.trim.x : 0;\n    }\n\n    get offsetY(): number {\n        // console.warn(\"Deprecation Warning: @Hackerham: I guess, if you are using PIXI-SPINE ATLAS region.offsetY, you want a texture, right? Use region.texture from now on.\");\n        return this.spineOffsetY;\n    }\n\n    get pixiOffsetY(): number {\n        const tex = this.texture;\n        return tex.trim ? tex.trim.y : 0;\n    }\n\n    get spineOffsetY(): number {\n        let tex = this.texture;\n        return this.originalHeight - this.height - (tex.trim ? tex.trim.y : 0);\n    }\n\n    get originalWidth(): number {\n        return this.texture.orig.width;\n    }\n\n    get originalHeight(): number {\n        return this.texture.orig.height;\n    }\n\n    get x(): number {\n        return this.texture.frame.x;\n    }\n\n    get y(): number {\n        return this.texture.frame.y;\n    }\n\n    get rotate(): boolean {\n        return this.texture.rotate !== 0;\n    }\n\n    get degrees() {\n        return (360 - this.texture.rotate * 45) % 360;\n    }\n}\n","import {ISkeleton} from \"./ISkeleton\";\n\n\nlet fround_polyfill = (function(array) {\n    return function(x: number) {\n        return array[0] = x, array[0];\n    };\n})(new Float32Array(1));\n\nlet fround: (value: number) => number =\n    (Math as any).fround || fround_polyfill;\n/**\n * @public\n */\nexport interface Map<T> {\n    [key: string]: T;\n}\n\n/**\n * @public\n */\nexport class IntSet {\n    array = new Array<number>();\n\n    add (value: number): boolean {\n        let contains = this.contains(value);\n        this.array[value | 0] = value | 0;\n        return !contains;\n    }\n\n    contains (value: number) {\n        return this.array[value | 0] != undefined;\n    }\n\n    remove (value: number) {\n        this.array[value | 0] = undefined;\n    }\n\n    clear () {\n        this.array.length = 0;\n    }\n}\n\n/**\n * @public\n */\nexport class StringSet {\n    entries: Map<boolean> = {};\n    size = 0;\n\n    add (value: string): boolean {\n        let contains = this.entries[value];\n        this.entries[value] = true;\n        if (!contains) {\n            this.size++;\n            return true;\n        }\n        return false;\n    }\n\n    addAll (values: string[]): boolean {\n        let oldSize = this.size;\n        for (var i = 0, n = values.length; i < n; i++)\n            this.add(values[i]);\n        return oldSize != this.size;\n    }\n\n    contains (value: string) {\n        return this.entries[value];\n    }\n\n    clear () {\n        this.entries = {};\n        this.size = 0;\n    }\n}\n\n/**\n * @public\n */\nexport interface Disposable {\n    dispose (): void;\n}\n\n/**\n * @public\n */\nexport interface Restorable {\n    restore (): void;\n}\n\n/**\n * @public\n */\nexport class Color {\n    public static WHITE = new Color(1, 1, 1, 1);\n    public static RED = new Color(1, 0, 0, 1);\n    public static GREEN = new Color(0, 1, 0, 1);\n    public static BLUE = new Color(0, 0, 1, 1);\n    public static MAGENTA = new Color(1, 0, 1, 1);\n\n    constructor (public r: number = 0, public g: number = 0, public b: number = 0, public a: number = 0) {\n    }\n\n    set (r: number, g: number, b: number, a: number) {\n        this.r = r;\n        this.g = g;\n        this.b = b;\n        this.a = a;\n        return this.clamp();\n    }\n\n    setFromColor (c: Color) {\n        this.r = c.r;\n        this.g = c.g;\n        this.b = c.b;\n        this.a = c.a;\n        return this;\n    }\n\n    setFromString (hex: string) {\n        hex = hex.charAt(0) == '#' ? hex.substr(1) : hex;\n        this.r = parseInt(hex.substr(0, 2), 16) / 255;\n        this.g = parseInt(hex.substr(2, 2), 16) / 255;\n        this.b = parseInt(hex.substr(4, 2), 16) / 255;\n        this.a = hex.length != 8 ? 1 : parseInt(hex.substr(6, 2), 16) / 255;\n        return this;\n    }\n\n    add (r: number, g: number, b: number, a: number) {\n        this.r += r;\n        this.g += g;\n        this.b += b;\n        this.a += a;\n        return this.clamp();\n    }\n\n    clamp () {\n        if (this.r < 0) this.r = 0;\n        else if (this.r > 1) this.r = 1;\n\n        if (this.g < 0) this.g = 0;\n        else if (this.g > 1) this.g = 1;\n\n        if (this.b < 0) this.b = 0;\n        else if (this.b > 1) this.b = 1;\n\n        if (this.a < 0) this.a = 0;\n        else if (this.a > 1) this.a = 1;\n        return this;\n    }\n\n    static rgba8888ToColor(color: Color, value: number) {\n        color.r = ((value & 0xff000000) >>> 24) / 255;\n        color.g = ((value & 0x00ff0000) >>> 16) / 255;\n        color.b = ((value & 0x0000ff00) >>> 8) / 255;\n        color.a = ((value & 0x000000ff)) / 255;\n    }\n\n    static rgb888ToColor (color: Color, value: number) {\n        color.r = ((value & 0x00ff0000) >>> 16) / 255;\n        color.g = ((value & 0x0000ff00) >>> 8) / 255;\n        color.b = ((value & 0x000000ff)) / 255;\n    }\n\n    static fromString (hex : string) : Color {\n        return new Color().setFromString(hex);\n    }\n}\n\n/**\n * @public\n */\nexport class MathUtils {\n    static PI = 3.1415927;\n    static PI2 = MathUtils.PI * 2;\n    static radiansToDegrees = 180 / MathUtils.PI;\n    static radDeg = MathUtils.radiansToDegrees;\n    static degreesToRadians = MathUtils.PI / 180;\n    static degRad = MathUtils.degreesToRadians;\n\n    static clamp (value: number, min: number, max: number) {\n        if (value < min) return min;\n        if (value > max) return max;\n        return value;\n    }\n\n    static cosDeg (degrees: number) {\n        return Math.cos(degrees * MathUtils.degRad);\n    }\n\n    static sinDeg (degrees: number) {\n        return Math.sin(degrees * MathUtils.degRad);\n    }\n\n    static signum (value: number): number {\n        return value > 0 ? 1 : value < 0 ? -1 : 0;\n    }\n\n    static toInt (x: number) {\n        return x > 0 ? Math.floor(x) : Math.ceil(x);\n    }\n\n    static cbrt (x: number) {\n        let y = Math.pow(Math.abs(x), 1/3);\n        return x < 0 ? -y : y;\n    }\n\n    static randomTriangular (min: number, max: number): number {\n        return MathUtils.randomTriangularWith(min, max, (min + max) * 0.5);\n    }\n\n    static randomTriangularWith (min: number, max: number, mode: number): number {\n        let u = Math.random();\n        let d = max - min;\n        if (u <= (mode - min) / d) return min + Math.sqrt(u * d * (mode - min));\n        return max - Math.sqrt((1 - u) * d * (max - mode));\n    }\n}\n\n/**\n * @public\n */\nexport abstract class Interpolation {\n    protected abstract applyInternal (a: number): number;\n    apply(start: number, end: number, a: number): number {\n        return start + (end - start) * this.applyInternal(a);\n    }\n}\n\n/**\n * @public\n */\nexport class Pow extends Interpolation {\n    protected power = 2;\n\n    constructor (power: number) {\n        super();\n        this.power = power;\n    }\n\n    applyInternal (a: number): number {\n        if (a <= 0.5) return Math.pow(a * 2, this.power) / 2;\n        return Math.pow((a - 1) * 2, this.power) / (this.power % 2 == 0 ? -2 : 2) + 1;\n    }\n}\n\n/**\n * @public\n */\nexport class PowOut extends Pow {\n    constructor (power: number) {\n        super(power);\n    }\n\n    applyInternal (a: number) : number {\n        return Math.pow(a - 1, this.power) * (this.power % 2 == 0 ? -1 : 1) + 1;\n    }\n}\n\n/**\n * @public\n */\nexport class Utils {\n    static SUPPORTS_TYPED_ARRAYS = typeof(Float32Array) !== \"undefined\";\n\n    static arrayCopy<T> (source: ArrayLike<T>, sourceStart: number, dest: ArrayLike<T>, destStart: number, numElements: number) {\n        for (let i = sourceStart, j = destStart; i < sourceStart + numElements; i++, j++) {\n            dest[j] = source[i];\n        }\n    }\n\n    static arrayFill<T> (array: ArrayLike<T>, fromIndex: number, toIndex: number, value: T) {\n        for (let i = fromIndex; i < toIndex; i++)\n            array[i] = value;\n    }\n\n    static setArraySize<T> (array: Array<T>, size: number, value: any = 0): Array<T> {\n        let oldSize = array.length;\n        if (oldSize == size) return array;\n        array.length = size;\n        if (oldSize < size) {\n            for (let i = oldSize; i < size; i++) array[i] = value;\n        }\n        return array;\n    }\n\n    static ensureArrayCapacity<T> (array: Array<T>, size: number, value: any = 0): Array<T> {\n        if (array.length >= size) return array;\n        return Utils.setArraySize(array, size, value);\n    }\n\n    static newArray<T> (size: number, defaultValue: T): Array<T> {\n        let array = new Array<T>(size);\n        for (let i = 0; i < size; i++) array[i] = defaultValue;\n        return array;\n    }\n\n    static newFloatArray (size: number): ArrayLike<number> {\n        if (Utils.SUPPORTS_TYPED_ARRAYS)\n            return new Float32Array(size)\n        else {\n            let array = new Array<number>(size);\n            for (let i = 0; i < array.length; i++) array[i] = 0;\n            return array;\n        }\n    }\n\n    static newShortArray (size: number): ArrayLike<number> {\n        if (Utils.SUPPORTS_TYPED_ARRAYS)\n            return new Int16Array(size)\n        else {\n            let array = new Array<number>(size);\n            for (let i = 0; i < array.length; i++) array[i] = 0;\n            return array;\n        }\n    }\n\n    static toFloatArray (array: Array<number>) {\n        return Utils.SUPPORTS_TYPED_ARRAYS ? new Float32Array(array) : array;\n    }\n\n    static toSinglePrecision (value: number) {\n        return Utils.SUPPORTS_TYPED_ARRAYS ? fround(value) : value;\n    }\n\n    // This function is used to fix WebKit 602 specific issue described at http://esotericsoftware.com/forum/iOS-10-disappearing-graphics-10109\n    static webkit602BugfixHelper (alpha: number, blend: any) {\n\n    }\n\n    static contains<T> (array: Array<T>, element: T, identity = true) {\n        for (let i = 0; i < array.length; i++)\n            if (array[i] == element) return true;\n        return false;\n    }\n\n    static enumValue (type: any, name: string) {\n        return type[name[0].toUpperCase() + name.slice(1)];\n    }\n}\n\n/**\n * @public\n */\nexport class DebugUtils {\n    static logBones(skeleton: ISkeleton) {\n        for (let i = 0; i < skeleton.bones.length; i++) {\n            let bone = skeleton.bones[i];\n            let mat = bone.matrix;\n            console.log(bone.data.name + \", \" + mat.a + \", \" + mat.b + \", \" + mat.c + \", \" + mat.d + \", \" + mat.tx + \", \" + mat.ty);\n        }\n    }\n}\n\n/**\n * @public\n */\nexport class Pool<T> {\n    private items = new Array<T>();\n    private instantiator: () => T;\n\n    constructor (instantiator: () => T) {\n        this.instantiator = instantiator;\n    }\n\n    obtain () {\n        return this.items.length > 0 ? this.items.pop() : this.instantiator();\n    }\n\n    free (item: T) {\n        if ((item as any).reset) (item as any).reset();\n        this.items.push(item);\n    }\n\n    freeAll (items: ArrayLike<T>) {\n        for (let i = 0; i < items.length; i++)\n            this.free(items[i]);\n    }\n\n    clear () {\n        this.items.length = 0;\n    }\n}\n\n/**\n * @public\n */\nexport class Vector2 {\n    constructor (public x = 0, public y = 0) {\n    }\n\n    set (x: number, y: number): Vector2 {\n        this.x = x;\n        this.y = y;\n        return this;\n    }\n\n    length () {\n        let x = this.x;\n        let y = this.y;\n        return Math.sqrt(x * x + y * y);\n    }\n\n    normalize () {\n        let len = this.length();\n        if (len != 0) {\n            this.x /= len;\n            this.y /= len;\n        }\n        return this;\n    }\n}\n\n/**\n * @public\n */\nexport class TimeKeeper {\n    maxDelta = 0.064;\n    framesPerSecond = 0;\n    delta = 0;\n    totalTime = 0;\n\n    private lastTime = Date.now() / 1000;\n    private frameCount = 0;\n    private frameTime = 0;\n\n    update () {\n        let now = Date.now() / 1000;\n        this.delta = now - this.lastTime;\n        this.frameTime += this.delta;\n        this.totalTime += this.delta;\n        if (this.delta > this.maxDelta) this.delta = this.maxDelta;\n        this.lastTime = now;\n\n        this.frameCount++;\n        if (this.frameTime > 1) {\n            this.framesPerSecond = this.frameCount / this.frameTime;\n            this.frameTime = 0;\n            this.frameCount = 0;\n        }\n    }\n}\n\n/**\n * @public\n */\nexport interface ArrayLike<T> {\n    length: number;\n    [n: number]: T;\n}\n\n/**\n * @public\n */\nexport class WindowedMean {\n    values: Array<number>;\n    addedValues = 0;\n    lastValue = 0;\n    mean = 0;\n    dirty = true;\n\n    constructor (windowSize: number = 32) {\n        this.values = new Array<number>(windowSize);\n    }\n\n    hasEnoughData () {\n        return this.addedValues >= this.values.length;\n    }\n\n    addValue (value: number) {\n        if (this.addedValues < this.values.length) this.addedValues++;\n        this.values[this.lastValue++] = value;\n        if (this.lastValue > this.values.length - 1) this.lastValue = 0;\n        this.dirty = true;\n    }\n\n    getMean () {\n        if (this.hasEnoughData()) {\n            if (this.dirty) {\n                let mean = 0;\n                for (let i = 0; i < this.values.length; i++)\n                    mean += this.values[i];\n                this.mean = mean / this.values.length;\n                this.dirty = false;\n            }\n            return this.mean;\n        }\n        return 0;\n    }\n}\n","import {SCALE_MODES, MIPMAP_MODES, ALPHA_MODES} from '@pixi/constants';\r\nimport {Texture} from '@pixi/core';\r\nimport {Rectangle} from '@pixi/math';\r\nimport {TextureRegion, TextureWrap, TextureFilter, filterFromString} from './TextureRegion';\r\nimport {Map, Disposable} from './Utils';\r\n\r\nimport type {BaseTexture} from '@pixi/core';\r\n\r\nclass RegionFields {\r\n    x = 0;\r\n    y = 0;\r\n    width = 0;\r\n    height = 0;\r\n    offsetX = 0;\r\n    offsetY = 0;\r\n    originalWidth = 0;\r\n    originalHeight = 0;\r\n    rotate = 0;\r\n    index = 0;\r\n}\r\n/**\r\n * @public\r\n */\r\nexport class TextureAtlas implements Disposable {\r\n    pages = new Array<TextureAtlasPage>();\r\n    regions = new Array<TextureAtlasRegion>();\r\n\r\n    constructor(atlasText?: string, textureLoader?: (path: string, loaderFunction: (tex: BaseTexture) => any) => any, callback?: (obj: TextureAtlas) => any) {\r\n        if (atlasText) {\r\n            this.addSpineAtlas(atlasText, textureLoader, callback);\r\n        }\r\n    }\r\n\r\n    addTexture(name: string, texture: Texture) {\r\n        let pages = this.pages;\r\n        let page: TextureAtlasPage = null;\r\n        for (let i = 0; i < pages.length; i++) {\r\n            if (pages[i].baseTexture === texture.baseTexture) {\r\n                page = pages[i];\r\n                break;\r\n            }\r\n        }\r\n        if (page === null) {\r\n            page = new TextureAtlasPage();\r\n            page.name = 'texturePage';\r\n            let baseTexture = texture.baseTexture;\r\n            page.width = baseTexture.realWidth;\r\n            page.height = baseTexture.realHeight;\r\n            page.baseTexture = baseTexture;\r\n            //those fields are not relevant in Pixi\r\n            page.minFilter = page.magFilter = TextureFilter.Nearest;\r\n            page.uWrap = TextureWrap.ClampToEdge;\r\n            page.vWrap = TextureWrap.ClampToEdge;\r\n            pages.push(page);\r\n        }\r\n        let region = new TextureAtlasRegion();\r\n        region.name = name;\r\n        region.page = page;\r\n        region.texture = texture;\r\n        region.index = -1;\r\n        this.regions.push(region);\r\n        return region;\r\n    }\r\n\r\n    addTextureHash(textures: Map<Texture>, stripExtension: boolean) {\r\n        for (let key in textures) {\r\n            if (textures.hasOwnProperty(key)) {\r\n                this.addTexture(stripExtension && key.indexOf('.') !== -1 ? key.substr(0, key.lastIndexOf('.')) : key, textures[key]);\r\n            }\r\n        }\r\n    }\r\n\r\n    public addSpineAtlas(atlasText: string, textureLoader: (path: string, loaderFunction: (tex: BaseTexture) => any) => any, callback: (obj: TextureAtlas) => any) {\r\n        return this.load(atlasText, textureLoader, callback);\r\n    }\r\n\r\n    private load(atlasText: string, textureLoader: (path: string, loaderFunction: (tex: BaseTexture) => any) => any, callback: (obj: TextureAtlas) => any) {\r\n        if (textureLoader == null)\r\n            throw new Error(\"textureLoader cannot be null.\");\r\n\r\n        let reader = new TextureAtlasReader(atlasText);\r\n        let entry = new Array<string>(4);\r\n        let page: TextureAtlasPage = null;\r\n        let pageFields: Map<Function> = {};\r\n        let region: RegionFields = null;\r\n        pageFields[\"size\"] = () => {\r\n            page.width = parseInt(entry[1]);\r\n            page.height = parseInt(entry[2]);\r\n        };\r\n        pageFields[\"format\"] = () => {\r\n            // page.format = Format[tuple[0]]; we don't need format in WebGL\r\n        };\r\n        pageFields[\"filter\"] = () => {\r\n            page.minFilter = filterFromString(entry[1]);\r\n            page.magFilter = filterFromString(entry[2]);\r\n        };\r\n        pageFields[\"repeat\"] = () => {\r\n            if (entry[1].indexOf('x') != -1) page.uWrap = TextureWrap.Repeat;\r\n            if (entry[1].indexOf('y') != -1) page.vWrap = TextureWrap.Repeat;\r\n        };\r\n        pageFields[\"pma\"] = () => {\r\n            page.pma = entry[1] == \"true\";\r\n        };\r\n\r\n        let regionFields: Map<Function> = {};\r\n        regionFields[\"xy\"] = () => { // Deprecated, use bounds.\r\n            region.x = parseInt(entry[1]);\r\n            region.y = parseInt(entry[2]);\r\n        };\r\n        regionFields[\"size\"] = () => { // Deprecated, use bounds.\r\n            region.width = parseInt(entry[1]);\r\n            region.height = parseInt(entry[2]);\r\n        };\r\n        regionFields[\"bounds\"] = () => {\r\n            region.x = parseInt(entry[1]);\r\n            region.y = parseInt(entry[2]);\r\n            region.width = parseInt(entry[3]);\r\n            region.height = parseInt(entry[4]);\r\n        };\r\n        regionFields[\"offset\"] = () => { // Deprecated, use offsets.\r\n            region.offsetX = parseInt(entry[1]);\r\n            region.offsetY = parseInt(entry[2]);\r\n        };\r\n        regionFields[\"orig\"] = () => { // Deprecated, use offsets.\r\n            region.originalWidth = parseInt(entry[1]);\r\n            region.originalHeight = parseInt(entry[2]);\r\n        };\r\n        regionFields[\"offsets\"] = () => {\r\n            region.offsetX = parseInt(entry[1]);\r\n            region.offsetY = parseInt(entry[2]);\r\n            region.originalWidth = parseInt(entry[3]);\r\n            region.originalHeight = parseInt(entry[4]);\r\n        };\r\n        regionFields[\"rotate\"] = () => {\r\n            let rotateValue = entry[1];\r\n            let rotate = 0;\r\n            if (rotateValue.toLocaleLowerCase() == \"true\") {\r\n                rotate = 6;\r\n            } else if (rotateValue.toLocaleLowerCase() == \"false\") {\r\n                rotate = 0;\r\n            } else {\r\n                rotate = ((720 - parseFloat(rotateValue)) % 360) / 45;\r\n            }\r\n            region.rotate = rotate;\r\n        };\r\n        regionFields[\"index\"] = () => {\r\n            region.index = parseInt(entry[1]);\r\n        };\r\n\r\n        let line = reader.readLine();\r\n        // Ignore empty lines before first entry.\r\n        while (line != null && line.trim().length == 0)\r\n            line = reader.readLine();\r\n        // Header entries.\r\n        while (true) {\r\n            if (line == null || line.trim().length == 0) break;\r\n            if (reader.readEntry(entry, line) == 0) break; // Silently ignore all header fields.\r\n            line = reader.readLine();\r\n        }\r\n\r\n        let iterateParser = () => {\r\n            while (true) {\r\n                if (line == null) {\r\n                    return callback && callback(this);\r\n                }\r\n                if (line.trim().length == 0) {\r\n                    page = null;\r\n                    line = reader.readLine();\r\n                } else if (page === null) {\r\n                    page = new TextureAtlasPage();\r\n                    page.name = line.trim();\r\n\r\n                    while (true) {\r\n                        if (reader.readEntry(entry, line = reader.readLine()) == 0) break;\r\n                        let field: Function = pageFields[entry[0]];\r\n                        if (field) field();\r\n                    }\r\n                    this.pages.push(page);\r\n\r\n                    textureLoader(page.name, (texture: BaseTexture) => {\r\n                        if (texture === null) {\r\n                            this.pages.splice(this.pages.indexOf(page), 1);\r\n                            return callback && callback(null);\r\n                        }\r\n                        page.baseTexture = texture;\r\n                        //TODO: set scaleMode and mipmapMode from spine\r\n                        if (page.pma) {\r\n                            texture.alphaMode = ALPHA_MODES.PMA;\r\n                        }\r\n                        if (!texture.valid) {\r\n                            texture.setSize(page.width, page.height);\r\n                        }\r\n                        this.pages.push(page);\r\n                        page.setFilters();\r\n\r\n                        if (!page.width || !page.height) {\r\n                            page.width = texture.realWidth;\r\n                            page.height = texture.realHeight;\r\n                            if (!page.width || !page.height) {\r\n                                console.log(\"ERROR spine atlas page \" + page.name + \": meshes wont work if you dont specify size in atlas (http://www.html5gamedevs.com/topic/18888-pixi-spines-and-meshes/?p=107121)\");\r\n                            }\r\n                        }\r\n                        iterateParser();\r\n                    });\r\n                    this.pages.push(page);\r\n                    break;\r\n                } else {\r\n                    region = new RegionFields();\r\n                    let atlasRegion = new TextureAtlasRegion();\r\n                    atlasRegion.name = line;\r\n                    atlasRegion.page = page;\r\n                    let names: string[] = null;\r\n                    let values: number[][] = null;\r\n                    while (true) {\r\n                        let count = reader.readEntry(entry, line = reader.readLine());\r\n                        if (count == 0) break;\r\n                        let field: Function = regionFields[entry[0]];\r\n                        if (field)\r\n                            field();\r\n                        else {\r\n                            if (names == null) {\r\n                                names = [];\r\n                                values = []\r\n                            }\r\n                            names.push(entry[0]);\r\n                            let entryValues: number[] = [];\r\n                            for (let i = 0; i < count; i++)\r\n                                entryValues.push(parseInt(entry[i + 1]));\r\n                            values.push(entryValues);\r\n                        }\r\n                    }\r\n                    if (region.originalWidth == 0 && region.originalHeight == 0) {\r\n                        region.originalWidth = region.width;\r\n                        region.originalHeight = region.height;\r\n                    }\r\n\r\n                    let resolution = page.baseTexture.resolution;\r\n                    region.x /= resolution;\r\n                    region.y /= resolution;\r\n                    region.width /= resolution;\r\n                    region.height /= resolution;\r\n                    region.originalWidth /= resolution;\r\n                    region.originalHeight /= resolution;\r\n                    region.offsetX /= resolution;\r\n                    region.offsetY /= resolution;\r\n\r\n                    const swapWH = region.rotate % 4 !== 0;\r\n                    let frame = new Rectangle(region.x, region.y, swapWH ? region.height : region.width, swapWH ? region.width : region.height);\r\n\r\n                    let orig = new Rectangle(0, 0, region.originalWidth, region.originalHeight);\r\n                    let trim = new Rectangle(region.offsetX, region.originalHeight - region.height - region.offsetY, region.width, region.height);\r\n\r\n                    atlasRegion.texture = new Texture(atlasRegion.page.baseTexture, frame, orig, trim, region.rotate);\r\n                    atlasRegion.index = region.index;\r\n                    atlasRegion.texture.updateUvs();\r\n\r\n                    this.regions.push(atlasRegion);\r\n                }\r\n            }\r\n        };\r\n\r\n        iterateParser();\r\n    }\r\n\r\n    findRegion(name: string): TextureAtlasRegion {\r\n        for (let i = 0; i < this.regions.length; i++) {\r\n            if (this.regions[i].name == name) {\r\n                return this.regions[i];\r\n            }\r\n        }\r\n        return null;\r\n    }\r\n\r\n    dispose() {\r\n        for (let i = 0; i < this.pages.length; i++) {\r\n            this.pages[i].baseTexture.dispose();\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nclass TextureAtlasReader {\r\n    lines: Array<string>;\r\n    index: number = 0;\r\n\r\n    constructor(text: string) {\r\n        this.lines = text.split(/\\r\\n|\\r|\\n/);\r\n    }\r\n\r\n    readLine(): string {\r\n        if (this.index >= this.lines.length)\r\n            return null;\r\n        return this.lines[this.index++];\r\n    }\r\n\r\n    readEntry (entry: string[], line: string): number {\r\n        if (line == null) return 0;\r\n        line = line.trim();\r\n        if (line.length == 0) return 0;\r\n\r\n        let colon = line.indexOf(':');\r\n        if (colon == -1) return 0;\r\n        entry[0] = line.substr(0, colon).trim();\r\n        for (let i = 1, lastMatch = colon + 1;; i++) {\r\n            let comma = line.indexOf(',', lastMatch);\r\n            if (comma == -1) {\r\n                entry[i] = line.substr(lastMatch).trim();\r\n                return i;\r\n            }\r\n            entry[i] = line.substr(lastMatch, comma - lastMatch).trim();\r\n            lastMatch = comma + 1;\r\n            if (i == 4) return 4;\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport class TextureAtlasPage {\r\n    name: string;\r\n    minFilter: TextureFilter = TextureFilter.Nearest;\r\n    magFilter: TextureFilter = TextureFilter.Nearest;\r\n    uWrap: TextureWrap = TextureWrap.ClampToEdge;\r\n    vWrap: TextureWrap = TextureWrap.ClampToEdge;\r\n    baseTexture: BaseTexture;\r\n    width: number;\r\n    height: number;\r\n    pma: boolean;\r\n\r\n    public setFilters() {\r\n        let tex = this.baseTexture;\r\n        let filter = this.minFilter;\r\n        if (filter == TextureFilter.Linear) {\r\n            tex.scaleMode = SCALE_MODES.LINEAR;\r\n        } else if (this.minFilter == TextureFilter.Nearest) {\r\n            tex.scaleMode = SCALE_MODES.NEAREST;\r\n        } else {\r\n            tex.mipmap = MIPMAP_MODES.POW2;\r\n            if (filter == TextureFilter.MipMapNearestNearest) {\r\n                tex.scaleMode = SCALE_MODES.NEAREST;\r\n            } else {\r\n                tex.scaleMode = SCALE_MODES.LINEAR;\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport class TextureAtlasRegion extends TextureRegion {\r\n    page: TextureAtlasPage;\r\n    name: string;\r\n    index: number;\r\n}\r\n","/**\r\n * @public\r\n */\r\nexport let settings = {\r\n    yDown: true,\r\n    /**\r\n     * pixi-spine gives option to not fail at certain parsing errors\r\n     * spine-ts fails here\r\n     */\r\n    FAIL_ON_NON_EXISTING_SKIN: false,\r\n\r\n    /**\r\n     * past Spine.globalAutoUpdate\r\n     */\r\n    GLOBAL_AUTO_UPDATE: true,\r\n\r\n    /**\r\n     * past Spine.globalDelayLimit\r\n     */\r\n    GLOBAL_DELAY_LIMIT: 0,\r\n}\r\n","import {AttachmentType} from './core/AttachmentType';\r\nimport {TextureRegion} from './core/TextureRegion';\r\nimport {TextureAtlasRegion} from './core/TextureAtlas';\r\nimport {MathUtils} from './core/Utils';\r\nimport type {\r\n    IAnimationState,\r\n    IAnimationStateData\r\n} from './core/IAnimation';\r\nimport type {\r\n    IAttachment, IClippingAttachment, IMeshAttachment,\r\n    IRegionAttachment,\r\n    ISkeleton,\r\n    ISkeletonData,\r\n    ISlot,\r\n    IVertexAttachment\r\n} from './core/ISkeleton';\r\n\r\nimport {DRAW_MODES} from '@pixi/constants';\r\nimport {Container, DisplayObject} from '@pixi/display';\r\nimport {Sprite} from '@pixi/sprite';\r\nimport {SimpleMesh} from '@pixi/mesh-extras';\r\nimport {Graphics} from '@pixi/graphics'\r\nimport {Rectangle, Polygon, Transform} from '@pixi/math';\r\nimport {hex2rgb, rgb2hex} from '@pixi/utils';\r\nimport type {Texture} from '@pixi/core';\r\nimport {settings} from \"./settings\";\r\n\r\nlet tempRgb = [0, 0, 0];\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface ISpineDisplayObject extends DisplayObject {\r\n    region?: TextureRegion;\r\n    attachment?: IAttachment;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport class SpineSprite extends Sprite implements ISpineDisplayObject {\r\n    region?: TextureRegion = null;\r\n    attachment?: IAttachment = null;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport class SpineMesh extends SimpleMesh implements ISpineDisplayObject {\r\n    region?: TextureRegion = null;\r\n    attachment?: IAttachment = null;\r\n\r\n    constructor(texture: Texture, vertices?: Float32Array, uvs?: Float32Array, indices?: Uint16Array, drawMode?: number) {\r\n        super(texture, vertices, uvs, indices, drawMode);\r\n    }\r\n}\r\n\r\n/**\r\n * A class that enables the you to import and run your spine animations in pixi.\r\n * The Spine animation data needs to be loaded using either the Loader or a SpineLoader before it can be used by this class\r\n * See example 12 (http://www.goodboydigital.com/pixijs/examples/12/) to see a working example and check out the source\r\n *\r\n * ```js\r\n * let spineAnimation = new spine(spineData);\r\n * ```\r\n *\r\n * @public\r\n * @class\r\n * @extends Container\r\n * @memberof spine\r\n * @param spineData {object} The spine data loaded from a spine atlas.\r\n */\r\nexport abstract class SpineBase<Skeleton extends ISkeleton,\r\n    SkeletonData extends ISkeletonData,\r\n    AnimationState extends IAnimationState,\r\n    AnimationStateData extends IAnimationStateData>\r\n    extends Container implements GlobalMixins.Spine {\r\n\r\n    tintRgb: ArrayLike<number>;\r\n    spineData: SkeletonData;\r\n    skeleton: Skeleton;\r\n    stateData: AnimationStateData;\r\n    state: AnimationState;\r\n    slotContainers: Array<Container>;\r\n    tempClipContainers: Array<Container>;\r\n    localDelayLimit: number;\r\n    private _autoUpdate: boolean;\r\n    protected _visible: boolean;\r\n\r\n    abstract createSkeleton(spineData: ISkeletonData);\r\n\r\n    constructor(spineData: SkeletonData) {\r\n        super();\r\n\r\n        if (!spineData) {\r\n            throw new Error('The spineData param is required.');\r\n        }\r\n\r\n        if ((typeof spineData) === \"string\") {\r\n            throw new Error('spineData param cant be string. Please use spine.Spine.fromAtlas(\"YOUR_RESOURCE_NAME\") from now on.');\r\n        }\r\n\r\n        /**\r\n         * The spineData object\r\n         *\r\n         * @member {object}\r\n         */\r\n        this.spineData = spineData;\r\n\r\n        /**\r\n         * A spine Skeleton object\r\n         *\r\n         * @member {object}\r\n         */\r\n        this.createSkeleton(spineData);\r\n\r\n        /**\r\n         * An array of containers\r\n         *\r\n         * @member {Container[]}\r\n         */\r\n        this.slotContainers = [];\r\n\r\n        this.tempClipContainers = [];\r\n\r\n        for (let i = 0, n = this.skeleton.slots.length; i < n; i++) {\r\n            let slot = this.skeleton.slots[i];\r\n            let attachment: any = slot.getAttachment();\r\n            let slotContainer = this.newContainer();\r\n            this.slotContainers.push(slotContainer);\r\n            this.addChild(slotContainer);\r\n            this.tempClipContainers.push(null);\r\n\r\n            if (!attachment) {\r\n                continue;\r\n            }\r\n            if (attachment.type === AttachmentType.Region) {\r\n                let spriteName = (attachment.region as TextureAtlasRegion).name;\r\n                let sprite = this.createSprite(slot, attachment as IRegionAttachment, spriteName);\r\n                slot.currentSprite = sprite;\r\n                slot.currentSpriteName = spriteName;\r\n                slotContainer.addChild(sprite);\r\n            } else if (attachment.type === AttachmentType.Mesh) {\r\n                let mesh = this.createMesh(slot, attachment);\r\n                slot.currentMesh = mesh;\r\n                slot.currentMeshId = attachment.id;\r\n                slot.currentMeshName = attachment.name;\r\n                slotContainer.addChild(mesh);\r\n            } else if (attachment.type === AttachmentType.Clipping) {\r\n                this.createGraphics(slot, attachment);\r\n                slotContainer.addChild(slot.clippingContainer);\r\n                slotContainer.addChild(slot.currentGraphics);\r\n            }\r\n        }\r\n\r\n        /**\r\n         * The tint applied to all spine slots. This is a [r,g,b] value. A value of [1,1,1] will remove any tint effect.\r\n         *\r\n         * @member {number}\r\n         * @memberof spine.Spine#\r\n         */\r\n        this.tintRgb = new Float32Array([1, 1, 1]);\r\n\r\n        this.autoUpdate = true;\r\n        this.visible = true;\r\n    }\r\n\r\n    /**\r\n     * If this flag is set to true, the spine animation will be automatically updated every\r\n     * time the object id drawn. The down side of this approach is that the delta time is\r\n     * automatically calculated and you could miss out on cool effects like slow motion,\r\n     * pause, skip ahead and the sorts. Most of these effects can be achieved even with\r\n     * autoUpdate enabled but are harder to achieve.\r\n     *\r\n     * @member {boolean}\r\n     * @memberof spine.Spine#\r\n     * @default true\r\n     */\r\n    get autoUpdate(): boolean {\r\n        return this._autoUpdate;\r\n    }\r\n\r\n    set autoUpdate(value: boolean) {\r\n        if (value !== this._autoUpdate) {\r\n            this._autoUpdate = value;\r\n            this.updateTransform = value ? SpineBase.prototype.autoUpdateTransform : Container.prototype.updateTransform;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * The tint applied to the spine object. This is a hex value. A value of 0xFFFFFF will remove any tint effect.\r\n     *\r\n     * @member {number}\r\n     * @memberof spine.Spine#\r\n     * @default 0xFFFFFF\r\n     */\r\n    get tint(): number {\r\n        return rgb2hex(this.tintRgb as any);\r\n    }\r\n\r\n    set tint(value: number) {\r\n        this.tintRgb = hex2rgb(value, this.tintRgb as any);\r\n    }\r\n\r\n    /**\r\n     * Limit value for the update dt with Spine.globalDelayLimit\r\n     * that can be overridden with localDelayLimit\r\n     * @return {number} - Maximum processed dt value for the update\r\n     */\r\n    get delayLimit(): number {\r\n        let limit = typeof this.localDelayLimit !== \"undefined\" ?\r\n            this.localDelayLimit : settings.GLOBAL_DELAY_LIMIT;\r\n\r\n        // If limit is 0, this means there is no limit for the delay\r\n        return limit || Number.MAX_VALUE\r\n    }\r\n\r\n    /**\r\n     * Update the spine skeleton and its animations by delta time (dt)\r\n     *\r\n     * @param dt {number} Delta time. Time by which the animation should be updated\r\n     */\r\n    update(dt: number) {\r\n        // Limit delta value to avoid animation jumps\r\n        let delayLimit = this.delayLimit;\r\n        if (dt > delayLimit) dt = delayLimit;\r\n\r\n        this.state.update(dt);\r\n        this.state.apply(this.skeleton);\r\n\r\n        //check we haven't been destroyed via a spine event callback in state update\r\n        if (!this.skeleton)\r\n            return;\r\n\r\n        this.skeleton.updateWorldTransform();\r\n\r\n        let slots = this.skeleton.slots;\r\n\r\n        // in case pixi has double tint\r\n        let globalClr = (this as any).color;\r\n        let light: ArrayLike<number> = null, dark: ArrayLike<number> = null;\r\n\r\n        if (globalClr) {\r\n            light = globalClr.light;\r\n            dark = globalClr.dark;\r\n        } else {\r\n            light = this.tintRgb;\r\n        }\r\n\r\n        // let thack = false;\r\n\r\n        for (let i = 0, n = slots.length; i < n; i++) {\r\n            let slot = slots[i];\r\n            let attachment = slot.getAttachment();\r\n            let slotContainer = this.slotContainers[i];\r\n\r\n            if (!attachment) {\r\n                slotContainer.visible = false;\r\n                continue;\r\n            }\r\n\r\n            let spriteColor: any = null;\r\n\r\n            let attColor = (attachment as any).color;\r\n            switch (attachment.type) {\r\n                case AttachmentType.Region:\r\n                    let region = (attachment as IRegionAttachment).region;\r\n                    if (region) {\r\n                        if (slot.currentMesh) {\r\n                            slot.currentMesh.visible = false;\r\n                            slot.currentMesh = null;\r\n                            slot.currentMeshId = undefined;\r\n                            slot.currentMeshName = undefined;\r\n                        }\r\n                        let ar = region as TextureAtlasRegion;\r\n                        if (!slot.currentSpriteName || slot.currentSpriteName !== ar.name) {\r\n                            let spriteName = ar.name;\r\n                            if (slot.currentSprite) {\r\n                                slot.currentSprite.visible = false;\r\n                            }\r\n                            slot.sprites = slot.sprites || {};\r\n                            if (slot.sprites[spriteName] !== undefined) {\r\n                                slot.sprites[spriteName].visible = true;\r\n                            } else {\r\n                                let sprite = this.createSprite(slot, attachment as IRegionAttachment, spriteName);\r\n                                slotContainer.addChild(sprite);\r\n                            }\r\n                            slot.currentSprite = slot.sprites[spriteName];\r\n                            slot.currentSpriteName = spriteName;\r\n\r\n                            // force sprite update when attachment name is same.\r\n                            // issues https://github.com/pixijs/pixi-spine/issues/318\r\n                        } else if (slot.currentSpriteName === ar.name && !slot.hackRegion) {\r\n                            this.setSpriteRegion(attachment as IRegionAttachment, slot.currentSprite, region);\r\n                        }\r\n                    }\r\n\r\n                    let transform = slotContainer.transform;\r\n                    transform.setFromMatrix(slot.bone.matrix);\r\n\r\n                    if (slot.currentSprite.color) {\r\n                        //YAY! double - tint!\r\n                        spriteColor = slot.currentSprite.color;\r\n                    } else {\r\n                        tempRgb[0] = light[0] * slot.color.r * attColor.r;\r\n                        tempRgb[1] = light[1] * slot.color.g * attColor.g;\r\n                        tempRgb[2] = light[2] * slot.color.b * attColor.b;\r\n                        slot.currentSprite.tint = rgb2hex(tempRgb);\r\n                    }\r\n                    slot.currentSprite.blendMode = slot.blendMode;\r\n                    break;\r\n\r\n                case AttachmentType.Mesh:\r\n                    if (slot.currentSprite) {\r\n                        //TODO: refactor this thing, switch it on and off for container\r\n                        slot.currentSprite.visible = false;\r\n                        slot.currentSprite = null;\r\n                        slot.currentSpriteName = undefined;\r\n\r\n                        //TODO: refactor this shit\r\n                        const transform = new Transform();\r\n                        (transform as any)._parentID = -1;\r\n                        (transform as any)._worldID = (slotContainer.transform as any)._worldID;\r\n                        slotContainer.transform = transform;\r\n                    }\r\n                    const id = (attachment as IVertexAttachment).id;\r\n                    if (!slot.currentMeshId || slot.currentMeshId !== id) {\r\n                        let meshId = id;\r\n                        if (slot.currentMesh) {\r\n                            slot.currentMesh.visible = false;\r\n                        }\r\n\r\n                        slot.meshes = slot.meshes || {};\r\n\r\n                        if (slot.meshes[meshId] !== undefined) {\r\n                            slot.meshes[meshId].visible = true;\r\n                        } else {\r\n                            let mesh = this.createMesh(slot, attachment as IMeshAttachment);\r\n                            slotContainer.addChild(mesh);\r\n                        }\r\n\r\n                        slot.currentMesh = slot.meshes[meshId];\r\n                        slot.currentMeshName = attachment.name;\r\n                        slot.currentMeshId = meshId;\r\n                    }\r\n                    (attachment as IVertexAttachment).computeWorldVerticesOld(slot, slot.currentMesh.vertices);\r\n                    if (slot.currentMesh.color) {\r\n                        // pixi-heaven\r\n                        spriteColor = slot.currentMesh.color;\r\n                    } else {\r\n                        tempRgb[0] = light[0] * slot.color.r * attColor.r;\r\n                        tempRgb[1] = light[1] * slot.color.g * attColor.g;\r\n                        tempRgb[2] = light[2] * slot.color.b * attColor.b;\r\n                        slot.currentMesh.tint = rgb2hex(tempRgb);\r\n                    }\r\n                    slot.currentMesh.blendMode = slot.blendMode;\r\n                    break;\r\n                case AttachmentType.Clipping:\r\n                    if (!slot.currentGraphics) {\r\n                        this.createGraphics(slot, attachment as IClippingAttachment);\r\n                        slotContainer.addChild(slot.clippingContainer);\r\n                        slotContainer.addChild(slot.currentGraphics);\r\n                    }\r\n                    this.updateGraphics(slot, attachment as IClippingAttachment);\r\n                    slotContainer.alpha = 1.0;\r\n                    slotContainer.visible = true;\r\n                    continue;\r\n                default:\r\n                    slotContainer.visible = false;\r\n                    continue;\r\n            }\r\n            slotContainer.visible = true;\r\n\r\n            // pixi has double tint\r\n            if (spriteColor) {\r\n                let r0 = slot.color.r * attColor.r;\r\n                let g0 = slot.color.g * attColor.g;\r\n                let b0 = slot.color.b * attColor.b;\r\n\r\n                //YAY! double-tint!\r\n                spriteColor.setLight(\r\n                    light[0] * r0 + dark[0] * (1.0 - r0),\r\n                    light[1] * g0 + dark[1] * (1.0 - g0),\r\n                    light[2] * b0 + dark[2] * (1.0 - b0),\r\n                );\r\n                if (slot.darkColor) {\r\n                    r0 = slot.darkColor.r;\r\n                    g0 = slot.darkColor.g;\r\n                    b0 = slot.darkColor.b;\r\n                } else {\r\n                    r0 = 0.0;\r\n                    g0 = 0.0;\r\n                    b0 = 0.0;\r\n                }\r\n                spriteColor.setDark(\r\n                    light[0] * r0 + dark[0] * (1 - r0),\r\n                    light[1] * g0 + dark[1] * (1 - g0),\r\n                    light[2] * b0 + dark[2] * (1 - b0),\r\n                );\r\n            }\r\n\r\n            slotContainer.alpha = slot.color.a;\r\n        }\r\n\r\n        //== this is clipping implementation ===\r\n        //TODO: remove parent hacks when pixi masks allow it\r\n        let drawOrder = this.skeleton.drawOrder;\r\n        let clippingAttachment: IClippingAttachment = null;\r\n        let clippingContainer: Container = null;\r\n\r\n        for (let i = 0, n = drawOrder.length; i < n; i++) {\r\n            let slot = slots[drawOrder[i].data.index];\r\n            let slotContainer = this.slotContainers[drawOrder[i].data.index];\r\n\r\n            if (!clippingContainer) {\r\n                //Adding null check as it is possible for slotContainer.parent to be null in the event of a spine being disposed off in its loop callback\r\n                if (slotContainer.parent !== null && slotContainer.parent !== this) {\r\n                    slotContainer.parent.removeChild(slotContainer);\r\n                    //silend add hack\r\n                    (slotContainer as any).parent = this;\r\n                }\r\n            }\r\n            if (slot.currentGraphics && slot.getAttachment()) {\r\n                clippingContainer = slot.clippingContainer;\r\n                clippingAttachment = slot.getAttachment() as IClippingAttachment;\r\n                clippingContainer.children.length = 0;\r\n                this.children[i] = slotContainer;\r\n\r\n                if (clippingAttachment.endSlot === slot.data) {\r\n                    clippingAttachment.endSlot = null;\r\n                }\r\n\r\n            } else {\r\n                if (clippingContainer) {\r\n                    let c = this.tempClipContainers[i];\r\n                    if (!c) {\r\n                        c = this.tempClipContainers[i] = this.newContainer();\r\n                        c.visible = false;\r\n                    }\r\n                    this.children[i] = c;\r\n\r\n                    //silent remove hack\r\n                    (slotContainer as any).parent = null;\r\n                    clippingContainer.addChild(slotContainer);\r\n                    if (clippingAttachment.endSlot == slot.data) {\r\n                        clippingContainer.renderable = true;\r\n                        clippingContainer = null;\r\n                        clippingAttachment = null;\r\n                    }\r\n                } else {\r\n                    this.children[i] = slotContainer;\r\n                }\r\n            }\r\n        }\r\n    };\r\n\r\n    private setSpriteRegion(attachment: IRegionAttachment, sprite: SpineSprite, region: TextureRegion) {\r\n        // prevent setters calling when attachment and region is same\r\n        if (sprite.attachment === attachment && sprite.region === region) {\r\n            return;\r\n        }\r\n\r\n        sprite.region = region;\r\n        sprite.attachment = attachment;\r\n\r\n        sprite.texture = region.texture;\r\n        sprite.rotation = attachment.rotation * MathUtils.degRad;\r\n        sprite.position.x = attachment.x;\r\n        sprite.position.y = attachment.y;\r\n        sprite.alpha = attachment.color.a;\r\n\r\n        if (!region.size) {\r\n            sprite.scale.x = attachment.scaleX * attachment.width / region.originalWidth;\r\n            sprite.scale.y = -attachment.scaleY * attachment.height / region.originalHeight;\r\n        } else {\r\n            //hacked!\r\n            sprite.scale.x = region.size.width / region.originalWidth;\r\n            sprite.scale.y = -region.size.height / region.originalHeight;\r\n        }\r\n    }\r\n\r\n    private setMeshRegion(attachment: IMeshAttachment, mesh: SpineMesh, region: TextureRegion) {\r\n\r\n        if (mesh.attachment === attachment && mesh.region === region) {\r\n            return;\r\n        }\r\n\r\n        mesh.region = region;\r\n        mesh.attachment = attachment;\r\n        mesh.texture = region.texture;\r\n        region.texture.updateUvs();\r\n        mesh.uvBuffer.update(attachment.regionUVs);\r\n    }\r\n\r\n    protected lastTime: number;\r\n\r\n    /**\r\n     * When autoupdate is set to yes this function is used as pixi's updateTransform function\r\n     *\r\n     * @private\r\n     */\r\n    autoUpdateTransform() {\r\n        if (settings.GLOBAL_AUTO_UPDATE) {\r\n            this.lastTime = this.lastTime || Date.now();\r\n            let timeDelta = (Date.now() - this.lastTime) * 0.001;\r\n            this.lastTime = Date.now();\r\n            this.update(timeDelta);\r\n        } else {\r\n            this.lastTime = 0;\r\n        }\r\n\r\n        Container.prototype.updateTransform.call(this);\r\n    };\r\n\r\n    /**\r\n     * Create a new sprite to be used with core.RegionAttachment\r\n     *\r\n     * @param slot {spine.Slot} The slot to which the attachment is parented\r\n     * @param attachment {spine.RegionAttachment} The attachment that the sprite will represent\r\n     * @private\r\n     */\r\n    createSprite(slot: ISlot, attachment: IRegionAttachment, defName: string) {\r\n        let region = attachment.region;\r\n        if (slot.hackAttachment === attachment) {\r\n            region = slot.hackRegion;\r\n        }\r\n        let texture = region.texture;\r\n        let sprite = this.newSprite(texture);\r\n\r\n        sprite.anchor.set(0.5);\r\n        this.setSpriteRegion(attachment, sprite, attachment.region);\r\n\r\n        slot.sprites = slot.sprites || {};\r\n        slot.sprites[defName] = sprite;\r\n        return sprite;\r\n    };\r\n\r\n    /**\r\n     * Creates a Strip from the spine data\r\n     * @param slot {spine.Slot} The slot to which the attachment is parented\r\n     * @param attachment {spine.RegionAttachment} The attachment that the sprite will represent\r\n     * @private\r\n     */\r\n    createMesh(slot: ISlot, attachment: IMeshAttachment) {\r\n        let region = attachment.region;\r\n        if (slot.hackAttachment === attachment) {\r\n            region = slot.hackRegion;\r\n            slot.hackAttachment = null;\r\n            slot.hackRegion = null;\r\n        }\r\n        let strip = this.newMesh(\r\n            region.texture,\r\n            new Float32Array(attachment.regionUVs.length),\r\n            attachment.regionUVs,\r\n            new Uint16Array(attachment.triangles),\r\n            DRAW_MODES.TRIANGLES);\r\n\r\n        if (typeof (strip as any)._canvasPadding !== \"undefined\") {\r\n            (strip as any)._canvasPadding = 1.5;\r\n        }\r\n\r\n        strip.alpha = attachment.color.a;\r\n\r\n        strip.region = attachment.region;\r\n        this.setMeshRegion(attachment, strip, region);\r\n\r\n        slot.meshes = slot.meshes || {};\r\n        slot.meshes[attachment.id] = strip;\r\n        return strip;\r\n    };\r\n\r\n    static clippingPolygon: Array<number> = [];\r\n\r\n    //@ts-ignore\r\n    createGraphics(slot: ISlot, clip: IClippingAttachment) {\r\n        let graphics = this.newGraphics();\r\n        let poly = new Polygon([]);\r\n        graphics.clear();\r\n        graphics.beginFill(0xffffff, 1);\r\n        graphics.drawPolygon(poly as any);\r\n        graphics.renderable = false;\r\n        slot.currentGraphics = graphics;\r\n        slot.clippingContainer = this.newContainer();\r\n        slot.clippingContainer.mask = slot.currentGraphics;\r\n\r\n        return graphics;\r\n    }\r\n\r\n    updateGraphics(slot: ISlot, clip: IClippingAttachment) {\r\n        let geom = slot.currentGraphics.geometry;\r\n        let vertices = (geom.graphicsData[0].shape as Polygon).points;\r\n        let n = clip.worldVerticesLength;\r\n        vertices.length = n;\r\n        clip.computeWorldVertices(slot, 0, n, vertices, 0, 2);\r\n        geom.invalidate();\r\n    }\r\n\r\n    /**\r\n     * Changes texture in attachment in specific slot.\r\n     *\r\n     * PIXI runtime feature, it was made to satisfy our users.\r\n     *\r\n     * @param slotIndex {number}\r\n     * @param [texture = null] {PIXI.Texture} If null, take default (original) texture\r\n     * @param [size = null] {PIXI.Point} sometimes we need new size for region attachment, you can pass 'texture.orig' there\r\n     * @returns {boolean} Success flag\r\n     */\r\n    hackTextureBySlotIndex(slotIndex: number, texture: Texture = null, size: Rectangle = null) {\r\n        let slot = this.skeleton.slots[slotIndex];\r\n        if (!slot) {\r\n            return false;\r\n        }\r\n        let attachment: any = slot.getAttachment();\r\n        let region: TextureRegion = attachment.region;\r\n        if (texture) {\r\n            region = new TextureRegion();\r\n            region.texture = texture;\r\n            region.size = size;\r\n            slot.hackRegion = region;\r\n            slot.hackAttachment = attachment;\r\n        } else {\r\n            slot.hackRegion = null;\r\n            slot.hackAttachment = null;\r\n        }\r\n        if (slot.currentSprite && slot.currentSprite.region != region) {\r\n            this.setSpriteRegion(attachment, slot.currentSprite, region);\r\n            slot.currentSprite.region = region;\r\n        } else if (slot.currentMesh && slot.currentMesh.region != region) {\r\n            this.setMeshRegion(attachment, slot.currentMesh, region);\r\n        }\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * Changes texture in attachment in specific slot.\r\n     *\r\n     * PIXI runtime feature, it was made to satisfy our users.\r\n     *\r\n     * @param slotName {string}\r\n     * @param [texture = null] {PIXI.Texture} If null, take default (original) texture\r\n     * @param [size = null] {PIXI.Point} sometimes we need new size for region attachment, you can pass 'texture.orig' there\r\n     * @returns {boolean} Success flag\r\n     */\r\n    hackTextureBySlotName(slotName: string, texture: Texture = null, size: Rectangle = null) {\r\n        let index = this.skeleton.findSlotIndex(slotName);\r\n        if (index == -1) {\r\n            return false;\r\n        }\r\n        return this.hackTextureBySlotIndex(index, texture, size);\r\n    }\r\n\r\n    /**\r\n     * Changes texture of an attachment\r\n     *\r\n     * PIXI runtime feature, it was made to satisfy our users.\r\n     *\r\n     * @param slotName {string}\r\n     * @param attachmentName {string}\r\n     * @param [texture = null] {PIXI.Texture} If null, take default (original) texture\r\n     * @param [size = null] {PIXI.Point} sometimes we need new size for region attachment, you can pass 'texture.orig' there\r\n     * @returns {boolean} Success flag\r\n     */\r\n    hackTextureAttachment(slotName: string, attachmentName: string, texture, size: Rectangle = null) {\r\n        // changes the texture of an attachment at the skeleton level\r\n        const slotIndex = this.skeleton.findSlotIndex(slotName)\r\n        const attachment: any = this.skeleton.getAttachmentByName(slotName, attachmentName)\r\n        attachment.region.texture = texture\r\n\r\n        const slot = this.skeleton.slots[slotIndex]\r\n        if (!slot) {\r\n            return false\r\n        }\r\n\r\n        // gets the currently active attachment in this slot\r\n        const currentAttachment: any = slot.getAttachment()\r\n        if (attachmentName === currentAttachment.name) {\r\n            // if the attachment we are changing is currently active, change the the live texture\r\n            let region: TextureRegion = attachment.region\r\n            if (texture) {\r\n                region = new TextureRegion()\r\n                region.texture = texture\r\n                region.size = size\r\n                slot.hackRegion = region\r\n                slot.hackAttachment = currentAttachment\r\n            } else {\r\n                slot.hackRegion = null\r\n                slot.hackAttachment = null\r\n            }\r\n            if (slot.currentSprite && slot.currentSprite.region != region) {\r\n                this.setSpriteRegion(currentAttachment, slot.currentSprite, region)\r\n                slot.currentSprite.region = region\r\n            } else if (slot.currentMesh && slot.currentMesh.region != region) {\r\n                this.setMeshRegion(currentAttachment, slot.currentMesh, region)\r\n            }\r\n            return true\r\n        }\r\n        return false\r\n    }\r\n\r\n    //those methods can be overriden to spawn different classes\r\n    newContainer() {\r\n        return new Container();\r\n    }\r\n\r\n    newSprite(tex: Texture) {\r\n        return new SpineSprite(tex);\r\n    }\r\n\r\n    newGraphics() {\r\n        return new Graphics();\r\n    }\r\n\r\n    newMesh(texture: Texture, vertices?: Float32Array, uvs?: Float32Array, indices?: Uint16Array, drawMode?: number) {\r\n        return new SpineMesh(texture, vertices, uvs, indices, drawMode);\r\n    }\r\n\r\n    transformHack() {\r\n        return 1;\r\n    }\r\n\r\n    /**\r\n     * Hack for pixi-display and pixi-lights. Every attachment name ending with a suffix will be added to different layer\r\n     * @param nameSuffix\r\n     * @param group\r\n     * @param outGroup\r\n     */\r\n    hackAttachmentGroups(nameSuffix: string, group: any, outGroup: any) {\r\n        if (!nameSuffix) {\r\n            return undefined;\r\n        }\r\n        const list_d = [], list_n = [];\r\n        for (let i = 0, len = this.skeleton.slots.length; i < len; i++) {\r\n            const slot = this.skeleton.slots[i];\r\n            const name = slot.currentSpriteName || slot.currentMeshName || \"\";\r\n            const target = slot.currentSprite || slot.currentMesh;\r\n            if (name.endsWith(nameSuffix)) {\r\n                target.parentGroup = group;\r\n                list_n.push(target);\r\n            } else if (outGroup && target) {\r\n                target.parentGroup = outGroup;\r\n                list_d.push(target);\r\n            }\r\n        }\r\n        return [list_d, list_n];\r\n    };\r\n\r\n    destroy(options?: any): void {\r\n        for (let i = 0, n = this.skeleton.slots.length; i < n; i++) {\r\n            let slot = this.skeleton.slots[i];\r\n            for (let name in slot.meshes) {\r\n                slot.meshes[name].destroy(options);\r\n            }\r\n            slot.meshes = null;\r\n\r\n            for (let name in slot.sprites) {\r\n                slot.sprites[name].destroy(options);\r\n            }\r\n            slot.sprites = null;\r\n        }\r\n\r\n        for (let i = 0, n = this.slotContainers.length; i < n; i++) {\r\n            this.slotContainers[i].destroy(options);\r\n        }\r\n        this.spineData = null;\r\n        this.skeleton = null;\r\n        this.slotContainers = null;\r\n        this.stateData = null;\r\n        this.state = null;\r\n        this.tempClipContainers = null;\r\n\r\n        super.destroy(options);\r\n    }\r\n}\r\n\r\n\r\n/**\r\n * The visibility of the spine object. If false the object will not be drawn,\r\n * the updateTransform function will not be called, and the spine will not be automatically updated.\r\n *\r\n * @member {boolean}\r\n * @memberof spine.Spine#\r\n * @default true\r\n */\r\nObject.defineProperty(SpineBase.prototype, 'visible', {\r\n    get: function () {\r\n        return this._visible;\r\n    },\r\n    set: function (value: boolean) {\r\n        if (value !== this._visible) {\r\n            this._visible = value;\r\n            if (value) {\r\n                this.lastTime = 0;\r\n            }\r\n        }\r\n    }\r\n})\r\n","import {IResourceMetadata, Loader, LoaderResource} from \"@pixi/loaders\";\nimport {BaseTexture, Texture} from \"@pixi/core\";\nimport {ISkeletonParser, TextureAtlas} from \"@pixi-spine/base\";\nimport {ALPHA_MODES} from \"@pixi/constants\";\n\nfunction isJson(resource: LoaderResource) {\n    return resource.type === LoaderResource.TYPE.JSON;\n}\n\nfunction isBuffer(resource: LoaderResource) {\n    return resource.xhrType === (LoaderResource as any).XHR_RESPONSE_TYPE.BUFFER;\n}\n\nLoaderResource.setExtensionXhrType('skel', LoaderResource.XHR_RESPONSE_TYPE.BUFFER);\n\n/**\n * @public\n */\nexport abstract class AbstractSpineParser {\n    abstract createJsonParser(): ISkeletonParser;\n\n    abstract createBinaryParser(): ISkeletonParser;\n\n    abstract parseData(resource: LoaderResource, parser: ISkeletonParser, atlas: TextureAtlas, dataToParse: any): void;\n\n    genMiddleware() {\n        const self = this;\n\n        return {\n            use(this: Loader, resource: LoaderResource, next: () => any) {\n                // skip if no data, its not json, or it isn't atlas data\n                if (!resource.data) {\n                    return next();\n                }\n\n                const isJsonSpineModel = isJson(resource) && resource.data.bones;\n                const isBinarySpineModel = isBuffer(resource) && (resource.extension === 'skel' || resource.metadata\n                    && (resource.metadata as any).spineMetadata);\n\n                if (!isJsonSpineModel && !isBinarySpineModel) {\n                    return next();\n                }\n\n                let parser: ISkeletonParser = null;\n                let dataToParse = resource.data;\n\n                if (isJsonSpineModel) {\n                    parser = self.createJsonParser();\n                } else {\n                    parser = self.createBinaryParser();\n                    if (resource.data instanceof ArrayBuffer) {\n                        dataToParse = new Uint8Array(resource.data);\n                    }\n                }\n\n                const metadata = (resource.metadata || {}) as IResourceMetadata;\n                const metadataSkeletonScale = metadata ? (metadata as any).spineSkeletonScale : null;\n\n                if (metadataSkeletonScale) {\n                    parser.scale = metadataSkeletonScale;\n                }\n\n                const metadataAtlas = metadata.spineAtlas;\n                if (metadataAtlas === false) {\n                    return next();\n                }\n                if (metadataAtlas && metadataAtlas.pages) {\n                    self.parseData(resource, parser, metadataAtlas, dataToParse);\n                    return next();\n                }\n\n                const metadataAtlasSuffix = metadata.spineAtlasSuffix || '.atlas';\n\n                /**\n                 * use a bit of hackery to load the atlas file, here we assume that the .json, .atlas and .png files\n                 * that correspond to the spine file are in the same base URL and that the .json and .atlas files\n                 * have the same name\n                 */\n                let atlasPath = resource.url;\n                let queryStringPos = atlasPath.indexOf('?');\n                if (queryStringPos > 0) {\n                    //remove querystring\n                    atlasPath = atlasPath.substr(0, queryStringPos)\n                }\n                atlasPath = atlasPath.substr(0, atlasPath.lastIndexOf('.')) + metadataAtlasSuffix;\n// use atlas path as a params. (no need to use same atlas file name with json file name)\n                if (metadata.spineAtlasFile) {\n                    atlasPath = metadata.spineAtlasFile;\n                }\n\n//remove the baseUrl\n                atlasPath = atlasPath.replace(this.baseUrl, '');\n\n                const atlasOptions = {\n                    crossOrigin: resource.crossOrigin,\n                    xhrType: LoaderResource.XHR_RESPONSE_TYPE.TEXT,\n                    metadata: metadata.spineMetadata || null,\n                    parentResource: resource\n                };\n                const imageOptions = {\n                    crossOrigin: resource.crossOrigin,\n                    metadata: metadata.imageMetadata || null,\n                    parentResource: resource\n                };\n                let baseUrl = resource.url.substr(0, resource.url.lastIndexOf('/') + 1);\n//remove the baseUrl\n                baseUrl = baseUrl.replace(this.baseUrl, '');\n\n                const namePrefix = metadata.imageNamePrefix || (resource.name + '_atlas_page_');\n\n                const adapter = metadata.images ? staticImageLoader(metadata.images)\n                    : metadata.image ? staticImageLoader({'default': metadata.image})\n                        : metadata.imageLoader ? metadata.imageLoader(this, namePrefix, baseUrl, imageOptions)\n                            : imageLoaderAdapter(this, namePrefix, baseUrl, imageOptions);\n\n                function createSkeletonWithRawAtlas(rawData: string) {\n                    new TextureAtlas(rawData, adapter, function(spineAtlas) {\n                        if (spineAtlas) {\n                            self.parseData(resource, parser, spineAtlas, dataToParse);\n                        }\n                        next();\n                    });\n                }\n\n                if (metadata.atlasRawData) {\n                    createSkeletonWithRawAtlas(metadata.atlasRawData)\n                } else {\n                    this.add(resource.name + '_atlas', atlasPath, atlasOptions, function (atlasResource: any) {\n                        if (!atlasResource.error) {\n                            createSkeletonWithRawAtlas(atlasResource.data);\n                        } else {\n                            next();\n                        }\n                    });\n                }\n            }\n        }\n    }\n}\n\n/**\n * @public\n */\nexport function imageLoaderAdapter(loader: any, namePrefix: any, baseUrl: any, imageOptions: any) {\n    if (baseUrl && baseUrl.lastIndexOf('/') !== (baseUrl.length - 1)) {\n        baseUrl += '/';\n    }\n    return function (line: string, callback: (baseTexture: BaseTexture) => any) {\n        const name = namePrefix + line;\n        const url = baseUrl + line;\n\n        const cachedResource = loader.resources[name];\n        if (cachedResource) {\n            const done = () => {\n                callback(cachedResource.texture.baseTexture)\n            }\n            if (cachedResource.texture) {\n                done();\n            } else {\n                cachedResource.onAfterMiddleware.add(done);\n            }\n        } else {\n            loader.add(name, url, imageOptions, (resource: LoaderResource) => {\n                if (!resource.error) {\n                    if (line.indexOf('-pma.') >= 0) {\n                        resource.texture.baseTexture.alphaMode = ALPHA_MODES.PMA;\n                    }\n\n                    callback(resource.texture.baseTexture);\n                } else {\n                    callback(null);\n                }\n            });\n        }\n    }\n}\n\n/**\n * @public\n */\nexport function syncImageLoaderAdapter(baseUrl: any, crossOrigin: any) {\n    if (baseUrl && baseUrl.lastIndexOf('/') !== (baseUrl.length - 1)) {\n        baseUrl += '/';\n    }\n    return function (line: any, callback: any) {\n        callback(BaseTexture.from(line, crossOrigin));\n    }\n}\n\n/**\n * @public\n */\nexport function staticImageLoader(pages: { [key: string]: (BaseTexture | Texture) }) {\n    return function (line: any, callback: any) {\n        let page = pages[line] || pages['default'] as any;\n        if (page && page.baseTexture)\n            callback(page.baseTexture);\n        else\n            callback(page);\n    }\n}\n","import {Event} from './Event';\r\nimport type {Skeleton} from \"./Skeleton\";\r\nimport {Attachment, VertexAttachment} from \"./attachments\";\r\nimport {ArrayLike, MathUtils, Utils, MixBlend, MixDirection} from '@pixi-spine/base';\r\nimport {Slot} from \"./Slot\";\r\nimport {IkConstraint} from \"./IkConstraint\";\r\nimport {TransformConstraint} from \"./TransformConstraint\";\r\nimport {PathConstraint} from \"./PathConstraint\";\r\n/** A simple container for a list of timelines and a name. */\r\n/**\r\n * @public\r\n */\r\nexport class Animation {\r\n    /** The animation's name, which is unique across all animations in the skeleton. */\r\n    name: string;\r\n    timelines: Array<Timeline>;\r\n    timelineIds: Array<boolean>;\r\n\r\n    /** The duration of the animation in seconds, which is the highest time of all keys in the timeline. */\r\n    duration: number;\r\n\r\n    constructor (name: string, timelines: Array<Timeline>, duration: number) {\r\n        if (name == null) throw new Error(\"name cannot be null.\");\r\n        if (timelines == null) throw new Error(\"timelines cannot be null.\");\r\n        this.name = name;\r\n        this.timelines = timelines;\r\n        this.timelineIds = [];\r\n        for (var i = 0; i < timelines.length; i++)\r\n            this.timelineIds[timelines[i].getPropertyId()] = true;\r\n        this.duration = duration;\r\n    }\r\n\r\n    hasTimeline (id: number) {\r\n        return this.timelineIds[id] == true;\r\n    }\r\n\r\n    /** Applies all the animation's timelines to the specified skeleton.\r\n     *\r\n     * See Timeline {@link Timeline#apply(Skeleton, float, float, Array, float, MixBlend, MixDirection)}.\r\n     * @param loop If true, the animation repeats after {@link #getDuration()}.\r\n     * @param events May be null to ignore fired events. */\r\n    apply (skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        if (skeleton == null) throw new Error(\"skeleton cannot be null.\");\r\n\r\n        if (loop && this.duration != 0) {\r\n            time %= this.duration;\r\n            if (lastTime > 0) lastTime %= this.duration;\r\n        }\r\n\r\n        let timelines = this.timelines;\r\n        for (let i = 0, n = timelines.length; i < n; i++)\r\n            timelines[i].apply(skeleton, lastTime, time, events, alpha, blend, direction);\r\n    }\r\n\r\n    /** @param target After the first and before the last value.\r\n     * @returns index of first value greater than the target. */\r\n    static binarySearch (values: ArrayLike<number>, target: number, step: number = 1) {\r\n        let low = 0;\r\n        let high = values.length / step - 2;\r\n        if (high == 0) return step;\r\n        let current = high >>> 1;\r\n        while (true) {\r\n            if (values[(current + 1) * step] <= target)\r\n                low = current + 1;\r\n            else\r\n                high = current;\r\n            if (low == high) return (low + 1) * step;\r\n            current = (low + high) >>> 1;\r\n        }\r\n    }\r\n\r\n    static linearSearch (values: ArrayLike<number>, target: number, step: number) {\r\n        for (let i = 0, last = values.length - step; i <= last; i += step)\r\n            if (values[i] > target) return i;\r\n        return -1;\r\n    }\r\n}\r\n\r\n/** The interface for all timelines. */\r\n/**\r\n * @public\r\n */\r\nexport interface Timeline {\r\n    /** Applies this timeline to the skeleton.\r\n     * @param skeleton The skeleton the timeline is being applied to. This provides access to the bones, slots, and other\r\n     *           skeleton components the timeline may change.\r\n     * @param lastTime The time this timeline was last applied. Timelines such as {@link EventTimeline}} trigger only at specific\r\n     *           times rather than every frame. In that case, the timeline triggers everything between `lastTime`\r\n     *           (exclusive) and `time` (inclusive).\r\n     * @param time The time within the animation. Most timelines find the key before and the key after this time so they can\r\n     *           interpolate between the keys.\r\n     * @param events If any events are fired, they are added to this list. Can be null to ignore fired events or if the timeline\r\n     *           does not fire events.\r\n     * @param alpha 0 applies the current or setup value (depending on `blend`). 1 applies the timeline value.\r\n     *           Between 0 and 1 applies a value between the current or setup value and the timeline value. By adjusting\r\n     *           `alpha` over time, an animation can be mixed in or out. `alpha` can also be useful to\r\n     *           apply animations on top of each other (layering).\r\n     * @param blend Controls how mixing is applied when `alpha` < 1.\r\n     * @param direction Indicates whether the timeline is mixing in or out. Used by timelines which perform instant transitions,\r\n     *           such as {@link DrawOrderTimeline} or {@link AttachmentTimeline}. */\r\n    apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;\r\n\r\n    /** Uniquely encodes both the type of this timeline and the skeleton property that it affects. */\r\n    getPropertyId (): number;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport enum TimelineType {\r\n    rotate, translate, scale, shear,\r\n    attachment, color, deform,\r\n    event, drawOrder,\r\n    ikConstraint, transformConstraint,\r\n    pathConstraintPosition, pathConstraintSpacing, pathConstraintMix,\r\n    twoColor\r\n}\r\n\r\n/** The base class for timelines that use interpolation between key frame values. */\r\n/**\r\n * @public\r\n */\r\nexport abstract class CurveTimeline implements Timeline {\r\n    static LINEAR = 0; static STEPPED = 1; static BEZIER = 2;\r\n    static BEZIER_SIZE = 10 * 2 - 1;\r\n\r\n    private curves: ArrayLike<number>; // type, x, y, ...\r\n\r\n    abstract getPropertyId(): number;\r\n\r\n    constructor (frameCount: number) {\r\n        if (frameCount <= 0) throw new Error(\"frameCount must be > 0: \" + frameCount);\r\n        this.curves = Utils.newFloatArray((frameCount - 1) * CurveTimeline.BEZIER_SIZE);\r\n    }\r\n\r\n    /** The number of key frames for this timeline. */\r\n    getFrameCount () {\r\n        return this.curves.length / CurveTimeline.BEZIER_SIZE + 1;\r\n    }\r\n\r\n    /** Sets the specified key frame to linear interpolation. */\r\n    setLinear (frameIndex: number) {\r\n        this.curves[frameIndex * CurveTimeline.BEZIER_SIZE] = CurveTimeline.LINEAR;\r\n    }\r\n\r\n    /** Sets the specified key frame to stepped interpolation. */\r\n    setStepped (frameIndex: number) {\r\n        this.curves[frameIndex * CurveTimeline.BEZIER_SIZE] = CurveTimeline.STEPPED;\r\n    }\r\n\r\n    /** Returns the interpolation type for the specified key frame.\r\n     * @returns Linear is 0, stepped is 1, Bezier is 2. */\r\n    getCurveType (frameIndex: number): number {\r\n        let index = frameIndex * CurveTimeline.BEZIER_SIZE;\r\n        if (index == this.curves.length) return CurveTimeline.LINEAR;\r\n        let type = this.curves[index];\r\n        if (type == CurveTimeline.LINEAR) return CurveTimeline.LINEAR;\r\n        if (type == CurveTimeline.STEPPED) return CurveTimeline.STEPPED;\r\n        return CurveTimeline.BEZIER;\r\n    }\r\n\r\n    /** Sets the specified key frame to Bezier interpolation. `cx1` and `cx2` are from 0 to 1,\r\n     * representing the percent of time between the two key frames. `cy1` and `cy2` are the percent of the\r\n     * difference between the key frame's values. */\r\n    setCurve (frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number) {\r\n        let tmpx = (-cx1 * 2 + cx2) * 0.03, tmpy = (-cy1 * 2 + cy2) * 0.03;\r\n        let dddfx = ((cx1 - cx2) * 3 + 1) * 0.006, dddfy = ((cy1 - cy2) * 3 + 1) * 0.006;\r\n        let ddfx = tmpx * 2 + dddfx, ddfy = tmpy * 2 + dddfy;\r\n        let dfx = cx1 * 0.3 + tmpx + dddfx * 0.16666667, dfy = cy1 * 0.3 + tmpy + dddfy * 0.16666667;\r\n\r\n        let i = frameIndex * CurveTimeline.BEZIER_SIZE;\r\n        let curves = this.curves;\r\n        curves[i++] = CurveTimeline.BEZIER;\r\n\r\n        let x = dfx, y = dfy;\r\n        for (let n = i + CurveTimeline.BEZIER_SIZE - 1; i < n; i += 2) {\r\n            curves[i] = x;\r\n            curves[i + 1] = y;\r\n            dfx += ddfx;\r\n            dfy += ddfy;\r\n            ddfx += dddfx;\r\n            ddfy += dddfy;\r\n            x += dfx;\r\n            y += dfy;\r\n        }\r\n    }\r\n\r\n    /** Returns the interpolated percentage for the specified key frame and linear percentage. */\r\n    getCurvePercent (frameIndex: number, percent: number) {\r\n        percent = MathUtils.clamp(percent, 0, 1);\r\n        let curves = this.curves;\r\n        let i = frameIndex * CurveTimeline.BEZIER_SIZE;\r\n        let type = curves[i];\r\n        if (type == CurveTimeline.LINEAR) return percent;\r\n        if (type == CurveTimeline.STEPPED) return 0;\r\n        i++;\r\n        let x = 0;\r\n        for (let start = i, n = i + CurveTimeline.BEZIER_SIZE - 1; i < n; i += 2) {\r\n            x = curves[i];\r\n            if (x >= percent) {\r\n                let prevX: number, prevY: number;\r\n                if (i == start) {\r\n                    prevX = 0;\r\n                    prevY = 0;\r\n                } else {\r\n                    prevX = curves[i - 2];\r\n                    prevY = curves[i - 1];\r\n                }\r\n                return prevY + (curves[i + 1] - prevY) * (percent - prevX) / (x - prevX);\r\n            }\r\n        }\r\n        let y = curves[i - 1];\r\n        return y + (1 - y) * (percent - x) / (1 - x); // Last point is 1,1.\r\n    }\r\n\r\n    abstract apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;\r\n}\r\n\r\n/** Changes a bone's local {@link Bone#rotation}. */\r\n/**\r\n * @public\r\n */\r\nexport class RotateTimeline extends CurveTimeline {\r\n    static ENTRIES = 2;\r\n    static PREV_TIME = -2; static PREV_ROTATION = -1;\r\n    static ROTATION = 1;\r\n\r\n    /** The index of the bone in {@link Skeleton#bones} that will be changed. */\r\n    boneIndex: number;\r\n\r\n    /** The time in seconds and rotation in degrees for each key frame. */\r\n    frames: ArrayLike<number>; // time, degrees, ...\r\n\r\n    constructor (frameCount: number) {\r\n        super(frameCount);\r\n        this.frames = Utils.newFloatArray(frameCount << 1);\r\n    }\r\n\r\n    getPropertyId () {\r\n        return (TimelineType.rotate << 24) + this.boneIndex;\r\n    }\r\n\r\n    /** Sets the time and angle of the specified keyframe. */\r\n    setFrame (frameIndex: number, time: number, degrees: number) {\r\n        frameIndex <<= 1;\r\n        this.frames[frameIndex] = time;\r\n        this.frames[frameIndex + RotateTimeline.ROTATION] = degrees;\r\n    }\r\n\r\n    apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        let frames = this.frames;\r\n\r\n        let bone = skeleton.bones[this.boneIndex];\r\n        if (!bone.active) return;\r\n        if (time < frames[0]) {\r\n            switch (blend) {\r\n                case MixBlend.setup:\r\n                    bone.rotation = bone.data.rotation;\r\n                    return;\r\n                case MixBlend.first:\r\n                    let r = bone.data.rotation - bone.rotation;\r\n                    bone.rotation += (r - (16384 - ((16384.499999999996 - r / 360) | 0)) * 360) * alpha;\r\n            }\r\n            return;\r\n        }\r\n\r\n        if (time >= frames[frames.length - RotateTimeline.ENTRIES]) { // Time is after last frame.\r\n            let r = frames[frames.length + RotateTimeline.PREV_ROTATION];\r\n            switch (blend) {\r\n                case MixBlend.setup:\r\n                    bone.rotation = bone.data.rotation + r * alpha;\r\n                    break;\r\n                case MixBlend.first:\r\n                case MixBlend.replace:\r\n                    r += bone.data.rotation - bone.rotation;\r\n                    r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360; // Wrap within -180 and 180.\r\n                case MixBlend.add:\r\n                    bone.rotation += r * alpha;\r\n            }\r\n            return;\r\n        }\r\n\r\n        // Interpolate between the previous frame and the current frame.\r\n        let frame = Animation.binarySearch(frames, time, RotateTimeline.ENTRIES);\r\n        let prevRotation = frames[frame + RotateTimeline.PREV_ROTATION];\r\n        let frameTime = frames[frame];\r\n        let percent = this.getCurvePercent((frame >> 1) - 1,\r\n            1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));\r\n\r\n        let r = frames[frame + RotateTimeline.ROTATION] - prevRotation;\r\n        r = prevRotation + (r - (16384 - ((16384.499999999996 - r / 360) | 0)) * 360) * percent;\r\n        switch (blend) {\r\n            case MixBlend.setup:\r\n                bone.rotation = bone.data.rotation + (r - (16384 - ((16384.499999999996 - r / 360) | 0)) * 360) * alpha;\r\n                break;\r\n            case MixBlend.first:\r\n            case MixBlend.replace:\r\n                r += bone.data.rotation - bone.rotation;\r\n            case MixBlend.add:\r\n                bone.rotation += (r - (16384 - ((16384.499999999996 - r / 360) | 0)) * 360) * alpha;\r\n        }\r\n    }\r\n}\r\n\r\n/** Changes a bone's local {@link Bone#x} and {@link Bone#y}. */\r\n/**\r\n * @public\r\n */\r\nexport class TranslateTimeline extends CurveTimeline {\r\n    static ENTRIES = 3;\r\n    static PREV_TIME = -3; static PREV_X = -2; static PREV_Y = -1;\r\n    static X = 1; static Y = 2;\r\n\r\n    /** The index of the bone in {@link Skeleton#bones} that will be changed. */\r\n    boneIndex: number;\r\n\r\n    /** The time in seconds, x, and y values for each key frame. */\r\n    frames: ArrayLike<number>; // time, x, y, ...\r\n\r\n    constructor (frameCount: number) {\r\n        super(frameCount);\r\n        this.frames = Utils.newFloatArray(frameCount * TranslateTimeline.ENTRIES);\r\n    }\r\n\r\n    getPropertyId () {\r\n        return (TimelineType.translate << 24) + this.boneIndex;\r\n    }\r\n\r\n    /** Sets the time in seconds, x, and y values for the specified key frame. */\r\n    setFrame (frameIndex: number, time: number, x: number, y: number) {\r\n        frameIndex *= TranslateTimeline.ENTRIES;\r\n        this.frames[frameIndex] = time;\r\n        this.frames[frameIndex + TranslateTimeline.X] = x;\r\n        this.frames[frameIndex + TranslateTimeline.Y] = y;\r\n    }\r\n\r\n        apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        let frames = this.frames;\r\n\r\n        let bone = skeleton.bones[this.boneIndex];\r\n        if (!bone.active) return;\r\n        if (time < frames[0]) {\r\n            switch (blend) {\r\n                case MixBlend.setup:\r\n                    bone.x = bone.data.x;\r\n                    bone.y = bone.data.y;\r\n                    return;\r\n                case MixBlend.first:\r\n                    bone.x += (bone.data.x - bone.x) * alpha;\r\n                    bone.y += (bone.data.y - bone.y) * alpha;\r\n            }\r\n            return;\r\n        }\r\n\r\n        let x = 0, y = 0;\r\n        if (time >= frames[frames.length - TranslateTimeline.ENTRIES]) { // Time is after last frame.\r\n            x = frames[frames.length + TranslateTimeline.PREV_X];\r\n            y = frames[frames.length + TranslateTimeline.PREV_Y];\r\n        } else {\r\n            // Interpolate between the previous frame and the current frame.\r\n            let frame = Animation.binarySearch(frames, time, TranslateTimeline.ENTRIES);\r\n            x = frames[frame + TranslateTimeline.PREV_X];\r\n            y = frames[frame + TranslateTimeline.PREV_Y];\r\n            let frameTime = frames[frame];\r\n            let percent = this.getCurvePercent(frame / TranslateTimeline.ENTRIES - 1,\r\n                1 - (time - frameTime) / (frames[frame + TranslateTimeline.PREV_TIME] - frameTime));\r\n\r\n            x += (frames[frame + TranslateTimeline.X] - x) * percent;\r\n            y += (frames[frame + TranslateTimeline.Y] - y) * percent;\r\n        }\r\n        switch (blend) {\r\n            case MixBlend.setup:\r\n                bone.x = bone.data.x + x * alpha;\r\n                bone.y = bone.data.y + y * alpha;\r\n                break;\r\n            case MixBlend.first:\r\n            case MixBlend.replace:\r\n                bone.x += (bone.data.x + x - bone.x) * alpha;\r\n                bone.y += (bone.data.y + y - bone.y) * alpha;\r\n                break;\r\n            case MixBlend.add:\r\n                bone.x += x * alpha;\r\n                bone.y += y * alpha;\r\n        }\r\n    }\r\n}\r\n\r\n/** Changes a bone's local {@link Bone#scaleX)} and {@link Bone#scaleY}. */\r\n/**\r\n * @public\r\n */\r\nexport class ScaleTimeline extends TranslateTimeline {\r\n    constructor (frameCount: number) {\r\n        super(frameCount);\r\n    }\r\n\r\n    getPropertyId () {\r\n        return (TimelineType.scale << 24) + this.boneIndex;\r\n    }\r\n\r\n        apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        let frames = this.frames;\r\n\r\n        let bone = skeleton.bones[this.boneIndex];\r\n        if (!bone.active) return;\r\n        if (time < frames[0]) {\r\n            switch (blend) {\r\n                case MixBlend.setup:\r\n                    bone.scaleX = bone.data.scaleX;\r\n                    bone.scaleY = bone.data.scaleY;\r\n                    return;\r\n                case MixBlend.first:\r\n                    bone.scaleX += (bone.data.scaleX - bone.scaleX) * alpha;\r\n                    bone.scaleY += (bone.data.scaleY - bone.scaleY) * alpha;\r\n            }\r\n            return;\r\n        }\r\n\r\n        let x = 0, y = 0;\r\n        if (time >= frames[frames.length - ScaleTimeline.ENTRIES]) { // Time is after last frame.\r\n            x = frames[frames.length + ScaleTimeline.PREV_X] * bone.data.scaleX;\r\n            y = frames[frames.length + ScaleTimeline.PREV_Y] * bone.data.scaleY;\r\n        } else {\r\n            // Interpolate between the previous frame and the current frame.\r\n            let frame = Animation.binarySearch(frames, time, ScaleTimeline.ENTRIES);\r\n            x = frames[frame + ScaleTimeline.PREV_X];\r\n            y = frames[frame + ScaleTimeline.PREV_Y];\r\n            let frameTime = frames[frame];\r\n            let percent = this.getCurvePercent(frame / ScaleTimeline.ENTRIES - 1,\r\n                1 - (time - frameTime) / (frames[frame + ScaleTimeline.PREV_TIME] - frameTime));\r\n\r\n            x = (x + (frames[frame + ScaleTimeline.X] - x) * percent) * bone.data.scaleX;\r\n            y = (y + (frames[frame + ScaleTimeline.Y] - y) * percent) * bone.data.scaleY;\r\n        }\r\n        if (alpha == 1) {\r\n            if (blend == MixBlend.add) {\r\n                bone.scaleX += x - bone.data.scaleX;\r\n                bone.scaleY += y - bone.data.scaleY;\r\n            } else {\r\n                bone.scaleX = x;\r\n                bone.scaleY = y;\r\n            }\r\n        } else {\r\n            let bx = 0, by = 0;\r\n            if (direction == MixDirection.mixOut) {\r\n                switch (blend) {\r\n                    case MixBlend.setup:\r\n                        bx = bone.data.scaleX;\r\n                        by = bone.data.scaleY;\r\n                        bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;\r\n                        bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;\r\n                        break;\r\n                    case MixBlend.first:\r\n                    case MixBlend.replace:\r\n                        bx = bone.scaleX;\r\n                        by = bone.scaleY;\r\n                        bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;\r\n                        bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;\r\n                        break;\r\n                    case MixBlend.add:\r\n                        bx = bone.scaleX;\r\n                        by = bone.scaleY;\r\n                        bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bone.data.scaleX) * alpha;\r\n                        bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - bone.data.scaleY) * alpha;\r\n                }\r\n            } else {\r\n                switch (blend) {\r\n                    case MixBlend.setup:\r\n                        bx = Math.abs(bone.data.scaleX) * MathUtils.signum(x);\r\n                        by = Math.abs(bone.data.scaleY) * MathUtils.signum(y);\r\n                        bone.scaleX = bx + (x - bx) * alpha;\r\n                        bone.scaleY = by + (y - by) * alpha;\r\n                        break;\r\n                    case MixBlend.first:\r\n                    case MixBlend.replace:\r\n                        bx = Math.abs(bone.scaleX) * MathUtils.signum(x);\r\n                        by = Math.abs(bone.scaleY) * MathUtils.signum(y);\r\n                        bone.scaleX = bx + (x - bx) * alpha;\r\n                        bone.scaleY = by + (y - by) * alpha;\r\n                        break;\r\n                    case MixBlend.add:\r\n                        bx = MathUtils.signum(x);\r\n                        by = MathUtils.signum(y);\r\n                        bone.scaleX = Math.abs(bone.scaleX) * bx + (x - Math.abs(bone.data.scaleX) * bx) * alpha;\r\n                        bone.scaleY = Math.abs(bone.scaleY) * by + (y - Math.abs(bone.data.scaleY) * by) * alpha;\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n/** Changes a bone's local {@link Bone#shearX} and {@link Bone#shearY}. */\r\n/**\r\n * @public\r\n */\r\nexport class ShearTimeline extends TranslateTimeline {\r\n    constructor (frameCount: number) {\r\n        super(frameCount);\r\n    }\r\n\r\n    getPropertyId () {\r\n        return (TimelineType.shear << 24) + this.boneIndex;\r\n    }\r\n\r\n    apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        let frames = this.frames;\r\n\r\n        let bone = skeleton.bones[this.boneIndex];\r\n        if (!bone.active) return;\r\n        if (time < frames[0]) {\r\n            switch (blend) {\r\n                case MixBlend.setup:\r\n                    bone.shearX = bone.data.shearX;\r\n                    bone.shearY = bone.data.shearY;\r\n                    return;\r\n                case MixBlend.first:\r\n                    bone.shearX += (bone.data.shearX - bone.shearX) * alpha;\r\n                    bone.shearY += (bone.data.shearY - bone.shearY) * alpha;\r\n            }\r\n            return;\r\n        }\r\n\r\n        let x = 0, y = 0;\r\n        if (time >= frames[frames.length - ShearTimeline.ENTRIES]) { // Time is after last frame.\r\n            x = frames[frames.length + ShearTimeline.PREV_X];\r\n            y = frames[frames.length + ShearTimeline.PREV_Y];\r\n        } else {\r\n            // Interpolate between the previous frame and the current frame.\r\n            let frame = Animation.binarySearch(frames, time, ShearTimeline.ENTRIES);\r\n            x = frames[frame + ShearTimeline.PREV_X];\r\n            y = frames[frame + ShearTimeline.PREV_Y];\r\n            let frameTime = frames[frame];\r\n            let percent = this.getCurvePercent(frame / ShearTimeline.ENTRIES - 1,\r\n                1 - (time - frameTime) / (frames[frame + ShearTimeline.PREV_TIME] - frameTime));\r\n\r\n            x = x + (frames[frame + ShearTimeline.X] - x) * percent;\r\n            y = y + (frames[frame + ShearTimeline.Y] - y) * percent;\r\n        }\r\n        switch (blend) {\r\n            case MixBlend.setup:\r\n                bone.shearX = bone.data.shearX + x * alpha;\r\n                bone.shearY = bone.data.shearY + y * alpha;\r\n                break;\r\n            case MixBlend.first:\r\n            case MixBlend.replace:\r\n                bone.shearX += (bone.data.shearX + x - bone.shearX) * alpha;\r\n                bone.shearY += (bone.data.shearY + y - bone.shearY) * alpha;\r\n                break;\r\n            case MixBlend.add:\r\n                bone.shearX += x * alpha;\r\n                bone.shearY += y * alpha;\r\n        }\r\n    }\r\n}\r\n\r\n/** Changes a slot's {@link Slot#color}. */\r\n/**\r\n * @public\r\n */\r\nexport class ColorTimeline extends CurveTimeline {\r\n    static ENTRIES = 5;\r\n    static PREV_TIME = -5; static PREV_R = -4; static PREV_G = -3; static PREV_B = -2; static PREV_A = -1;\r\n    static R = 1; static G = 2; static B = 3; static A = 4;\r\n\r\n    /** The index of the slot in {@link Skeleton#slots} that will be changed. */\r\n    slotIndex: number;\r\n\r\n    /** The time in seconds, red, green, blue, and alpha values for each key frame. */\r\n    frames: ArrayLike<number>; // time, r, g, b, a, ...\r\n\r\n    constructor (frameCount: number) {\r\n        super(frameCount);\r\n        this.frames = Utils.newFloatArray(frameCount * ColorTimeline.ENTRIES);\r\n    }\r\n\r\n    getPropertyId () {\r\n        return (TimelineType.color << 24) + this.slotIndex;\r\n    }\r\n\r\n    /** Sets the time in seconds, red, green, blue, and alpha for the specified key frame. */\r\n    setFrame (frameIndex: number, time: number, r: number, g: number, b: number, a: number) {\r\n        frameIndex *= ColorTimeline.ENTRIES;\r\n        this.frames[frameIndex] = time;\r\n        this.frames[frameIndex + ColorTimeline.R] = r;\r\n        this.frames[frameIndex + ColorTimeline.G] = g;\r\n        this.frames[frameIndex + ColorTimeline.B] = b;\r\n        this.frames[frameIndex + ColorTimeline.A] = a;\r\n    }\r\n\r\n    apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        let slot = skeleton.slots[this.slotIndex];\r\n        if (!slot.bone.active) return;\r\n        let frames = this.frames;\r\n        if (time < frames[0]) {\r\n            switch (blend) {\r\n                case MixBlend.setup:\r\n                    slot.color.setFromColor(slot.data.color);\r\n                    return;\r\n                case MixBlend.first:\r\n                    let color = slot.color, setup = slot.data.color;\r\n                    color.add((setup.r - color.r) * alpha, (setup.g - color.g) * alpha, (setup.b - color.b) * alpha,\r\n                        (setup.a - color.a) * alpha);\r\n            }\r\n            return;\r\n        }\r\n\r\n        let r = 0, g = 0, b = 0, a = 0;\r\n        if (time >= frames[frames.length - ColorTimeline.ENTRIES]) { // Time is after last frame.\r\n            let i = frames.length;\r\n            r = frames[i + ColorTimeline.PREV_R];\r\n            g = frames[i + ColorTimeline.PREV_G];\r\n            b = frames[i + ColorTimeline.PREV_B];\r\n            a = frames[i + ColorTimeline.PREV_A];\r\n        } else {\r\n            // Interpolate between the previous frame and the current frame.\r\n            let frame = Animation.binarySearch(frames, time, ColorTimeline.ENTRIES);\r\n            r = frames[frame + ColorTimeline.PREV_R];\r\n            g = frames[frame + ColorTimeline.PREV_G];\r\n            b = frames[frame + ColorTimeline.PREV_B];\r\n            a = frames[frame + ColorTimeline.PREV_A];\r\n            let frameTime = frames[frame];\r\n            let percent = this.getCurvePercent(frame / ColorTimeline.ENTRIES - 1,\r\n                1 - (time - frameTime) / (frames[frame + ColorTimeline.PREV_TIME] - frameTime));\r\n\r\n            r += (frames[frame + ColorTimeline.R] - r) * percent;\r\n            g += (frames[frame + ColorTimeline.G] - g) * percent;\r\n            b += (frames[frame + ColorTimeline.B] - b) * percent;\r\n            a += (frames[frame + ColorTimeline.A] - a) * percent;\r\n        }\r\n        if (alpha == 1)\r\n            slot.color.set(r, g, b, a);\r\n        else {\r\n            let color = slot.color;\r\n            if (blend == MixBlend.setup) color.setFromColor(slot.data.color);\r\n            color.add((r - color.r) * alpha, (g - color.g) * alpha, (b - color.b) * alpha, (a - color.a) * alpha);\r\n        }\r\n    }\r\n}\r\n\r\n/** Changes a slot's {@link Slot#color} and {@link Slot#darkColor} for two color tinting. */\r\n/**\r\n * @public\r\n */\r\nexport class TwoColorTimeline extends CurveTimeline {\r\n    static ENTRIES = 8;\r\n    static PREV_TIME = -8; static PREV_R = -7; static PREV_G = -6; static PREV_B = -5; static PREV_A = -4;\r\n    static PREV_R2 = -3; static PREV_G2 = -2; static PREV_B2 = -1;\r\n    static R = 1; static G = 2; static B = 3; static A = 4; static R2 = 5; static G2 = 6; static B2 = 7;\r\n\r\n    /** The index of the slot in {@link Skeleton#slots()} that will be changed. The {@link Slot#darkColor()} must not be\r\n     * null. */\r\n    slotIndex: number;\r\n\r\n    /** The time in seconds, red, green, blue, and alpha values of the color, red, green, blue of the dark color, for each key frame. */\r\n    frames: ArrayLike<number>; // time, r, g, b, a, r2, g2, b2, ...\r\n\r\n    constructor (frameCount: number) {\r\n        super(frameCount);\r\n        this.frames = Utils.newFloatArray(frameCount * TwoColorTimeline.ENTRIES);\r\n    }\r\n\r\n    getPropertyId () {\r\n        return (TimelineType.twoColor << 24) + this.slotIndex;\r\n    }\r\n\r\n    /** Sets the time in seconds, light, and dark colors for the specified key frame. */\r\n    setFrame (frameIndex: number, time: number, r: number, g: number, b: number, a: number, r2: number, g2: number, b2: number) {\r\n        frameIndex *= TwoColorTimeline.ENTRIES;\r\n        this.frames[frameIndex] = time;\r\n        this.frames[frameIndex + TwoColorTimeline.R] = r;\r\n        this.frames[frameIndex + TwoColorTimeline.G] = g;\r\n        this.frames[frameIndex + TwoColorTimeline.B] = b;\r\n        this.frames[frameIndex + TwoColorTimeline.A] = a;\r\n        this.frames[frameIndex + TwoColorTimeline.R2] = r2;\r\n        this.frames[frameIndex + TwoColorTimeline.G2] = g2;\r\n        this.frames[frameIndex + TwoColorTimeline.B2] = b2;\r\n    }\r\n\r\n    apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        let slot = skeleton.slots[this.slotIndex];\r\n        if (!slot.bone.active) return;\r\n        let frames = this.frames;\r\n        if (time < frames[0]) {\r\n            switch (blend) {\r\n                case MixBlend.setup:\r\n                    slot.color.setFromColor(slot.data.color);\r\n                    slot.darkColor.setFromColor(slot.data.darkColor);\r\n                    return;\r\n                case MixBlend.first:\r\n                    let light = slot.color, dark = slot.darkColor, setupLight = slot.data.color, setupDark = slot.data.darkColor;\r\n                    light.add((setupLight.r - light.r) * alpha, (setupLight.g - light.g) * alpha, (setupLight.b - light.b) * alpha,\r\n                        (setupLight.a - light.a) * alpha);\r\n                    dark.add((setupDark.r - dark.r) * alpha, (setupDark.g - dark.g) * alpha, (setupDark.b - dark.b) * alpha, 0);\r\n            }\r\n            return;\r\n        }\r\n\r\n        let r = 0, g = 0, b = 0, a = 0, r2 = 0, g2 = 0, b2 = 0;\r\n        if (time >= frames[frames.length - TwoColorTimeline.ENTRIES]) { // Time is after last frame.\r\n            let i = frames.length;\r\n            r = frames[i + TwoColorTimeline.PREV_R];\r\n            g = frames[i + TwoColorTimeline.PREV_G];\r\n            b = frames[i + TwoColorTimeline.PREV_B];\r\n            a = frames[i + TwoColorTimeline.PREV_A];\r\n            r2 = frames[i + TwoColorTimeline.PREV_R2];\r\n            g2 = frames[i + TwoColorTimeline.PREV_G2];\r\n            b2 = frames[i + TwoColorTimeline.PREV_B2];\r\n        } else {\r\n            // Interpolate between the previous frame and the current frame.\r\n            let frame = Animation.binarySearch(frames, time, TwoColorTimeline.ENTRIES);\r\n            r = frames[frame + TwoColorTimeline.PREV_R];\r\n            g = frames[frame + TwoColorTimeline.PREV_G];\r\n            b = frames[frame + TwoColorTimeline.PREV_B];\r\n            a = frames[frame + TwoColorTimeline.PREV_A];\r\n            r2 = frames[frame + TwoColorTimeline.PREV_R2];\r\n            g2 = frames[frame + TwoColorTimeline.PREV_G2];\r\n            b2 = frames[frame + TwoColorTimeline.PREV_B2];\r\n            let frameTime = frames[frame];\r\n            let percent = this.getCurvePercent(frame / TwoColorTimeline.ENTRIES - 1,\r\n                1 - (time - frameTime) / (frames[frame + TwoColorTimeline.PREV_TIME] - frameTime));\r\n\r\n            r += (frames[frame + TwoColorTimeline.R] - r) * percent;\r\n            g += (frames[frame + TwoColorTimeline.G] - g) * percent;\r\n            b += (frames[frame + TwoColorTimeline.B] - b) * percent;\r\n            a += (frames[frame + TwoColorTimeline.A] - a) * percent;\r\n            r2 += (frames[frame + TwoColorTimeline.R2] - r2) * percent;\r\n            g2 += (frames[frame + TwoColorTimeline.G2] - g2) * percent;\r\n            b2 += (frames[frame + TwoColorTimeline.B2] - b2) * percent;\r\n        }\r\n        if (alpha == 1) {\r\n            slot.color.set(r, g, b, a);\r\n            slot.darkColor.set(r2, g2, b2, 1);\r\n        } else {\r\n            let light = slot.color, dark = slot.darkColor;\r\n            if (blend == MixBlend.setup) {\r\n                light.setFromColor(slot.data.color);\r\n                dark.setFromColor(slot.data.darkColor);\r\n            }\r\n            light.add((r - light.r) * alpha, (g - light.g) * alpha, (b - light.b) * alpha, (a - light.a) * alpha);\r\n            dark.add((r2 - dark.r) * alpha, (g2 - dark.g) * alpha, (b2 - dark.b) * alpha, 0);\r\n        }\r\n    }\r\n}\r\n\r\n/** Changes a slot's {@link Slot#attachment}. */\r\n/**\r\n * @public\r\n */\r\nexport class AttachmentTimeline implements Timeline {\r\n    /** The index of the slot in {@link Skeleton#slots} that will be changed. */\r\n    slotIndex: number;\r\n\r\n    /** The time in seconds for each key frame. */\r\n    frames: ArrayLike<number> // time, ...\r\n\r\n    /** The attachment name for each key frame. May contain null values to clear the attachment. */\r\n    attachmentNames: Array<string>;\r\n\r\n    constructor (frameCount: number) {\r\n        this.frames = Utils.newFloatArray(frameCount);\r\n        this.attachmentNames = new Array<string>(frameCount);\r\n    }\r\n\r\n    getPropertyId () {\r\n        return (TimelineType.attachment << 24) + this.slotIndex;\r\n    }\r\n\r\n    /** The number of key frames for this timeline. */\r\n    getFrameCount () {\r\n        return this.frames.length;\r\n    }\r\n\r\n    /** Sets the time in seconds and the attachment name for the specified key frame. */\r\n    setFrame (frameIndex: number, time: number, attachmentName: string) {\r\n        this.frames[frameIndex] = time;\r\n        this.attachmentNames[frameIndex] = attachmentName;\r\n    }\r\n\r\n    apply (skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        let slot = skeleton.slots[this.slotIndex];\r\n        if (!slot.bone.active) return;\r\n        if (direction == MixDirection.mixOut) {\r\n            if (blend == MixBlend.setup)\r\n                this.setAttachment(skeleton, slot, slot.data.attachmentName);\r\n            return;\r\n        }\r\n\r\n        let frames = this.frames;\r\n        if (time < frames[0]) {\r\n            if (blend == MixBlend.setup || blend == MixBlend.first) this.setAttachment(skeleton, slot, slot.data.attachmentName);\r\n            return;\r\n        }\r\n\r\n        let frameIndex = 0;\r\n        if (time >= frames[frames.length - 1]) // Time is after last frame.\r\n            frameIndex = frames.length - 1;\r\n        else\r\n            frameIndex = Animation.binarySearch(frames, time, 1) - 1;\r\n\r\n        let attachmentName = this.attachmentNames[frameIndex];\r\n        skeleton.slots[this.slotIndex]\r\n            .setAttachment(attachmentName == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName));\r\n    }\r\n\r\n    setAttachment(skeleton: Skeleton, slot: Slot, attachmentName: string) {\r\n        slot.setAttachment(attachmentName == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName));\r\n    }\r\n}\r\n\r\nlet zeros : ArrayLike<number> = null;\r\n\r\n/** Changes a slot's {@link Slot#deform} to deform a {@link VertexAttachment}. */\r\n/**\r\n * @public\r\n */\r\nexport class DeformTimeline extends CurveTimeline {\r\n    /** The index of the slot in {@link Skeleton#getSlots()} that will be changed. */\r\n    slotIndex: number;\r\n\r\n    /** The attachment that will be deformed. */\r\n    attachment: VertexAttachment;\r\n\r\n    /** The time in seconds for each key frame. */\r\n    frames: ArrayLike<number>; // time, ...\r\n\r\n    /** The vertices for each key frame. */\r\n    frameVertices: Array<ArrayLike<number>>;\r\n\r\n    constructor (frameCount: number) {\r\n        super(frameCount);\r\n        this.frames = Utils.newFloatArray(frameCount);\r\n        this.frameVertices = new Array<ArrayLike<number>>(frameCount);\r\n        if (zeros == null) zeros = Utils.newFloatArray(64);\r\n    }\r\n\r\n    getPropertyId () {\r\n        return (TimelineType.deform << 27) + + this.attachment.id + this.slotIndex;\r\n    }\r\n\r\n    /** Sets the time in seconds and the vertices for the specified key frame.\r\n     * @param vertices Vertex positions for an unweighted VertexAttachment, or deform offsets if it has weights. */\r\n    setFrame (frameIndex: number, time: number, vertices: ArrayLike<number>) {\r\n        this.frames[frameIndex] = time;\r\n        this.frameVertices[frameIndex] = vertices;\r\n    }\r\n\r\n    apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        let slot: Slot = skeleton.slots[this.slotIndex];\r\n        if (!slot.bone.active) return;\r\n        let slotAttachment: Attachment = slot.getAttachment();\r\n        if (!(slotAttachment instanceof VertexAttachment) || !((<VertexAttachment>slotAttachment).deformAttachment == this.attachment)) return;\r\n\r\n        let deformArray: Array<number> = slot.deform;\r\n        if (deformArray.length == 0) blend = MixBlend.setup;\r\n\r\n        let frameVertices = this.frameVertices;\r\n        let vertexCount = frameVertices[0].length;\r\n\r\n        let frames = this.frames;\r\n        if (time < frames[0]) {\r\n            let vertexAttachment = <VertexAttachment>slotAttachment;\r\n            switch (blend) {\r\n                case MixBlend.setup:\r\n                    deformArray.length = 0;\r\n                    return;\r\n                case MixBlend.first:\r\n                    if (alpha == 1) {\r\n                        deformArray.length = 0;\r\n                        break;\r\n                    }\r\n                    let deform: Array<number> = Utils.setArraySize(deformArray, vertexCount);\r\n                    if (vertexAttachment.bones == null) {\r\n                        // Unweighted vertex positions.\r\n                        let setupVertices = vertexAttachment.vertices;\r\n                        for (var i = 0; i < vertexCount; i++)\r\n                            deform[i] += (setupVertices[i] - deform[i]) * alpha;\r\n                    } else {\r\n                        // Weighted deform offsets.\r\n                        alpha = 1 - alpha;\r\n                        for (var i = 0; i < vertexCount; i++)\r\n                            deform[i] *= alpha;\r\n                    }\r\n            }\r\n            return;\r\n        }\r\n\r\n        let deform: Array<number> = Utils.setArraySize(deformArray, vertexCount);\r\n        if (time >= frames[frames.length - 1]) { // Time is after last frame.\r\n            let lastVertices = frameVertices[frames.length - 1];\r\n            if (alpha == 1) {\r\n                if (blend == MixBlend.add) {\r\n                    let vertexAttachment = slotAttachment as VertexAttachment;\r\n                    if (vertexAttachment.bones == null) {\r\n                        // Unweighted vertex positions, with alpha.\r\n                        let setupVertices = vertexAttachment.vertices;\r\n                        for (let i = 0; i < vertexCount; i++) {\r\n                            deform[i] += lastVertices[i] - setupVertices[i];\r\n                        }\r\n                    } else {\r\n                        // Weighted deform offsets, with alpha.\r\n                        for (let i = 0; i < vertexCount; i++)\r\n                            deform[i] += lastVertices[i];\r\n                    }\r\n                } else {\r\n                    Utils.arrayCopy(lastVertices, 0, deform, 0, vertexCount);\r\n                }\r\n            } else {\r\n                switch (blend) {\r\n                    case MixBlend.setup: {\r\n                        let vertexAttachment = slotAttachment as VertexAttachment;\r\n                        if (vertexAttachment.bones == null) {\r\n                            // Unweighted vertex positions, with alpha.\r\n                            let setupVertices = vertexAttachment.vertices;\r\n                            for (let i = 0; i < vertexCount; i++) {\r\n                                let setup = setupVertices[i];\r\n                                deform[i] = setup + (lastVertices[i] - setup) * alpha;\r\n                            }\r\n                        } else {\r\n                            // Weighted deform offsets, with alpha.\r\n                            for (let i = 0; i < vertexCount; i++)\r\n                                deform[i] = lastVertices[i] * alpha;\r\n                        }\r\n                        break;\r\n                    }\r\n                    case MixBlend.first:\r\n                    case MixBlend.replace:\r\n                        for (let i = 0; i < vertexCount; i++)\r\n                            deform[i] += (lastVertices[i] - deform[i]) * alpha;\r\n                        break;\r\n                    case MixBlend.add:\r\n                        let vertexAttachment = slotAttachment as VertexAttachment;\r\n                        if (vertexAttachment.bones == null) {\r\n                            // Unweighted vertex positions, with alpha.\r\n                            let setupVertices = vertexAttachment.vertices;\r\n                            for (let i = 0; i < vertexCount; i++) {\r\n                                deform[i] += (lastVertices[i] - setupVertices[i]) * alpha;\r\n                            }\r\n                        } else {\r\n                            // Weighted deform offsets, with alpha.\r\n                            for (let i = 0; i < vertexCount; i++)\r\n                                deform[i] += lastVertices[i] * alpha;\r\n                        }\r\n                }\r\n            }\r\n            return;\r\n        }\r\n\r\n        // Interpolate between the previous frame and the current frame.\r\n        let frame = Animation.binarySearch(frames, time);\r\n        let prevVertices = frameVertices[frame - 1];\r\n        let nextVertices = frameVertices[frame];\r\n        let frameTime = frames[frame];\r\n        let percent = this.getCurvePercent(frame - 1, 1 - (time - frameTime) / (frames[frame - 1] - frameTime));\r\n\r\n        if (alpha == 1) {\r\n            if (blend == MixBlend.add) {\r\n                let vertexAttachment = slotAttachment as VertexAttachment;\r\n                if (vertexAttachment.bones == null) {\r\n                    // Unweighted vertex positions, with alpha.\r\n                    let setupVertices = vertexAttachment.vertices;\r\n                    for (let i = 0; i < vertexCount; i++) {\r\n                        let prev = prevVertices[i];\r\n                        deform[i] += prev + (nextVertices[i] - prev) * percent - setupVertices[i];\r\n                    }\r\n                } else {\r\n                    // Weighted deform offsets, with alpha.\r\n                    for (let i = 0; i < vertexCount; i++) {\r\n                        let prev = prevVertices[i];\r\n                        deform[i] += prev + (nextVertices[i] - prev) * percent;\r\n                    }\r\n                }\r\n            } else {\r\n                for (let i = 0; i < vertexCount; i++) {\r\n                    let prev = prevVertices[i];\r\n                    deform[i] = prev + (nextVertices[i] - prev) * percent;\r\n                }\r\n            }\r\n        } else {\r\n            switch (blend) {\r\n                case MixBlend.setup: {\r\n                    let vertexAttachment = slotAttachment as VertexAttachment;\r\n                    if (vertexAttachment.bones == null) {\r\n                        // Unweighted vertex positions, with alpha.\r\n                        let setupVertices = vertexAttachment.vertices;\r\n                        for (let i = 0; i < vertexCount; i++) {\r\n                            let prev = prevVertices[i], setup = setupVertices[i];\r\n                            deform[i] = setup + (prev + (nextVertices[i] - prev) * percent - setup) * alpha;\r\n                        }\r\n                    } else {\r\n                        // Weighted deform offsets, with alpha.\r\n                        for (let i = 0; i < vertexCount; i++) {\r\n                            let prev = prevVertices[i];\r\n                            deform[i] = (prev + (nextVertices[i] - prev) * percent) * alpha;\r\n                        }\r\n                    }\r\n                    break;\r\n                }\r\n                case MixBlend.first:\r\n                case MixBlend.replace:\r\n                    for (let i = 0; i < vertexCount; i++) {\r\n                        let prev = prevVertices[i];\r\n                        deform[i] += (prev + (nextVertices[i] - prev) * percent - deform[i]) * alpha;\r\n                    }\r\n                    break;\r\n                case MixBlend.add:\r\n                    let vertexAttachment = slotAttachment as VertexAttachment;\r\n                    if (vertexAttachment.bones == null) {\r\n                        // Unweighted vertex positions, with alpha.\r\n                        let setupVertices = vertexAttachment.vertices;\r\n                        for (let i = 0; i < vertexCount; i++) {\r\n                            let prev = prevVertices[i];\r\n                            deform[i] += (prev + (nextVertices[i] - prev) * percent - setupVertices[i]) * alpha;\r\n                        }\r\n                    } else {\r\n                        // Weighted deform offsets, with alpha.\r\n                        for (let i = 0; i < vertexCount; i++) {\r\n                            let prev = prevVertices[i];\r\n                            deform[i] += (prev + (nextVertices[i] - prev) * percent) * alpha;\r\n                        }\r\n                    }\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n/** Fires an {@link Event} when specific animation times are reached. */\r\n/**\r\n * @public\r\n */\r\nexport class EventTimeline implements Timeline {\r\n    /** The time in seconds for each key frame. */\r\n    frames: ArrayLike<number>; // time, ...\r\n\r\n    /** The event for each key frame. */\r\n    events: Array<Event>;\r\n\r\n    constructor (frameCount: number) {\r\n        this.frames = Utils.newFloatArray(frameCount);\r\n        this.events = new Array<Event>(frameCount);\r\n    }\r\n\r\n    getPropertyId () {\r\n        return TimelineType.event << 24;\r\n    }\r\n\r\n    /** The number of key frames for this timeline. */\r\n    getFrameCount () {\r\n        return this.frames.length;\r\n    }\r\n\r\n    /** Sets the time in seconds and the event for the specified key frame. */\r\n    setFrame (frameIndex: number, event: Event) {\r\n        this.frames[frameIndex] = event.time;\r\n        this.events[frameIndex] = event;\r\n    }\r\n\r\n    /** Fires events for frames > `lastTime` and <= `time`. */\r\n    apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        if (firedEvents == null) return;\r\n        let frames = this.frames;\r\n        let frameCount = this.frames.length;\r\n\r\n        if (lastTime > time) { // Fire events after last time for looped animations.\r\n            this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, blend, direction);\r\n            lastTime = -1;\r\n        } else if (lastTime >= frames[frameCount - 1]) // Last time is after last frame.\r\n            return;\r\n        if (time < frames[0]) return; // Time is before first frame.\r\n\r\n        let frame = 0;\r\n        if (lastTime < frames[0])\r\n            frame = 0;\r\n        else {\r\n            frame = Animation.binarySearch(frames, lastTime);\r\n            let frameTime = frames[frame];\r\n            while (frame > 0) { // Fire multiple events with the same frame.\r\n                if (frames[frame - 1] != frameTime) break;\r\n                frame--;\r\n            }\r\n        }\r\n        for (; frame < frameCount && time >= frames[frame]; frame++)\r\n            firedEvents.push(this.events[frame]);\r\n    }\r\n}\r\n\r\n/** Changes a skeleton's {@link Skeleton#drawOrder}. */\r\n/**\r\n * @public\r\n */\r\nexport class DrawOrderTimeline implements Timeline {\r\n    /** The time in seconds for each key frame. */\r\n    frames: ArrayLike<number>; // time, ...\r\n\r\n    /** The draw order for each key frame. See {@link #setFrame(int, float, int[])}. */\r\n    drawOrders: Array<Array<number>>;\r\n\r\n    constructor (frameCount: number) {\r\n        this.frames = Utils.newFloatArray(frameCount);\r\n        this.drawOrders = new Array<Array<number>>(frameCount);\r\n    }\r\n\r\n    getPropertyId () {\r\n        return TimelineType.drawOrder << 24;\r\n    }\r\n\r\n    /** The number of key frames for this timeline. */\r\n    getFrameCount () {\r\n        return this.frames.length;\r\n    }\r\n\r\n    /** Sets the time in seconds and the draw order for the specified key frame.\r\n     * @param drawOrder For each slot in {@link Skeleton#slots}, the index of the new draw order. May be null to use setup pose\r\n     *           draw order. */\r\n    setFrame (frameIndex: number, time: number, drawOrder: Array<number>) {\r\n        this.frames[frameIndex] = time;\r\n        this.drawOrders[frameIndex] = drawOrder;\r\n    }\r\n\r\n    apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        let drawOrder: Array<Slot> = skeleton.drawOrder;\r\n        let slots: Array<Slot> = skeleton.slots;\r\n        if (direction == MixDirection.mixOut && blend == MixBlend.setup) {\r\n            Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);\r\n            return;\r\n        }\r\n\r\n        let frames = this.frames;\r\n        if (time < frames[0]) {\r\n            if (blend == MixBlend.setup || blend == MixBlend.first) Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);\r\n            return;\r\n        }\r\n\r\n        let frame = 0;\r\n        if (time >= frames[frames.length - 1]) // Time is after last frame.\r\n            frame = frames.length - 1;\r\n        else\r\n            frame = Animation.binarySearch(frames, time) - 1;\r\n\r\n        let drawOrderToSetupIndex = this.drawOrders[frame];\r\n        if (drawOrderToSetupIndex == null)\r\n            Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length);\r\n        else {\r\n            for (let i = 0, n = drawOrderToSetupIndex.length; i < n; i++)\r\n                drawOrder[i] = slots[drawOrderToSetupIndex[i]];\r\n        }\r\n    }\r\n}\r\n\r\n/** Changes an IK constraint's {@link IkConstraint#mix}, {@link IkConstraint#softness},\r\n * {@link IkConstraint#bendDirection}, {@link IkConstraint#stretch}, and {@link IkConstraint#compress}. */\r\n/**\r\n * @public\r\n */\r\nexport class IkConstraintTimeline extends CurveTimeline {\r\n    static ENTRIES = 6;\r\n    static PREV_TIME = -6; static PREV_MIX = -5; static PREV_SOFTNESS = -4; static PREV_BEND_DIRECTION = -3; static PREV_COMPRESS = -2; static PREV_STRETCH = -1;\r\n    static MIX = 1; static SOFTNESS = 2; static BEND_DIRECTION = 3; static COMPRESS = 4; static STRETCH = 5;\r\n\r\n    /** The index of the IK constraint slot in {@link Skeleton#ikConstraints} that will be changed. */\r\n    ikConstraintIndex: number;\r\n\r\n    /** The time in seconds, mix, softness, bend direction, compress, and stretch for each key frame. */\r\n    frames: ArrayLike<number>; // time, mix, softness, bendDirection, compress, stretch, ...\r\n\r\n    constructor (frameCount: number) {\r\n        super(frameCount);\r\n        this.frames = Utils.newFloatArray(frameCount * IkConstraintTimeline.ENTRIES);\r\n    }\r\n\r\n    getPropertyId () {\r\n        return (TimelineType.ikConstraint << 24) + this.ikConstraintIndex;\r\n    }\r\n\r\n    /** Sets the time in seconds, mix, softness, bend direction, compress, and stretch for the specified key frame. */\r\n    setFrame (frameIndex: number, time: number, mix: number, softness: number, bendDirection: number, compress: boolean, stretch: boolean) {\r\n        frameIndex *= IkConstraintTimeline.ENTRIES;\r\n        this.frames[frameIndex] = time;\r\n        this.frames[frameIndex + IkConstraintTimeline.MIX] = mix;\r\n        this.frames[frameIndex + IkConstraintTimeline.SOFTNESS] = softness;\r\n        this.frames[frameIndex + IkConstraintTimeline.BEND_DIRECTION] = bendDirection;\r\n        this.frames[frameIndex + IkConstraintTimeline.COMPRESS] = compress ? 1 : 0;\r\n        this.frames[frameIndex + IkConstraintTimeline.STRETCH] = stretch ? 1 : 0;\r\n    }\r\n\r\n    apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        let frames = this.frames;\r\n        let constraint: IkConstraint = skeleton.ikConstraints[this.ikConstraintIndex];\r\n        if (!constraint.active) return;\r\n        if (time < frames[0]) {\r\n            switch (blend) {\r\n                case MixBlend.setup:\r\n                    constraint.mix = constraint.data.mix;\r\n                    constraint.softness = constraint.data.softness;\r\n                    constraint.bendDirection = constraint.data.bendDirection;\r\n                    constraint.compress = constraint.data.compress;\r\n                    constraint.stretch = constraint.data.stretch;\r\n                    return;\r\n                case MixBlend.first:\r\n                    constraint.mix += (constraint.data.mix - constraint.mix) * alpha;\r\n                    constraint.softness += (constraint.data.softness - constraint.softness) * alpha;\r\n                    constraint.bendDirection = constraint.data.bendDirection;\r\n                    constraint.compress = constraint.data.compress;\r\n                    constraint.stretch = constraint.data.stretch;\r\n            }\r\n            return;\r\n        }\r\n\r\n        if (time >= frames[frames.length - IkConstraintTimeline.ENTRIES]) { // Time is after last frame.\r\n            if (blend == MixBlend.setup) {\r\n                constraint.mix = constraint.data.mix + (frames[frames.length + IkConstraintTimeline.PREV_MIX] - constraint.data.mix) * alpha;\r\n                constraint.softness = constraint.data.softness\r\n                    + (frames[frames.length + IkConstraintTimeline.PREV_SOFTNESS] - constraint.data.softness) * alpha;\r\n                if (direction == MixDirection.mixOut) {\r\n                    constraint.bendDirection = constraint.data.bendDirection;\r\n                    constraint.compress = constraint.data.compress;\r\n                    constraint.stretch = constraint.data.stretch;\r\n                } else {\r\n                    constraint.bendDirection = frames[frames.length + IkConstraintTimeline.PREV_BEND_DIRECTION]\r\n                    constraint.compress = frames[frames.length + IkConstraintTimeline.PREV_COMPRESS] != 0;\r\n                    constraint.stretch = frames[frames.length + IkConstraintTimeline.PREV_STRETCH] != 0;\r\n                }\r\n            } else {\r\n                constraint.mix += (frames[frames.length + IkConstraintTimeline.PREV_MIX] - constraint.mix) * alpha;\r\n                constraint.softness += (frames[frames.length + IkConstraintTimeline.PREV_SOFTNESS] - constraint.softness) * alpha;\r\n                if (direction == MixDirection.mixIn) {\r\n                    constraint.bendDirection = frames[frames.length + IkConstraintTimeline.PREV_BEND_DIRECTION];\r\n                    constraint.compress = frames[frames.length + IkConstraintTimeline.PREV_COMPRESS] != 0;\r\n                    constraint.stretch = frames[frames.length + IkConstraintTimeline.PREV_STRETCH] != 0;\r\n                }\r\n            }\r\n            return;\r\n        }\r\n\r\n        // Interpolate between the previous frame and the current frame.\r\n        let frame = Animation.binarySearch(frames, time, IkConstraintTimeline.ENTRIES);\r\n        let mix = frames[frame + IkConstraintTimeline.PREV_MIX];\r\n        let softness = frames[frame + IkConstraintTimeline.PREV_SOFTNESS];\r\n        let frameTime = frames[frame];\r\n        let percent = this.getCurvePercent(frame / IkConstraintTimeline.ENTRIES - 1,\r\n            1 - (time - frameTime) / (frames[frame + IkConstraintTimeline.PREV_TIME] - frameTime));\r\n\r\n        if (blend == MixBlend.setup) {\r\n            constraint.mix = constraint.data.mix + (mix + (frames[frame + IkConstraintTimeline.MIX] - mix) * percent - constraint.data.mix) * alpha;\r\n            constraint.softness = constraint.data.softness\r\n                + (softness + (frames[frame + IkConstraintTimeline.SOFTNESS] - softness) * percent - constraint.data.softness) * alpha;\r\n            if (direction == MixDirection.mixOut) {\r\n                constraint.bendDirection = constraint.data.bendDirection;\r\n                constraint.compress = constraint.data.compress;\r\n                constraint.stretch = constraint.data.stretch;\r\n            } else {\r\n                constraint.bendDirection = frames[frame + IkConstraintTimeline.PREV_BEND_DIRECTION];\r\n                constraint.compress = frames[frame + IkConstraintTimeline.PREV_COMPRESS] != 0;\r\n                constraint.stretch = frames[frame + IkConstraintTimeline.PREV_STRETCH] != 0;\r\n            }\r\n        } else {\r\n            constraint.mix += (mix + (frames[frame + IkConstraintTimeline.MIX] - mix) * percent - constraint.mix) * alpha;\r\n            constraint.softness += (softness + (frames[frame + IkConstraintTimeline.SOFTNESS] - softness) * percent - constraint.softness) * alpha;\r\n            if (direction == MixDirection.mixIn) {\r\n                constraint.bendDirection = frames[frame + IkConstraintTimeline.PREV_BEND_DIRECTION];\r\n                constraint.compress = frames[frame + IkConstraintTimeline.PREV_COMPRESS] != 0;\r\n                constraint.stretch = frames[frame + IkConstraintTimeline.PREV_STRETCH] != 0;\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\n/** Changes a transform constraint's {@link TransformConstraint#rotateMix}, {@link TransformConstraint#translateMix},\r\n * {@link TransformConstraint#scaleMix}, and {@link TransformConstraint#shearMix}. */\r\n/**\r\n * @public\r\n */\r\nexport class TransformConstraintTimeline extends CurveTimeline {\r\n    static ENTRIES = 5;\r\n    static PREV_TIME = -5; static PREV_ROTATE = -4; static PREV_TRANSLATE = -3; static PREV_SCALE = -2; static PREV_SHEAR = -1;\r\n    static ROTATE = 1; static TRANSLATE = 2; static SCALE = 3; static SHEAR = 4;\r\n\r\n    /** The index of the transform constraint slot in {@link Skeleton#transformConstraints} that will be changed. */\r\n    transformConstraintIndex: number;\r\n\r\n    /** The time in seconds, rotate mix, translate mix, scale mix, and shear mix for each key frame. */\r\n    frames: ArrayLike<number>; // time, rotate mix, translate mix, scale mix, shear mix, ...\r\n\r\n    constructor (frameCount: number) {\r\n        super(frameCount);\r\n        this.frames = Utils.newFloatArray(frameCount * TransformConstraintTimeline.ENTRIES);\r\n    }\r\n\r\n    getPropertyId () {\r\n        return (TimelineType.transformConstraint << 24) + this.transformConstraintIndex;\r\n    }\r\n\r\n    /** The time in seconds, rotate mix, translate mix, scale mix, and shear mix for the specified key frame. */\r\n    setFrame (frameIndex: number, time: number, rotateMix: number, translateMix: number, scaleMix: number, shearMix: number) {\r\n        frameIndex *= TransformConstraintTimeline.ENTRIES;\r\n        this.frames[frameIndex] = time;\r\n        this.frames[frameIndex + TransformConstraintTimeline.ROTATE] = rotateMix;\r\n        this.frames[frameIndex + TransformConstraintTimeline.TRANSLATE] = translateMix;\r\n        this.frames[frameIndex + TransformConstraintTimeline.SCALE] = scaleMix;\r\n        this.frames[frameIndex + TransformConstraintTimeline.SHEAR] = shearMix;\r\n    }\r\n\r\n    apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        let frames = this.frames;\r\n\r\n        let constraint: TransformConstraint = skeleton.transformConstraints[this.transformConstraintIndex];\r\n        if (!constraint.active) return;\r\n        if (time < frames[0]) {\r\n            let data = constraint.data;\r\n            switch (blend) {\r\n                case MixBlend.setup:\r\n                    constraint.rotateMix = data.rotateMix;\r\n                    constraint.translateMix = data.translateMix;\r\n                    constraint.scaleMix = data.scaleMix;\r\n                    constraint.shearMix = data.shearMix;\r\n                    return;\r\n                case MixBlend.first:\r\n                    constraint.rotateMix += (data.rotateMix - constraint.rotateMix) * alpha;\r\n                    constraint.translateMix += (data.translateMix - constraint.translateMix) * alpha;\r\n                    constraint.scaleMix += (data.scaleMix - constraint.scaleMix) * alpha;\r\n                    constraint.shearMix += (data.shearMix - constraint.shearMix) * alpha;\r\n            }\r\n            return;\r\n        }\r\n\r\n        let rotate = 0, translate = 0, scale = 0, shear = 0;\r\n        if (time >= frames[frames.length - TransformConstraintTimeline.ENTRIES]) { // Time is after last frame.\r\n            let i = frames.length;\r\n            rotate = frames[i + TransformConstraintTimeline.PREV_ROTATE];\r\n            translate = frames[i + TransformConstraintTimeline.PREV_TRANSLATE];\r\n            scale = frames[i + TransformConstraintTimeline.PREV_SCALE];\r\n            shear = frames[i + TransformConstraintTimeline.PREV_SHEAR];\r\n        } else {\r\n            // Interpolate between the previous frame and the current frame.\r\n            let frame = Animation.binarySearch(frames, time, TransformConstraintTimeline.ENTRIES);\r\n            rotate = frames[frame + TransformConstraintTimeline.PREV_ROTATE];\r\n            translate = frames[frame + TransformConstraintTimeline.PREV_TRANSLATE];\r\n            scale = frames[frame + TransformConstraintTimeline.PREV_SCALE];\r\n            shear = frames[frame + TransformConstraintTimeline.PREV_SHEAR];\r\n            let frameTime = frames[frame];\r\n            let percent = this.getCurvePercent(frame / TransformConstraintTimeline.ENTRIES - 1,\r\n                1 - (time - frameTime) / (frames[frame + TransformConstraintTimeline.PREV_TIME] - frameTime));\r\n\r\n            rotate += (frames[frame + TransformConstraintTimeline.ROTATE] - rotate) * percent;\r\n            translate += (frames[frame + TransformConstraintTimeline.TRANSLATE] - translate) * percent;\r\n            scale += (frames[frame + TransformConstraintTimeline.SCALE] - scale) * percent;\r\n            shear += (frames[frame + TransformConstraintTimeline.SHEAR] - shear) * percent;\r\n        }\r\n        if (blend == MixBlend.setup) {\r\n            let data = constraint.data;\r\n            constraint.rotateMix = data.rotateMix + (rotate - data.rotateMix) * alpha;\r\n            constraint.translateMix = data.translateMix + (translate - data.translateMix) * alpha;\r\n            constraint.scaleMix = data.scaleMix + (scale - data.scaleMix) * alpha;\r\n            constraint.shearMix = data.shearMix + (shear - data.shearMix) * alpha;\r\n        } else {\r\n            constraint.rotateMix += (rotate - constraint.rotateMix) * alpha;\r\n            constraint.translateMix += (translate - constraint.translateMix) * alpha;\r\n            constraint.scaleMix += (scale - constraint.scaleMix) * alpha;\r\n            constraint.shearMix += (shear - constraint.shearMix) * alpha;\r\n        }\r\n    }\r\n}\r\n\r\n/** Changes a path constraint's {@link PathConstraint#position}. */\r\n/**\r\n * @public\r\n */\r\nexport class PathConstraintPositionTimeline extends CurveTimeline {\r\n    static ENTRIES = 2;\r\n    static PREV_TIME = -2; static PREV_VALUE = -1;\r\n    static VALUE = 1;\r\n\r\n    /** The index of the path constraint slot in {@link Skeleton#pathConstraints} that will be changed. */\r\n    pathConstraintIndex: number;\r\n\r\n    /** The time in seconds and path constraint position for each key frame. */\r\n    frames: ArrayLike<number>; // time, position, ...\r\n\r\n    constructor (frameCount: number) {\r\n        super(frameCount);\r\n        this.frames = Utils.newFloatArray(frameCount * PathConstraintPositionTimeline.ENTRIES);\r\n    }\r\n\r\n    getPropertyId () {\r\n        return (TimelineType.pathConstraintPosition << 24) + this.pathConstraintIndex;\r\n    }\r\n\r\n    /** Sets the time in seconds and path constraint position for the specified key frame. */\r\n    setFrame (frameIndex: number, time: number, value: number) {\r\n        frameIndex *= PathConstraintPositionTimeline.ENTRIES;\r\n        this.frames[frameIndex] = time;\r\n        this.frames[frameIndex + PathConstraintPositionTimeline.VALUE] = value;\r\n    }\r\n\r\n    apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        let frames = this.frames;\r\n        let constraint: PathConstraint = skeleton.pathConstraints[this.pathConstraintIndex];\r\n        if (!constraint.active) return;\r\n        if (time < frames[0]) {\r\n            switch (blend) {\r\n                case MixBlend.setup:\r\n                    constraint.position = constraint.data.position;\r\n                    return;\r\n                case MixBlend.first:\r\n                    constraint.position += (constraint.data.position - constraint.position) * alpha;\r\n            }\r\n            return;\r\n        }\r\n\r\n        let position = 0;\r\n        if (time >= frames[frames.length - PathConstraintPositionTimeline.ENTRIES]) // Time is after last frame.\r\n            position = frames[frames.length + PathConstraintPositionTimeline.PREV_VALUE];\r\n        else {\r\n            // Interpolate between the previous frame and the current frame.\r\n            let frame = Animation.binarySearch(frames, time, PathConstraintPositionTimeline.ENTRIES);\r\n            position = frames[frame + PathConstraintPositionTimeline.PREV_VALUE];\r\n            let frameTime = frames[frame];\r\n            let percent = this.getCurvePercent(frame / PathConstraintPositionTimeline.ENTRIES - 1,\r\n                1 - (time - frameTime) / (frames[frame + PathConstraintPositionTimeline.PREV_TIME] - frameTime));\r\n\r\n            position += (frames[frame + PathConstraintPositionTimeline.VALUE] - position) * percent;\r\n        }\r\n        if (blend == MixBlend.setup)\r\n            constraint.position = constraint.data.position + (position - constraint.data.position) * alpha;\r\n        else\r\n            constraint.position += (position - constraint.position) * alpha;\r\n    }\r\n}\r\n\r\n/** Changes a path constraint's {@link PathConstraint#spacing}. */\r\n/**\r\n * @public\r\n */\r\nexport class PathConstraintSpacingTimeline extends PathConstraintPositionTimeline {\r\n    constructor (frameCount: number) {\r\n        super(frameCount);\r\n    }\r\n\r\n    getPropertyId () {\r\n        return (TimelineType.pathConstraintSpacing << 24) + this.pathConstraintIndex;\r\n    }\r\n\r\n    apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        let frames = this.frames;\r\n        let constraint: PathConstraint = skeleton.pathConstraints[this.pathConstraintIndex];\r\n        if (!constraint.active) return;\r\n        if (time < frames[0]) {\r\n            switch (blend) {\r\n                case MixBlend.setup:\r\n                    constraint.spacing = constraint.data.spacing;\r\n                    return;\r\n                case MixBlend.first:\r\n                    constraint.spacing += (constraint.data.spacing - constraint.spacing) * alpha;\r\n            }\r\n            return;\r\n        }\r\n\r\n        let spacing = 0;\r\n        if (time >= frames[frames.length - PathConstraintSpacingTimeline.ENTRIES]) // Time is after last frame.\r\n            spacing = frames[frames.length + PathConstraintSpacingTimeline.PREV_VALUE];\r\n        else {\r\n            // Interpolate between the previous frame and the current frame.\r\n            let frame = Animation.binarySearch(frames, time, PathConstraintSpacingTimeline.ENTRIES);\r\n            spacing = frames[frame + PathConstraintSpacingTimeline.PREV_VALUE];\r\n            let frameTime = frames[frame];\r\n            let percent = this.getCurvePercent(frame / PathConstraintSpacingTimeline.ENTRIES - 1,\r\n                1 - (time - frameTime) / (frames[frame + PathConstraintSpacingTimeline.PREV_TIME] - frameTime));\r\n\r\n            spacing += (frames[frame + PathConstraintSpacingTimeline.VALUE] - spacing) * percent;\r\n        }\r\n\r\n        if (blend == MixBlend.setup)\r\n            constraint.spacing = constraint.data.spacing + (spacing - constraint.data.spacing) * alpha;\r\n        else\r\n            constraint.spacing += (spacing - constraint.spacing) * alpha;\r\n    }\r\n}\r\n\r\n/** Changes a transform constraint's {@link PathConstraint#rotateMix} and\r\n * {@link TransformConstraint#translateMix}. */\r\n/**\r\n * @public\r\n */\r\nexport class PathConstraintMixTimeline extends CurveTimeline {\r\n    static ENTRIES = 3;\r\n    static PREV_TIME = -3; static PREV_ROTATE = -2; static PREV_TRANSLATE = -1;\r\n    static ROTATE = 1; static TRANSLATE = 2;\r\n\r\n    /** The index of the path constraint slot in {@link Skeleton#getPathConstraints()} that will be changed. */\r\n    pathConstraintIndex: number;\r\n\r\n    /** The time in seconds, rotate mix, and translate mix for each key frame. */\r\n    frames: ArrayLike<number>; // time, rotate mix, translate mix, ...\r\n\r\n    constructor (frameCount: number) {\r\n        super(frameCount);\r\n        this.frames = Utils.newFloatArray(frameCount * PathConstraintMixTimeline.ENTRIES);\r\n    }\r\n\r\n    getPropertyId () {\r\n        return (TimelineType.pathConstraintMix << 24) + this.pathConstraintIndex;\r\n    }\r\n\r\n    /** The time in seconds, rotate mix, and translate mix for the specified key frame. */\r\n    setFrame (frameIndex: number, time: number, rotateMix: number, translateMix: number) {\r\n        frameIndex *= PathConstraintMixTimeline.ENTRIES;\r\n        this.frames[frameIndex] = time;\r\n        this.frames[frameIndex + PathConstraintMixTimeline.ROTATE] = rotateMix;\r\n        this.frames[frameIndex + PathConstraintMixTimeline.TRANSLATE] = translateMix;\r\n    }\r\n\r\n    apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {\r\n        let frames = this.frames;\r\n        let constraint: PathConstraint = skeleton.pathConstraints[this.pathConstraintIndex];\r\n        if (!constraint.active) return;\r\n        if (time < frames[0]) {\r\n            switch (blend) {\r\n                case MixBlend.setup:\r\n                    constraint.rotateMix = constraint.data.rotateMix;\r\n                    constraint.translateMix = constraint.data.translateMix;\r\n                    return;\r\n                case MixBlend.first:\r\n                    constraint.rotateMix += (constraint.data.rotateMix - constraint.rotateMix) * alpha;\r\n                    constraint.translateMix += (constraint.data.translateMix - constraint.translateMix) * alpha;\r\n            }\r\n            return;\r\n        }\r\n\r\n        let rotate = 0, translate = 0;\r\n        if (time >= frames[frames.length - PathConstraintMixTimeline.ENTRIES]) { // Time is after last frame.\r\n            rotate = frames[frames.length + PathConstraintMixTimeline.PREV_ROTATE];\r\n            translate = frames[frames.length + PathConstraintMixTimeline.PREV_TRANSLATE];\r\n        } else {\r\n            // Interpolate between the previous frame and the current frame.\r\n            let frame = Animation.binarySearch(frames, time, PathConstraintMixTimeline.ENTRIES);\r\n            rotate = frames[frame + PathConstraintMixTimeline.PREV_ROTATE];\r\n            translate = frames[frame + PathConstraintMixTimeline.PREV_TRANSLATE];\r\n            let frameTime = frames[frame];\r\n            let percent = this.getCurvePercent(frame / PathConstraintMixTimeline.ENTRIES - 1,\r\n                1 - (time - frameTime) / (frames[frame + PathConstraintMixTimeline.PREV_TIME] - frameTime));\r\n\r\n            rotate += (frames[frame + PathConstraintMixTimeline.ROTATE] - rotate) * percent;\r\n            translate += (frames[frame + PathConstraintMixTimeline.TRANSLATE] - translate) * percent;\r\n        }\r\n\r\n        if (blend == MixBlend.setup) {\r\n            constraint.rotateMix = constraint.data.rotateMix + (rotate - constraint.data.rotateMix) * alpha;\r\n            constraint.translateMix = constraint.data.translateMix + (translate - constraint.data.translateMix) * alpha;\r\n        } else {\r\n            constraint.rotateMix += (rotate - constraint.rotateMix) * alpha;\r\n            constraint.translateMix += (translate - constraint.translateMix) * alpha;\r\n        }\r\n    }\r\n}\r\n","import {AttachmentType, Utils} from '@pixi-spine/base';\r\nimport type {IAttachment, ArrayLike} from '@pixi-spine/base';\r\n\r\nimport type {Slot} from '../Slot';\r\n\r\n/**\r\n * @public\r\n */\r\nexport abstract class Attachment implements IAttachment {\r\n    name: string;\r\n    type: AttachmentType;\r\n\r\n    constructor(name: string) {\r\n        if (name == null) throw new Error(\"name cannot be null.\");\r\n        this.name = name;\r\n    }\r\n\r\n    abstract copy (): Attachment;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport abstract class VertexAttachment extends Attachment {\r\n    private static nextID = 0;\r\n\r\n    id = (VertexAttachment.nextID++ & 65535) << 11;\r\n    bones: Array<number>;\r\n    vertices: ArrayLike<number>;\r\n    worldVerticesLength = 0;\r\n    deformAttachment: VertexAttachment = this;\r\n\r\n    constructor(name: string) {\r\n        super(name);\r\n    }\r\n\r\n    computeWorldVerticesOld(slot: Slot, worldVertices: ArrayLike<number>) {\r\n        this.computeWorldVertices(slot, 0, this.worldVerticesLength, worldVertices, 0, 2);\r\n    }\r\n\r\n    /** Transforms local vertices to world coordinates.\r\n     * @param start The index of the first local vertex value to transform. Each vertex has 2 values, x and y.\r\n     * @param count The number of world vertex values to output. Must be <= {@link #getWorldVerticesLength()} - start.\r\n     * @param worldVertices The output world vertices. Must have a length >= offset + count.\r\n     * @param offset The worldVertices index to begin writing values. */\r\n    computeWorldVertices (slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number) {\r\n        count = offset + (count >> 1) * stride;\r\n        let skeleton = slot.bone.skeleton;\r\n        let deformArray = slot.deform;\r\n        let vertices = this.vertices;\r\n        let bones = this.bones;\r\n        if (bones == null) {\r\n            if (deformArray.length > 0) vertices = deformArray;\r\n            let mat = slot.bone.matrix;\r\n            let x = mat.tx;\r\n            let y = mat.ty;\r\n            let a = mat.a, b = mat.c, c = mat.b, d = mat.d;\r\n            for (let v = start, w = offset; w < count; v += 2, w += stride) {\r\n                let vx = vertices[v], vy = vertices[v + 1];\r\n                worldVertices[w] = vx * a + vy * b + x;\r\n                worldVertices[w + 1] = vx * c + vy * d + y;\r\n            }\r\n            return;\r\n        }\r\n        let v = 0, skip = 0;\r\n        for (let i = 0; i < start; i += 2) {\r\n            let n = bones[v];\r\n            v += n + 1;\r\n            skip += n;\r\n        }\r\n        let skeletonBones = skeleton.bones;\r\n        if (deformArray.length == 0) {\r\n            for (let w = offset, b = skip * 3; w < count; w += stride) {\r\n                let wx = 0, wy = 0;\r\n                let n = bones[v++];\r\n                n += v;\r\n                for (; v < n; v++, b += 3) {\r\n                    let mat = skeletonBones[bones[v]].matrix;\r\n                    let vx = vertices[b], vy = vertices[b + 1], weight = vertices[b + 2];\r\n                    wx += (vx * mat.a + vy * mat.c + mat.tx) * weight;\r\n                    wy += (vx * mat.b + vy * mat.d + mat.ty) * weight;\r\n                }\r\n                worldVertices[w] = wx;\r\n                worldVertices[w + 1] = wy;\r\n            }\r\n        } else {\r\n            let deform = deformArray;\r\n            for (let w = offset, b = skip * 3, f = skip << 1; w < count; w += stride) {\r\n                let wx = 0, wy = 0;\r\n                let n = bones[v++];\r\n                n += v;\r\n                for (; v < n; v++, b += 3, f += 2) {\r\n                    let mat = skeletonBones[bones[v]].matrix;\r\n                    let vx = vertices[b] + deform[f], vy = vertices[b + 1] + deform[f + 1], weight = vertices[b + 2];\r\n                    wx += (vx * mat.a + vy * mat.c + mat.tx) * weight;\r\n                    wy += (vx * mat.b + vy * mat.d + mat.ty) * weight;\r\n                }\r\n                worldVertices[w] = wx;\r\n                worldVertices[w + 1] = wy;\r\n            }\r\n        }\r\n    }\r\n\r\n    copyTo (attachment: VertexAttachment) {\r\n        if (this.bones != null) {\r\n            attachment.bones = new Array<number>(this.bones.length);\r\n            Utils.arrayCopy(this.bones, 0, attachment.bones, 0, this.bones.length);\r\n        } else\r\n            attachment.bones = null;\r\n\r\n        if (this.vertices != null) {\r\n            attachment.vertices = Utils.newFloatArray(this.vertices.length);\r\n            Utils.arrayCopy(this.vertices, 0, attachment.vertices, 0, this.vertices.length);\r\n        } else\r\n            attachment.vertices = null;\r\n\r\n        attachment.worldVerticesLength = this.worldVerticesLength;\r\n        attachment.deformAttachment = this.deformAttachment;\r\n    }\r\n}\r\n","import {Attachment, VertexAttachment} from './Attachment';\r\nimport {AttachmentType, Color} from '@pixi-spine/base';\r\n\r\n/**\r\n * @public\r\n */\r\nexport class BoundingBoxAttachment extends VertexAttachment {\r\n    type = AttachmentType.BoundingBox;\r\n    color = new Color(1, 1, 1, 1);\r\n\r\n    constructor (name: string) {\r\n        super(name);\r\n    }\r\n\r\n    copy (): Attachment {\r\n        let copy = new BoundingBoxAttachment(this.name);\r\n        this.copyTo(copy);\r\n        copy.color.setFromColor(this.color);\r\n        return copy;\r\n    }\r\n}\r\n","import {Attachment, VertexAttachment} from './Attachment';\r\nimport {AttachmentType, Color, IClippingAttachment} from '@pixi-spine/base';\r\nimport type {SlotData} from '../SlotData';\r\n\r\n/**\r\n * @public\r\n */\r\nexport class ClippingAttachment extends VertexAttachment implements IClippingAttachment {\r\n    type = AttachmentType.Clipping;\r\n    endSlot: SlotData;\r\n\r\n    // Nonessential.\r\n    color = new Color(0.2275, 0.2275, 0.8078, 1); // ce3a3aff\r\n\r\n    constructor (name: string) {\r\n        super(name);\r\n    }\r\n\r\n    copy (): Attachment {\r\n        let copy = new ClippingAttachment(this.name);\r\n        this.copyTo(copy);\r\n        copy.endSlot = this.endSlot;\r\n        copy.color.setFromColor(this.color);\r\n        return copy;\r\n    }\r\n}\r\n","import {Attachment, VertexAttachment} from './Attachment';\r\nimport {AttachmentType, Color, IMeshAttachment, TextureRegion, Utils} from '@pixi-spine/base';\r\n\r\n/**\r\n * @public\r\n */\r\nexport class MeshAttachment extends VertexAttachment implements IMeshAttachment {\r\n    type = AttachmentType.Mesh;\r\n\r\n    region: TextureRegion;\r\n    path: string;\r\n    regionUVs: Float32Array;\r\n    triangles: Array<number>;\r\n    color = new Color(1, 1, 1, 1);\r\n    width: number;\r\n    height: number;\r\n    hullLength: number;\r\n    edges: Array<number>;\r\n    private parentMesh: MeshAttachment;\r\n    tempColor = new Color(0, 0, 0, 0);\r\n\r\n    constructor (name: string) {\r\n        super(name);\r\n    }\r\n\r\n    getParentMesh () {\r\n        return this.parentMesh;\r\n    }\r\n\r\n    /** @param parentMesh May be null. */\r\n    setParentMesh (parentMesh: MeshAttachment) {\r\n        this.parentMesh = parentMesh;\r\n        if (parentMesh != null) {\r\n            this.bones = parentMesh.bones;\r\n            this.vertices = parentMesh.vertices;\r\n            this.worldVerticesLength = parentMesh.worldVerticesLength;\r\n            this.regionUVs = parentMesh.regionUVs;\r\n            this.triangles = parentMesh.triangles;\r\n            this.hullLength = parentMesh.hullLength;\r\n            this.worldVerticesLength = parentMesh.worldVerticesLength\r\n        }\r\n    }\r\n\r\n    copy (): Attachment {\r\n        if (this.parentMesh != null) return this.newLinkedMesh();\r\n\r\n        let copy = new MeshAttachment(this.name);\r\n        copy.region = this.region;\r\n        copy.path = this.path;\r\n        copy.color.setFromColor(this.color);\r\n\r\n        this.copyTo(copy);\r\n        copy.regionUVs = new Float32Array(this.regionUVs.length);\r\n        Utils.arrayCopy(this.regionUVs, 0, copy.regionUVs, 0, this.regionUVs.length);\r\n        copy.triangles = new Array<number>(this.triangles.length);\r\n        Utils.arrayCopy(this.triangles, 0, copy.triangles, 0, this.triangles.length);\r\n        copy.hullLength = this.hullLength;\r\n\r\n        // Nonessential.\r\n        if (this.edges != null) {\r\n            copy.edges = new Array<number>(this.edges.length);\r\n            Utils.arrayCopy(this.edges, 0, copy.edges, 0, this.edges.length);\r\n        }\r\n        copy.width = this.width;\r\n        copy.height = this.height;\r\n\r\n        return copy;\r\n    }\r\n\r\n    newLinkedMesh (): MeshAttachment {\r\n        let copy = new MeshAttachment(this.name);\r\n        copy.region = this.region;\r\n        copy.path = this.path;\r\n        copy.color.setFromColor(this.color);\r\n        copy.deformAttachment = this.deformAttachment;\r\n        copy.setParentMesh(this.parentMesh != null ? this.parentMesh : this);\r\n        // copy.updateUVs();\r\n        return copy;\r\n    }\r\n}\r\n","import {Attachment, VertexAttachment} from \"./Attachment\";\r\nimport {AttachmentType, Color, Utils} from \"@pixi-spine/base\";\r\n\r\n/**\r\n * @public\r\n */\r\nexport class PathAttachment extends VertexAttachment {\r\n    type = AttachmentType.Path;\r\n    lengths: Array<number>;\r\n    closed = false; constantSpeed = false;\r\n    color = new Color(1, 1, 1, 1);\r\n\r\n    constructor (name: string) {\r\n        super(name);\r\n    }\r\n\r\n    copy (): Attachment {\r\n        let copy = new PathAttachment(this.name);\r\n        this.copyTo(copy);\r\n        copy.lengths = new Array<number>(this.lengths.length);\r\n        Utils.arrayCopy(this.lengths, 0, copy.lengths, 0, this.lengths.length);\r\n        copy.closed = closed;\r\n        copy.constantSpeed = this.constantSpeed;\r\n        copy.color.setFromColor(this.color);\r\n        return copy;\r\n    }\r\n}\r\n","import {Attachment, VertexAttachment} from './Attachment';\r\nimport {AttachmentType, Color, MathUtils, Vector2} from \"@pixi-spine/base\";\r\nimport type {Bone} from '../Bone';\r\n\r\n/**\r\n * @public\r\n */\r\nexport class PointAttachment extends VertexAttachment {\r\n    type = AttachmentType.Point;\r\n    x: number; y: number; rotation: number;\r\n    color = new Color(0.38, 0.94, 0, 1);\r\n\r\n    constructor (name: string) {\r\n        super(name);\r\n    }\r\n\r\n    computeWorldPosition(bone: Bone, point: Vector2) {\r\n        const mat = bone.matrix;\r\n        point.x = this.x * mat.a + this.y * mat.c + bone.worldX;\r\n        point.y = this.x * mat.b + this.y * mat.d + bone.worldY;\r\n        return point;\r\n    }\r\n\r\n    computeWorldRotation(bone: Bone) {\r\n        const mat = bone.matrix;\r\n        let cos = MathUtils.cosDeg(this.rotation), sin = MathUtils.sinDeg(this.rotation);\r\n        let x = cos * mat.a + sin * mat.c;\r\n        let y = cos * mat.b + sin * mat.d;\r\n        return Math.atan2(y, x) * MathUtils.radDeg;\r\n    }\r\n\r\n    copy (): Attachment {\r\n        let copy = new PointAttachment(this.name);\r\n        copy.x = this.x;\r\n        copy.y = this.y;\r\n        copy.rotation = this.rotation;\r\n        copy.color.setFromColor(this.color);\r\n        return copy;\r\n    }\r\n}\r\n","import {Attachment} from './Attachment';\r\nimport {AttachmentType, ArrayLike, Color, TextureRegion, Utils, IRegionAttachment} from \"@pixi-spine/base\";\r\n\r\nimport type {Bone} from '../Bone';\r\n\r\n/**\r\n * @public\r\n */\r\nexport class RegionAttachment extends Attachment implements IRegionAttachment {\r\n    type = AttachmentType.Region;\r\n\r\n    static OX1 = 0;\r\n    static OY1 = 1;\r\n    static OX2 = 2;\r\n    static OY2 = 3;\r\n    static OX3 = 4;\r\n    static OY3 = 5;\r\n    static OX4 = 6;\r\n    static OY4 = 7;\r\n\r\n    static X1 = 0;\r\n    static Y1 = 1;\r\n    static C1R = 2;\r\n    static C1G = 3;\r\n    static C1B = 4;\r\n    static C1A = 5;\r\n    static U1 = 6;\r\n    static V1 = 7;\r\n\r\n    static X2 = 8;\r\n    static Y2 = 9;\r\n    static C2R = 10;\r\n    static C2G = 11;\r\n    static C2B = 12;\r\n    static C2A = 13;\r\n    static U2 = 14;\r\n    static V2 = 15;\r\n\r\n    static X3 = 16;\r\n    static Y3 = 17;\r\n    static C3R = 18;\r\n    static C3G = 19;\r\n    static C3B = 20;\r\n    static C3A = 21;\r\n    static U3 = 22;\r\n    static V3 = 23;\r\n\r\n    static X4 = 24;\r\n    static Y4 = 25;\r\n    static C4R = 26;\r\n    static C4G = 27;\r\n    static C4B = 28;\r\n    static C4A = 29;\r\n    static U4 = 30;\r\n    static V4 = 31;\r\n\r\n    x = 0;\r\n    y = 0;\r\n    scaleX = 1;\r\n    scaleY = 1;\r\n    rotation = 0;\r\n    width = 0;\r\n    height = 0;\r\n    color = new Color(1, 1, 1, 1);\r\n\r\n    path: string;\r\n    rendererObject: any;\r\n    region: TextureRegion;\r\n\r\n    offset = Utils.newFloatArray(8);\r\n    uvs = Utils.newFloatArray(8);\r\n\r\n    tempColor = new Color(1, 1, 1, 1);\r\n\r\n    constructor(name: string) {\r\n        super(name);\r\n    }\r\n\r\n    updateOffset(): void {\r\n        let regionScaleX = this.width / this.region.originalWidth * this.scaleX;\r\n        let regionScaleY = this.height / this.region.originalHeight * this.scaleY;\r\n        let localX = -this.width / 2 * this.scaleX + this.region.offsetX * regionScaleX;\r\n        let localY = -this.height / 2 * this.scaleY + this.region.offsetY * regionScaleY;\r\n        let localX2 = localX + this.region.width * regionScaleX;\r\n        let localY2 = localY + this.region.height * regionScaleY;\r\n        let radians = this.rotation * Math.PI / 180;\r\n        let cos = Math.cos(radians);\r\n        let sin = Math.sin(radians);\r\n        let localXCos = localX * cos + this.x;\r\n        let localXSin = localX * sin;\r\n        let localYCos = localY * cos + this.y;\r\n        let localYSin = localY * sin;\r\n        let localX2Cos = localX2 * cos + this.x;\r\n        let localX2Sin = localX2 * sin;\r\n        let localY2Cos = localY2 * cos + this.y;\r\n        let localY2Sin = localY2 * sin;\r\n        let offset = this.offset;\r\n        offset[RegionAttachment.OX1] = localXCos - localYSin;\r\n        offset[RegionAttachment.OY1] = localYCos + localXSin;\r\n        offset[RegionAttachment.OX2] = localXCos - localY2Sin;\r\n        offset[RegionAttachment.OY2] = localY2Cos + localXSin;\r\n        offset[RegionAttachment.OX3] = localX2Cos - localY2Sin;\r\n        offset[RegionAttachment.OY3] = localY2Cos + localX2Sin;\r\n        offset[RegionAttachment.OX4] = localX2Cos - localYSin;\r\n        offset[RegionAttachment.OY4] = localYCos + localX2Sin;\r\n    }\r\n\r\n    setRegion(region: TextureRegion): void {\r\n        this.region = region;\r\n        let uvs = this.uvs;\r\n        if (region.rotate) {\r\n            uvs[2] = region.u;\r\n            uvs[3] = region.v2;\r\n            uvs[4] = region.u;\r\n            uvs[5] = region.v;\r\n            uvs[6] = region.u2;\r\n            uvs[7] = region.v;\r\n            uvs[0] = region.u2;\r\n            uvs[1] = region.v2;\r\n        } else {\r\n            uvs[0] = region.u;\r\n            uvs[1] = region.v2;\r\n            uvs[2] = region.u;\r\n            uvs[3] = region.v;\r\n            uvs[4] = region.u2;\r\n            uvs[5] = region.v;\r\n            uvs[6] = region.u2;\r\n            uvs[7] = region.v2;\r\n        }\r\n    }\r\n\r\n    computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number) {\r\n        let vertexOffset = this.offset;\r\n        let mat = bone.matrix;\r\n        let x = mat.tx, y = mat.ty;\r\n        let a = mat.a, b = mat.c, c = mat.b, d = mat.d;\r\n        let offsetX = 0, offsetY = 0;\r\n\r\n        offsetX = vertexOffset[RegionAttachment.OX1];\r\n        offsetY = vertexOffset[RegionAttachment.OY1];\r\n        worldVertices[offset] = offsetX * a + offsetY * b + x; // br\r\n        worldVertices[offset + 1] = offsetX * c + offsetY * d + y;\r\n        offset += stride;\r\n\r\n        offsetX = vertexOffset[RegionAttachment.OX2];\r\n        offsetY = vertexOffset[RegionAttachment.OY2];\r\n        worldVertices[offset] = offsetX * a + offsetY * b + x; // bl\r\n        worldVertices[offset + 1] = offsetX * c + offsetY * d + y;\r\n        offset += stride;\r\n\r\n        offsetX = vertexOffset[RegionAttachment.OX3];\r\n        offsetY = vertexOffset[RegionAttachment.OY3];\r\n        worldVertices[offset] = offsetX * a + offsetY * b + x; // ul\r\n        worldVertices[offset + 1] = offsetX * c + offsetY * d + y;\r\n        offset += stride;\r\n\r\n        offsetX = vertexOffset[RegionAttachment.OX4];\r\n        offsetY = vertexOffset[RegionAttachment.OY4];\r\n        worldVertices[offset] = offsetX * a + offsetY * b + x; // ur\r\n        worldVertices[offset + 1] = offsetX * c + offsetY * d + y;\r\n    }\r\n\r\n    copy (): Attachment {\r\n        let copy = new RegionAttachment(this.name);\r\n        copy.region = this.region;\r\n        copy.rendererObject = this.rendererObject;\r\n        copy.path = this.path;\r\n        copy.x = this.x;\r\n        copy.y = this.y;\r\n        copy.scaleX = this.scaleX;\r\n        copy.scaleY = this.scaleY;\r\n        copy.rotation = this.rotation;\r\n        copy.width = this.width;\r\n        copy.height = this.height;\r\n        Utils.arrayCopy(this.uvs, 0, copy.uvs, 0, 8);\r\n        Utils.arrayCopy(this.offset, 0, copy.offset, 0, 8);\r\n        copy.color.setFromColor(this.color);\r\n        return copy;\r\n    }\r\n}\r\n","import {VertexEffect} from \"../VertexEffect\";\r\nimport type {Skeleton} from \"../Skeleton\";\r\nimport {Color, MathUtils, Vector2} from \"@pixi-spine/base\";\r\n\r\n/**\r\n * @public\r\n */\r\nexport class JitterEffect implements VertexEffect {\r\n    jitterX = 0;\r\n    jitterY = 0;\r\n\r\n    constructor (jitterX: number, jitterY: number) {\r\n        this.jitterX = jitterX;\r\n        this.jitterY = jitterY;\r\n    }\r\n\r\n    begin(skeleton: Skeleton): void {\r\n    }\r\n\r\n    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void {\r\n        position.x += MathUtils.randomTriangular(-this.jitterX, this.jitterY);\r\n        position.y += MathUtils.randomTriangular(-this.jitterX, this.jitterY);\r\n    }\r\n\r\n    end(): void {\r\n    }\r\n}\r\n","import {VertexEffect} from \"../VertexEffect\";\r\nimport type {Skeleton} from \"../Skeleton\";\r\nimport {Color, MathUtils, PowOut, Vector2} from \"@pixi-spine/base\";\r\n\r\n/**\r\n * @public\r\n */\r\nexport class SwirlEffect implements VertexEffect {\r\n    static interpolation = new PowOut(2);\r\n    centerX = 0;\r\n    centerY = 0;\r\n    radius = 0;\r\n    angle = 0;\r\n    private worldX = 0;\r\n    private worldY = 0;\r\n\r\n    constructor (radius: number) {\r\n        this.radius = radius;\r\n    }\r\n\r\n    begin(skeleton: Skeleton): void {\r\n        this.worldX = skeleton.x + this.centerX;\r\n        this.worldY = skeleton.y + this.centerY;\r\n    }\r\n\r\n    transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void {\r\n        let radAngle = this.angle * MathUtils.degreesToRadians;\r\n        let x = position.x - this.worldX;\r\n        let y = position.y - this.worldY;\r\n        let dist = Math.sqrt(x * x + y * y);\r\n        if (dist < this.radius) {\r\n            let theta = SwirlEffect.interpolation.apply(0, radAngle, (this.radius - dist) / this.radius);\r\n            let cos = Math.cos(theta);\r\n            let sin = Math.sin(theta);\r\n            position.x = cos * x - sin * y + this.worldX;\r\n            position.y = sin * x + cos * y + this.worldY;\r\n        }\r\n    }\r\n\r\n    end(): void {\r\n    }\r\n}\r\n","import {\r\n    IAnimationState,\r\n    IAnimationStateListener,\r\n    ITrackEntry,\r\n    MixBlend,\r\n    MixDirection,\r\n    MathUtils,\r\n    Pool,\r\n    IntSet,\r\n    Utils\r\n} from \"@pixi-spine/base\";\r\nimport {\r\n    Animation,\r\n    AttachmentTimeline,\r\n    DrawOrderTimeline,\r\n    EventTimeline,\r\n    RotateTimeline, Timeline\r\n} from './Animation';\r\nimport {AnimationStateData} from \"./AnimationStateData\";\r\nimport {Event} from './Event';\r\nimport type {Skeleton} from \"./Skeleton\";\r\nimport type {Slot} from \"./Slot\";\r\n\r\n/** Applies animations over time, queues animations for later playback, mixes (crossfading) between animations, and applies\r\n * multiple animations on top of each other (layering).\r\n *\r\n * See [Applying Animations](http://esotericsoftware.com/spine-applying-animations/) in the Spine Runtimes Guide. */\r\n/**\r\n * @public\r\n */\r\nexport class AnimationState implements IAnimationState<AnimationStateData> {\r\n    static emptyAnimation = new Animation(\"<empty>\", [], 0);\r\n\r\n    /** 1. A previously applied timeline has set this property.\r\n     *\r\n     * Result: Mix from the current pose to the timeline pose. */\r\n    static SUBSEQUENT = 0;\r\n    /** 1. This is the first timeline to set this property.\r\n     * 2. The next track entry applied after this one does not have a timeline to set this property.\r\n     *\r\n     * Result: Mix from the setup pose to the timeline pose. */\r\n    static FIRST = 1;\r\n    /** 1) A previously applied timeline has set this property.<br>\r\n     * 2) The next track entry to be applied does have a timeline to set this property.<br>\r\n     * 3) The next track entry after that one does not have a timeline to set this property.<br>\r\n     * Result: Mix from the current pose to the timeline pose, but do not mix out. This avoids \"dipping\" when crossfading\r\n     * animations that key the same property. A subsequent timeline will set this property using a mix. */\r\n    static HOLD_SUBSEQUENT = 2;\r\n    /** 1) This is the first timeline to set this property.<br>\r\n     * 2) The next track entry to be applied does have a timeline to set this property.<br>\r\n     * 3) The next track entry after that one does not have a timeline to set this property.<br>\r\n     * Result: Mix from the setup pose to the timeline pose, but do not mix out. This avoids \"dipping\" when crossfading animations\r\n     * that key the same property. A subsequent timeline will set this property using a mix. */\r\n    static HOLD_FIRST = 3;\r\n    /** 1. This is the first timeline to set this property.\r\n     * 2. The next track entry to be applied does have a timeline to set this property.\r\n     * 3. The next track entry after that one does have a timeline to set this property.\r\n     * 4. timelineHoldMix stores the first subsequent track entry that does not have a timeline to set this property.\r\n     *\r\n     * Result: The same as HOLD except the mix percentage from the timelineHoldMix track entry is used. This handles when more than\r\n     * 2 track entries in a row have a timeline that sets the same property.\r\n     *\r\n     * Eg, A -> B -> C -> D where A, B, and C have a timeline setting same property, but D does not. When A is applied, to avoid\r\n     * \"dipping\" A is not mixed out, however D (the first entry that doesn't set the property) mixing in is used to mix out A\r\n     * (which affects B and C). Without using D to mix out, A would be applied fully until mixing completes, then snap into\r\n     * place. */\r\n    static HOLD_MIX = 4;\r\n\r\n    static SETUP = 1;\r\n    static CURRENT = 2;\r\n\r\n    /** The AnimationStateData to look up mix durations. */\r\n    data: AnimationStateData;\r\n\r\n    /** The list of tracks that currently have animations, which may contain null entries. */\r\n    tracks = new Array<TrackEntry>();\r\n\r\n    /** Multiplier for the delta time when the animation state is updated, causing time for all animations and mixes to play slower\r\n     * or faster. Defaults to 1.\r\n     *\r\n     * See TrackEntry {@link TrackEntry#timeScale} for affecting a single animation. */\r\n    timeScale = 1;\r\n    unkeyedState = 0;\r\n\r\n    events = new Array<Event>();\r\n    listeners = new Array<AnimationStateListener>();\r\n    queue = new EventQueue(this);\r\n    propertyIDs = new IntSet();\r\n    animationsChanged = false;\r\n\r\n    trackEntryPool = new Pool<TrackEntry>(() => new TrackEntry());\r\n\r\n    constructor (data: AnimationStateData) {\r\n        this.data = data;\r\n    }\r\n\r\n    /** Increments each track entry {@link TrackEntry#trackTime()}, setting queued animations as current if needed. */\r\n    update (delta: number) {\r\n        delta *= this.timeScale;\r\n        let tracks = this.tracks;\r\n        for (let i = 0, n = tracks.length; i < n; i++) {\r\n            let current = tracks[i];\r\n            if (current == null) continue;\r\n\r\n            current.animationLast = current.nextAnimationLast;\r\n            current.trackLast = current.nextTrackLast;\r\n\r\n            let currentDelta = delta * current.timeScale;\r\n\r\n            if (current.delay > 0) {\r\n                current.delay -= currentDelta;\r\n                if (current.delay > 0) continue;\r\n                currentDelta = -current.delay;\r\n                current.delay = 0;\r\n            }\r\n\r\n            let next = current.next;\r\n            if (next != null) {\r\n                // When the next entry's delay is passed, change to the next entry, preserving leftover time.\r\n                let nextTime = current.trackLast - next.delay;\r\n                if (nextTime >= 0) {\r\n                    next.delay = 0;\r\n                    next.trackTime += current.timeScale == 0 ? 0 : (nextTime / current.timeScale + delta) * next.timeScale;\r\n                    current.trackTime += currentDelta;\r\n                    this.setCurrent(i, next, true);\r\n                    while (next.mixingFrom != null) {\r\n                        next.mixTime += delta;\r\n                        next = next.mixingFrom;\r\n                    }\r\n                    continue;\r\n                }\r\n            } else if (current.trackLast >= current.trackEnd && current.mixingFrom == null) {\r\n                tracks[i] = null;\r\n                this.queue.end(current);\r\n                this.disposeNext(current);\r\n                continue;\r\n            }\r\n            if (current.mixingFrom != null && this.updateMixingFrom(current, delta)) {\r\n                // End mixing from entries once all have completed.\r\n                let from = current.mixingFrom;\r\n                current.mixingFrom = null;\r\n                if (from != null) from.mixingTo = null;\r\n                while (from != null) {\r\n                    this.queue.end(from);\r\n                    from = from.mixingFrom;\r\n                }\r\n            }\r\n\r\n            current.trackTime += currentDelta;\r\n        }\r\n\r\n        this.queue.drain();\r\n    }\r\n\r\n    /** Returns true when all mixing from entries are complete. */\r\n    updateMixingFrom (to: TrackEntry, delta: number): boolean {\r\n        let from = to.mixingFrom;\r\n        if (from == null) return true;\r\n\r\n        let finished = this.updateMixingFrom(from, delta);\r\n\r\n        from.animationLast = from.nextAnimationLast;\r\n        from.trackLast = from.nextTrackLast;\r\n\r\n        // Require mixTime > 0 to ensure the mixing from entry was applied at least once.\r\n        if (to.mixTime > 0 && to.mixTime >= to.mixDuration) {\r\n            // Require totalAlpha == 0 to ensure mixing is complete, unless mixDuration == 0 (the transition is a single frame).\r\n            if (from.totalAlpha == 0 || to.mixDuration == 0) {\r\n                to.mixingFrom = from.mixingFrom;\r\n                if (from.mixingFrom != null) from.mixingFrom.mixingTo = to;\r\n                to.interruptAlpha = from.interruptAlpha;\r\n                this.queue.end(from);\r\n            }\r\n            return finished;\r\n        }\r\n\r\n        from.trackTime += delta * from.timeScale;\r\n        to.mixTime += delta;\r\n        return false;\r\n    }\r\n\r\n    /** Poses the skeleton using the track entry animations. There are no side effects other than invoking listeners, so the\r\n     * animation state can be applied to multiple skeletons to pose them identically.\r\n     * @returns True if any animations were applied. */\r\n    apply (skeleton: Skeleton) : boolean {\r\n        if (skeleton == null) throw new Error(\"skeleton cannot be null.\");\r\n        if (this.animationsChanged) this._animationsChanged();\r\n\r\n        let events = this.events;\r\n        let tracks = this.tracks;\r\n        let applied = false;\r\n\r\n        for (let i = 0, n = tracks.length; i < n; i++) {\r\n            let current = tracks[i];\r\n            if (current == null || current.delay > 0) continue;\r\n            applied = true;\r\n            let blend: MixBlend = i == 0 ? MixBlend.first : current.mixBlend;\r\n\r\n            // Apply mixing from entries first.\r\n            let mix = current.alpha;\r\n            if (current.mixingFrom != null)\r\n                mix *= this.applyMixingFrom(current, skeleton, blend);\r\n            else if (current.trackTime >= current.trackEnd && current.next == null)\r\n                mix = 0;\r\n\r\n            // Apply current entry.\r\n            let animationLast = current.animationLast, animationTime = current.getAnimationTime();\r\n            let timelineCount = current.animation.timelines.length;\r\n            let timelines = current.animation.timelines;\r\n            if ((i == 0 && mix == 1) || blend == MixBlend.add) {\r\n                for (let ii = 0; ii < timelineCount; ii++) {\r\n                    // Fixes issue #302 on IOS9 where mix, blend sometimes became undefined and caused assets\r\n                    // to sometimes stop rendering when using color correction, as their RGBA values become NaN.\r\n                    // (https://github.com/pixijs/pixi-spine/issues/302)\r\n                    Utils.webkit602BugfixHelper(mix, blend);\r\n                    var timeline = timelines[ii];\r\n                    if (timeline instanceof AttachmentTimeline)\r\n                        this.applyAttachmentTimeline(timeline, skeleton, animationTime, blend, true);\r\n                    else\r\n                        timeline.apply(skeleton, animationLast, animationTime, events, mix, blend, MixDirection.mixIn);\r\n                }\r\n            } else {\r\n                let timelineMode = current.timelineMode;\r\n\r\n                let firstFrame = current.timelinesRotation.length == 0;\r\n                if (firstFrame) Utils.setArraySize(current.timelinesRotation, timelineCount << 1, null);\r\n                let timelinesRotation = current.timelinesRotation;\r\n\r\n                for (let ii = 0; ii < timelineCount; ii++) {\r\n                    let timeline = timelines[ii];\r\n                    let timelineBlend = timelineMode[ii]  == AnimationState.SUBSEQUENT ? blend : MixBlend.setup;\r\n                    if (timeline instanceof RotateTimeline) {\r\n                        this.applyRotateTimeline(timeline, skeleton, animationTime, mix, timelineBlend, timelinesRotation, ii << 1, firstFrame);\r\n                    } else if (timeline instanceof AttachmentTimeline) {\r\n                        this.applyAttachmentTimeline(timeline, skeleton, animationTime, blend, true);\r\n                    } else {\r\n                        // This fixes the WebKit 602 specific issue described at http://esotericsoftware.com/forum/iOS-10-disappearing-graphics-10109\r\n                        Utils.webkit602BugfixHelper(mix, blend);\r\n                        timeline.apply(skeleton, animationLast, animationTime, events, mix, timelineBlend, MixDirection.mixIn);\r\n                    }\r\n                }\r\n            }\r\n            this.queueEvents(current, animationTime);\r\n            events.length = 0;\r\n            current.nextAnimationLast = animationTime;\r\n            current.nextTrackLast = current.trackTime;\r\n        }\r\n\r\n        // Set slots attachments to the setup pose, if needed. This occurs if an animation that is mixing out sets attachments so\r\n        // subsequent timelines see any deform, but the subsequent timelines don't set an attachment (eg they are also mixing out or\r\n        // the time is before the first key).\r\n        var setupState = this.unkeyedState + AnimationState.SETUP;\r\n        var slots = skeleton.slots;\r\n        for (var i = 0, n = skeleton.slots.length; i < n; i++) {\r\n            var slot = slots[i];\r\n            if (slot.attachmentState == setupState) {\r\n                var attachmentName = slot.data.attachmentName;\r\n                slot.setAttachment(attachmentName == null ? null : skeleton.getAttachment(slot.data.index, attachmentName));\r\n            }\r\n        }\r\n        this.unkeyedState += 2; // Increasing after each use avoids the need to reset attachmentState for every slot.\r\n\r\n        this.queue.drain();\r\n        return applied;\r\n    }\r\n\r\n    applyMixingFrom (to: TrackEntry, skeleton: Skeleton, blend: MixBlend) {\r\n        let from = to.mixingFrom;\r\n        if (from.mixingFrom != null) this.applyMixingFrom(from, skeleton, blend);\r\n\r\n        let mix = 0;\r\n        if (to.mixDuration == 0) { // Single frame mix to undo mixingFrom changes.\r\n            mix = 1;\r\n            if (blend == MixBlend.first) blend = MixBlend.setup;\r\n        } else {\r\n            mix = to.mixTime / to.mixDuration;\r\n            if (mix > 1) mix = 1;\r\n            if (blend != MixBlend.first) blend = from.mixBlend;\r\n        }\r\n\r\n        let events = mix < from.eventThreshold ? this.events : null;\r\n        let attachments = mix < from.attachmentThreshold, drawOrder = mix < from.drawOrderThreshold;\r\n        let animationLast = from.animationLast, animationTime = from.getAnimationTime();\r\n        let timelineCount = from.animation.timelines.length;\r\n        let timelines = from.animation.timelines;\r\n        let alphaHold = from.alpha * to.interruptAlpha, alphaMix = alphaHold * (1 - mix);\r\n        if (blend == MixBlend.add) {\r\n            for (let i = 0; i < timelineCount; i++)\r\n                timelines[i].apply(skeleton, animationLast, animationTime, events, alphaMix, blend, MixDirection.mixOut);\r\n        } else {\r\n            let timelineMode = from.timelineMode;\r\n            let timelineHoldMix = from.timelineHoldMix;\r\n\r\n            let firstFrame = from.timelinesRotation.length == 0;\r\n            if (firstFrame) Utils.setArraySize(from.timelinesRotation, timelineCount << 1, null);\r\n            let timelinesRotation = from.timelinesRotation;\r\n\r\n            from.totalAlpha = 0;\r\n            for (let i = 0; i < timelineCount; i++) {\r\n                let timeline = timelines[i];\r\n                let direction = MixDirection.mixOut;\r\n                let timelineBlend: MixBlend;\r\n                let alpha = 0;\r\n                switch (timelineMode[i]) {\r\n                    case AnimationState.SUBSEQUENT:\r\n                        if (!drawOrder && timeline instanceof DrawOrderTimeline) continue;\r\n                        timelineBlend = blend;\r\n                        alpha = alphaMix;\r\n                        break;\r\n                    case AnimationState.FIRST:\r\n                        timelineBlend = MixBlend.setup;\r\n                        alpha = alphaMix;\r\n                        break;\r\n                    case AnimationState.HOLD_SUBSEQUENT:\r\n                        timelineBlend = blend;\r\n                        alpha = alphaHold;\r\n                        break;\r\n                    case AnimationState.HOLD_FIRST:\r\n                        timelineBlend = MixBlend.setup;\r\n                        alpha = alphaHold;\r\n                        break;\r\n                    default:\r\n                        timelineBlend = MixBlend.setup;\r\n                        let holdMix = timelineHoldMix[i];\r\n                        alpha = alphaHold * Math.max(0, 1 - holdMix.mixTime / holdMix.mixDuration);\r\n                        break;\r\n                }\r\n                from.totalAlpha += alpha;\r\n\r\n                if (timeline instanceof RotateTimeline)\r\n                    this.applyRotateTimeline(timeline, skeleton, animationTime, alpha, timelineBlend, timelinesRotation, i << 1, firstFrame);\r\n                else if (timeline instanceof AttachmentTimeline)\r\n                    this.applyAttachmentTimeline(timeline, skeleton, animationTime, timelineBlend, attachments);\r\n                else {\r\n                    // This fixes the WebKit 602 specific issue described at http://esotericsoftware.com/forum/iOS-10-disappearing-graphics-10109\r\n                    Utils.webkit602BugfixHelper(alpha, blend);\r\n                    if (drawOrder && timeline instanceof DrawOrderTimeline && timelineBlend == MixBlend.setup)\r\n                        direction = MixDirection.mixIn;\r\n                    timeline.apply(skeleton, animationLast, animationTime, events, alpha, timelineBlend, direction);\r\n                }\r\n            }\r\n        }\r\n\r\n        if (to.mixDuration > 0) this.queueEvents(from, animationTime);\r\n        this.events.length = 0;\r\n        from.nextAnimationLast = animationTime;\r\n        from.nextTrackLast = from.trackTime;\r\n\r\n        return mix;\r\n    }\r\n\r\n    applyAttachmentTimeline (timeline: AttachmentTimeline, skeleton: Skeleton, time: number, blend: MixBlend, attachments: boolean) {\r\n\r\n        var slot = skeleton.slots[timeline.slotIndex];\r\n        if (!slot.bone.active) return;\r\n\r\n        var frames = timeline.frames;\r\n        if (time < frames[0]) { // Time is before first frame.\r\n            if (blend == MixBlend.setup || blend == MixBlend.first)\r\n                this.setAttachment(skeleton, slot, slot.data.attachmentName, attachments);\r\n        }\r\n        else {\r\n            var frameIndex;\r\n            if (time >= frames[frames.length - 1]) // Time is after last frame.\r\n                frameIndex = frames.length - 1;\r\n            else\r\n                frameIndex = Animation.binarySearch(frames, time) - 1;\r\n            this.setAttachment(skeleton, slot, timeline.attachmentNames[frameIndex], attachments);\r\n        }\r\n\r\n        // If an attachment wasn't set (ie before the first frame or attachments is false), set the setup attachment later.\r\n        if (slot.attachmentState <= this.unkeyedState) slot.attachmentState = this.unkeyedState + AnimationState.SETUP;\r\n    }\r\n\r\n    setAttachment (skeleton: Skeleton, slot: Slot, attachmentName: string, attachments: boolean) {\r\n        slot.setAttachment(attachmentName == null ? null : skeleton.getAttachment(slot.data.index, attachmentName));\r\n        if (attachments) slot.attachmentState = this.unkeyedState + AnimationState.CURRENT;\r\n    }\r\n\r\n\r\n    applyRotateTimeline (timeline: Timeline, skeleton: Skeleton, time: number, alpha: number, blend: MixBlend,\r\n                         timelinesRotation: Array<number>, i: number, firstFrame: boolean) {\r\n\r\n        if (firstFrame) timelinesRotation[i] = 0;\r\n\r\n        if (alpha == 1) {\r\n            timeline.apply(skeleton, 0, time, null, 1, blend, MixDirection.mixIn);\r\n            return;\r\n        }\r\n\r\n        let rotateTimeline = timeline as RotateTimeline;\r\n        let frames = rotateTimeline.frames;\r\n        let bone = skeleton.bones[rotateTimeline.boneIndex];\r\n        if (!bone.active) return;\r\n        let r1 = 0, r2 = 0;\r\n        if (time < frames[0]) {\r\n            switch (blend) {\r\n                case MixBlend.setup:\r\n                    bone.rotation = bone.data.rotation;\r\n                default:\r\n                    return;\r\n                case MixBlend.first:\r\n                    r1 = bone.rotation;\r\n                    r2 = bone.data.rotation;\r\n            }\r\n        } else {\r\n            r1 = blend == MixBlend.setup ? bone.data.rotation : bone.rotation;\r\n            if (time >= frames[frames.length - RotateTimeline.ENTRIES]) // Time is after last frame.\r\n                r2 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION];\r\n            else {\r\n                // Interpolate between the previous frame and the current frame.\r\n                let frame = Animation.binarySearch(frames, time, RotateTimeline.ENTRIES);\r\n                let prevRotation = frames[frame + RotateTimeline.PREV_ROTATION];\r\n                let frameTime = frames[frame];\r\n                let percent = rotateTimeline.getCurvePercent((frame >> 1) - 1,\r\n                    1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));\r\n\r\n                r2 = frames[frame + RotateTimeline.ROTATION] - prevRotation;\r\n                r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;\r\n                r2 = prevRotation + r2 * percent + bone.data.rotation;\r\n                r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;\r\n            }\r\n        }\r\n\r\n        // Mix between rotations using the direction of the shortest route on the first frame while detecting crosses.\r\n        let total = 0, diff = r2 - r1;\r\n        diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;\r\n        if (diff == 0) {\r\n            total = timelinesRotation[i];\r\n        } else {\r\n            let lastTotal = 0, lastDiff = 0;\r\n            if (firstFrame) {\r\n                lastTotal = 0;\r\n                lastDiff = diff;\r\n            } else {\r\n                lastTotal = timelinesRotation[i]; // Angle and direction of mix, including loops.\r\n                lastDiff = timelinesRotation[i + 1]; // Difference between bones.\r\n            }\r\n            let current = diff > 0, dir = lastTotal >= 0;\r\n            // Detect cross at 0 (not 180).\r\n            if (MathUtils.signum(lastDiff) != MathUtils.signum(diff) && Math.abs(lastDiff) <= 90) {\r\n                // A cross after a 360 rotation is a loop.\r\n                if (Math.abs(lastTotal) > 180) lastTotal += 360 * MathUtils.signum(lastTotal);\r\n                dir = current;\r\n            }\r\n            total = diff + lastTotal - lastTotal % 360; // Store loops as part of lastTotal.\r\n            if (dir != current) total += 360 * MathUtils.signum(lastTotal);\r\n            timelinesRotation[i] = total;\r\n        }\r\n        timelinesRotation[i + 1] = diff;\r\n        r1 += total * alpha;\r\n        bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360;\r\n    }\r\n\r\n    queueEvents (entry: TrackEntry, animationTime: number) {\r\n        let animationStart = entry.animationStart, animationEnd = entry.animationEnd;\r\n        let duration = animationEnd - animationStart;\r\n        let trackLastWrapped = entry.trackLast % duration;\r\n\r\n        // Queue events before complete.\r\n        let events = this.events;\r\n        let i = 0, n = events.length;\r\n        for (; i < n; i++) {\r\n            let event = events[i];\r\n            if (event.time < trackLastWrapped) break;\r\n            if (event.time > animationEnd) continue; // Discard events outside animation start/end.\r\n            this.queue.event(entry, event);\r\n        }\r\n\r\n        // Queue complete if completed a loop iteration or the animation.\r\n        let complete = false;\r\n        if (entry.loop)\r\n            complete = duration == 0 || trackLastWrapped > entry.trackTime % duration;\r\n        else\r\n            complete = animationTime >= animationEnd && entry.animationLast < animationEnd;\r\n        if (complete) this.queue.complete(entry);\r\n\r\n        // Queue events after complete.\r\n        for (; i < n; i++) {\r\n            let event = events[i];\r\n            if (event.time < animationStart) continue; // Discard events outside animation start/end.\r\n            this.queue.event(entry, events[i]);\r\n        }\r\n    }\r\n\r\n    /** Removes all animations from all tracks, leaving skeletons in their current pose.\r\n     *\r\n     * It may be desired to use {@link AnimationState#setEmptyAnimation()} to mix the skeletons back to the setup pose,\r\n     * rather than leaving them in their current pose. */\r\n    clearTracks () {\r\n        let oldDrainDisabled = this.queue.drainDisabled;\r\n        this.queue.drainDisabled = true;\r\n        for (let i = 0, n = this.tracks.length; i < n; i++)\r\n            this.clearTrack(i);\r\n        this.tracks.length = 0;\r\n        this.queue.drainDisabled = oldDrainDisabled;\r\n        this.queue.drain();\r\n    }\r\n\r\n    /** Removes all animations from the track, leaving skeletons in their current pose.\r\n     *\r\n     * It may be desired to use {@link AnimationState#setEmptyAnimation()} to mix the skeletons back to the setup pose,\r\n     * rather than leaving them in their current pose. */\r\n    clearTrack (trackIndex: number) {\r\n        if (trackIndex >= this.tracks.length) return;\r\n        let current = this.tracks[trackIndex];\r\n        if (current == null) return;\r\n\r\n        this.queue.end(current);\r\n\r\n        this.disposeNext(current);\r\n\r\n        let entry = current;\r\n        while (true) {\r\n            let from = entry.mixingFrom;\r\n            if (from == null) break;\r\n            this.queue.end(from);\r\n            entry.mixingFrom = null;\r\n            entry.mixingTo = null;\r\n            entry = from;\r\n        }\r\n\r\n        this.tracks[current.trackIndex] = null;\r\n\r\n        this.queue.drain();\r\n    }\r\n\r\n    setCurrent (index: number, current: TrackEntry, interrupt: boolean) {\r\n        let from = this.expandToIndex(index);\r\n        this.tracks[index] = current;\r\n\r\n        if (from != null) {\r\n            if (interrupt) this.queue.interrupt(from);\r\n            current.mixingFrom = from;\r\n            from.mixingTo = current;\r\n            current.mixTime = 0;\r\n\r\n            // Store the interrupted mix percentage.\r\n            if (from.mixingFrom != null && from.mixDuration > 0)\r\n                current.interruptAlpha *= Math.min(1, from.mixTime / from.mixDuration);\r\n\r\n            from.timelinesRotation.length = 0; // Reset rotation for mixing out, in case entry was mixed in.\r\n        }\r\n\r\n        this.queue.start(current);\r\n    }\r\n\r\n    /** Sets an animation by name.\r\n     *\r\n     * {@link #setAnimationWith(}. */\r\n    setAnimation (trackIndex: number, animationName: string, loop: boolean) {\r\n        let animation = this.data.skeletonData.findAnimation(animationName);\r\n        if (animation == null) throw new Error(\"Animation not found: \" + animationName);\r\n        return this.setAnimationWith(trackIndex, animation, loop);\r\n    }\r\n\r\n    /** Sets the current animation for a track, discarding any queued animations. If the formerly current track entry was never\r\n     * applied to a skeleton, it is replaced (not mixed from).\r\n     * @param loop If true, the animation will repeat. If false it will not, instead its last frame is applied if played beyond its\r\n     *           duration. In either case {@link TrackEntry#trackEnd} determines when the track is cleared.\r\n     * @returns A track entry to allow further customization of animation playback. References to the track entry must not be kept\r\n     *         after the {@link AnimationStateListener#dispose()} event occurs. */\r\n    setAnimationWith (trackIndex: number, animation: Animation, loop: boolean) {\r\n        if (animation == null) throw new Error(\"animation cannot be null.\");\r\n        let interrupt = true;\r\n        let current = this.expandToIndex(trackIndex);\r\n        if (current != null) {\r\n            if (current.nextTrackLast == -1) {\r\n                // Don't mix from an entry that was never applied.\r\n                this.tracks[trackIndex] = current.mixingFrom;\r\n                this.queue.interrupt(current);\r\n                this.queue.end(current);\r\n                this.disposeNext(current);\r\n                current = current.mixingFrom;\r\n                interrupt = false;\r\n            } else\r\n                this.disposeNext(current);\r\n        }\r\n        let entry = this.trackEntry(trackIndex, animation, loop, current);\r\n        this.setCurrent(trackIndex, entry, interrupt);\r\n        this.queue.drain();\r\n        return entry;\r\n    }\r\n\r\n    /** Queues an animation by name.\r\n     *\r\n     * See {@link #addAnimationWith()}. */\r\n    addAnimation (trackIndex: number, animationName: string, loop: boolean, delay: number) {\r\n        let animation = this.data.skeletonData.findAnimation(animationName);\r\n        if (animation == null) throw new Error(\"Animation not found: \" + animationName);\r\n        return this.addAnimationWith(trackIndex, animation, loop, delay);\r\n    }\r\n\r\n    /** Adds an animation to be played after the current or last queued animation for a track. If the track is empty, it is\r\n     * equivalent to calling {@link #setAnimationWith()}.\r\n     * @param delay If > 0, sets {@link TrackEntry#delay}. If <= 0, the delay set is the duration of the previous track entry\r\n     *           minus any mix duration (from the {@link AnimationStateData}) plus the specified `delay` (ie the mix\r\n     *           ends at (`delay` = 0) or before (`delay` < 0) the previous track entry duration). If the\r\n     *           previous entry is looping, its next loop completion is used instead of its duration.\r\n     * @returns A track entry to allow further customization of animation playback. References to the track entry must not be kept\r\n     *         after the {@link AnimationStateListener#dispose()} event occurs. */\r\n    addAnimationWith (trackIndex: number, animation: Animation, loop: boolean, delay: number) {\r\n        if (animation == null) throw new Error(\"animation cannot be null.\");\r\n\r\n        let last = this.expandToIndex(trackIndex);\r\n        if (last != null) {\r\n            while (last.next != null)\r\n                last = last.next;\r\n        }\r\n\r\n        let entry = this.trackEntry(trackIndex, animation, loop, last);\r\n\r\n        if (last == null) {\r\n            this.setCurrent(trackIndex, entry, true);\r\n            this.queue.drain();\r\n        } else {\r\n            last.next = entry;\r\n            if (delay <= 0) {\r\n                let duration = last.animationEnd - last.animationStart;\r\n                if (duration != 0) {\r\n                    if (last.loop)\r\n                        delay += duration * (1 + ((last.trackTime / duration) | 0));\r\n                    else\r\n                        delay += Math.max(duration, last.trackTime);\r\n                    delay -= this.data.getMix(last.animation, animation);\r\n                } else\r\n                    delay = last.trackTime;\r\n            }\r\n        }\r\n\r\n        entry.delay = delay;\r\n        return entry;\r\n    }\r\n\r\n    /** Sets an empty animation for a track, discarding any queued animations, and sets the track entry's\r\n     * {@link TrackEntry#mixduration}. An empty animation has no timelines and serves as a placeholder for mixing in or out.\r\n     *\r\n     * Mixing out is done by setting an empty animation with a mix duration using either {@link #setEmptyAnimation()},\r\n     * {@link #setEmptyAnimations()}, or {@link #addEmptyAnimation()}. Mixing to an empty animation causes\r\n     * the previous animation to be applied less and less over the mix duration. Properties keyed in the previous animation\r\n     * transition to the value from lower tracks or to the setup pose value if no lower tracks key the property. A mix duration of\r\n     * 0 still mixes out over one frame.\r\n     *\r\n     * Mixing in is done by first setting an empty animation, then adding an animation using\r\n     * {@link #addAnimation()} and on the returned track entry, set the\r\n     * {@link TrackEntry#setMixDuration()}. Mixing from an empty animation causes the new animation to be applied more and\r\n     * more over the mix duration. Properties keyed in the new animation transition from the value from lower tracks or from the\r\n     * setup pose value if no lower tracks key the property to the value keyed in the new animation. */\r\n    setEmptyAnimation (trackIndex: number, mixDuration: number) {\r\n        let entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false);\r\n        entry.mixDuration = mixDuration;\r\n        entry.trackEnd = mixDuration;\r\n        return entry;\r\n    }\r\n\r\n    /** Adds an empty animation to be played after the current or last queued animation for a track, and sets the track entry's\r\n     * {@link TrackEntry#mixDuration}. If the track is empty, it is equivalent to calling\r\n     * {@link #setEmptyAnimation()}.\r\n     *\r\n     * See {@link #setEmptyAnimation()}.\r\n     * @param delay If > 0, sets {@link TrackEntry#delay}. If <= 0, the delay set is the duration of the previous track entry\r\n     *           minus any mix duration plus the specified `delay` (ie the mix ends at (`delay` = 0) or\r\n     *           before (`delay` < 0) the previous track entry duration). If the previous entry is looping, its next\r\n     *           loop completion is used instead of its duration.\r\n     * @return A track entry to allow further customization of animation playback. References to the track entry must not be kept\r\n     *         after the {@link AnimationStateListener#dispose()} event occurs. */\r\n    addEmptyAnimation (trackIndex: number, mixDuration: number, delay: number) {\r\n        if (delay <= 0) delay -= mixDuration;\r\n        let entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);\r\n        entry.mixDuration = mixDuration;\r\n        entry.trackEnd = mixDuration;\r\n        return entry;\r\n    }\r\n\r\n    /** Sets an empty animation for every track, discarding any queued animations, and mixes to it over the specified mix\r\n     * duration. */\r\n    setEmptyAnimations (mixDuration: number) {\r\n        let oldDrainDisabled = this.queue.drainDisabled;\r\n        this.queue.drainDisabled = true;\r\n        for (let i = 0, n = this.tracks.length; i < n; i++) {\r\n            let current = this.tracks[i];\r\n            if (current != null) this.setEmptyAnimation(current.trackIndex, mixDuration);\r\n        }\r\n        this.queue.drainDisabled = oldDrainDisabled;\r\n        this.queue.drain();\r\n    }\r\n\r\n    expandToIndex (index: number) {\r\n        if (index < this.tracks.length) return this.tracks[index];\r\n        Utils.ensureArrayCapacity(this.tracks, index + 1, null);\r\n        this.tracks.length = index + 1;\r\n        return null;\r\n    }\r\n\r\n    /** @param last May be null. */\r\n    trackEntry (trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry) {\r\n        let entry = this.trackEntryPool.obtain();\r\n        entry.trackIndex = trackIndex;\r\n        entry.animation = animation;\r\n        entry.loop = loop;\r\n        entry.holdPrevious = false;\r\n\r\n        entry.eventThreshold = 0;\r\n        entry.attachmentThreshold = 0;\r\n        entry.drawOrderThreshold = 0;\r\n\r\n        entry.animationStart = 0;\r\n        entry.animationEnd = animation.duration;\r\n        entry.animationLast = -1;\r\n        entry.nextAnimationLast = -1;\r\n\r\n        entry.delay = 0;\r\n        entry.trackTime = 0;\r\n        entry.trackLast = -1;\r\n        entry.nextTrackLast = -1;\r\n        entry.trackEnd = Number.MAX_VALUE;\r\n        entry.timeScale = 1;\r\n\r\n        entry.alpha = 1;\r\n        entry.interruptAlpha = 1;\r\n        entry.mixTime = 0;\r\n        entry.mixDuration = last == null ? 0 : this.data.getMix(last.animation, animation);\r\n        entry.mixBlend = MixBlend.replace;\r\n        return entry;\r\n    }\r\n\r\n    disposeNext (entry: TrackEntry) {\r\n        let next = entry.next;\r\n        while (next != null) {\r\n            this.queue.dispose(next);\r\n            next = next.next;\r\n        }\r\n        entry.next = null;\r\n    }\r\n\r\n    _animationsChanged () {\r\n        this.animationsChanged = false;\r\n\r\n        this.propertyIDs.clear();\r\n\r\n        for (let i = 0, n = this.tracks.length; i < n; i++) {\r\n            let entry = this.tracks[i];\r\n            if (entry == null) continue;\r\n            while (entry.mixingFrom != null)\r\n                entry = entry.mixingFrom;\r\n\r\n            do {\r\n                if (entry.mixingFrom == null || entry.mixBlend != MixBlend.add) this.computeHold(entry);\r\n                entry = entry.mixingTo;\r\n            } while (entry != null)\r\n        }\r\n    }\r\n\r\n    computeHold (entry: TrackEntry) {\r\n        let to = entry.mixingTo;\r\n        let timelines = entry.animation.timelines;\r\n        let timelinesCount = entry.animation.timelines.length;\r\n        let timelineMode = Utils.setArraySize(entry.timelineMode, timelinesCount);\r\n        entry.timelineHoldMix.length = 0;\r\n        let timelineDipMix = Utils.setArraySize(entry.timelineHoldMix, timelinesCount);\r\n        let propertyIDs = this.propertyIDs;\r\n\r\n        if (to != null && to.holdPrevious) {\r\n            for (let i = 0; i < timelinesCount; i++) {\r\n                timelineMode[i] = propertyIDs.add(timelines[i].getPropertyId()) ? AnimationState.HOLD_FIRST : AnimationState.HOLD_SUBSEQUENT;\r\n            }\r\n            return;\r\n        }\r\n\r\n        outer:\r\n            for (let i = 0; i < timelinesCount; i++) {\r\n                let timeline = timelines[i];\r\n                let id = timeline.getPropertyId();\r\n                if (!propertyIDs.add(id))\r\n                    timelineMode[i] = AnimationState.SUBSEQUENT;\r\n                else if (to == null || timeline instanceof AttachmentTimeline || timeline instanceof DrawOrderTimeline\r\n                    || timeline instanceof EventTimeline || !to.animation.hasTimeline(id)) {\r\n                    timelineMode[i] = AnimationState.FIRST;\r\n                } else {\r\n                    for (let next = to.mixingTo; next != null; next = next.mixingTo) {\r\n                        if (next.animation.hasTimeline(id)) continue;\r\n                        if (entry.mixDuration > 0) {\r\n                            timelineMode[i] = AnimationState.HOLD_MIX;\r\n                            timelineDipMix[i] = next;\r\n                            continue outer;\r\n                        }\r\n                        break;\r\n                    }\r\n                    timelineMode[i] = AnimationState.HOLD_FIRST;\r\n                }\r\n            }\r\n    }\r\n\r\n    /** Returns the track entry for the animation currently playing on the track, or null if no animation is currently playing. */\r\n    getCurrent (trackIndex: number) {\r\n        if (trackIndex >= this.tracks.length) return null;\r\n        return this.tracks[trackIndex];\r\n    }\r\n\r\n    /** Adds a listener to receive events for all track entries. */\r\n    addListener (listener: AnimationStateListener) {\r\n        if (listener == null) throw new Error(\"listener cannot be null.\");\r\n        this.listeners.push(listener);\r\n    }\r\n\r\n    /** Removes the listener added with {@link #addListener()}. */\r\n    removeListener (listener: AnimationStateListener) {\r\n        let index = this.listeners.indexOf(listener);\r\n        if (index >= 0) this.listeners.splice(index, 1);\r\n    }\r\n\r\n    /** Removes all listeners added with {@link #addListener()}. */\r\n    clearListeners () {\r\n        this.listeners.length = 0;\r\n    }\r\n\r\n    /** Discards all listener notifications that have not yet been delivered. This can be useful to call from an\r\n     * {@link AnimationStateListener} when it is known that further notifications that may have been already queued for delivery\r\n     * are not wanted because new animations are being set. */\r\n    clearListenerNotifications () {\r\n        this.queue.clear();\r\n    }\r\n\r\n    //deprecated stuff\r\n    onComplete: (trackIndex: number, loopCount: number) => any;\r\n    onEvent: (trackIndex: number, event: Event) => any;\r\n    onStart: (trackIndex: number) => any;\r\n    onEnd: (trackIndex: number) => any;\r\n\r\n    private static deprecatedWarning1: boolean = false;\r\n\r\n    setAnimationByName(trackIndex: number, animationName: string, loop: boolean) {\r\n        if (!AnimationState.deprecatedWarning1) {\r\n            AnimationState.deprecatedWarning1 = true;\r\n            console.warn(\"Spine Deprecation Warning: AnimationState.setAnimationByName is deprecated, please use setAnimation from now on.\");\r\n        }\r\n        this.setAnimation(trackIndex, animationName, loop);\r\n    }\r\n\r\n    private static deprecatedWarning2: boolean = false;\r\n\r\n    addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number) {\r\n        if (!AnimationState.deprecatedWarning2) {\r\n            AnimationState.deprecatedWarning2 = true;\r\n            console.warn(\"Spine Deprecation Warning: AnimationState.addAnimationByName is deprecated, please use addAnimation from now on.\");\r\n        }\r\n        this.addAnimation(trackIndex, animationName, loop, delay);\r\n    }\r\n\r\n    private static deprecatedWarning3: boolean = false;\r\n\r\n    hasAnimation(animationName: string): boolean {\r\n        let animation = this.data.skeletonData.findAnimation(animationName);\r\n        return animation !== null;\r\n    }\r\n\r\n    hasAnimationByName(animationName: string): boolean {\r\n        if (!AnimationState.deprecatedWarning3) {\r\n            AnimationState.deprecatedWarning3 = true;\r\n            console.warn(\"Spine Deprecation Warning: AnimationState.hasAnimationByName is deprecated, please use hasAnimation from now on.\");\r\n        }\r\n        return this.hasAnimation(animationName);\r\n    }\r\n}\r\n\r\n/** Stores settings and other state for the playback of an animation on an {@link AnimationState} track.\r\n *\r\n * References to a track entry must not be kept after the {@link AnimationStateListener#dispose()} event occurs. */\r\n/**\r\n * @public\r\n */\r\nexport class TrackEntry implements ITrackEntry {\r\n    /** The animation to apply for this track entry. */\r\n    animation: Animation;\r\n\r\n    /** The animation queued to start after this animation, or null. `next` makes up a linked list. */\r\n    next: TrackEntry;\r\n\r\n    /** The track entry for the previous animation when mixing from the previous animation to this animation, or null if no\r\n     * mixing is currently occuring. When mixing from multiple animations, `mixingFrom` makes up a linked list. */\r\n    mixingFrom: TrackEntry;\r\n\r\n    /** The track entry for the next animation when mixing from this animation to the next animation, or null if no mixing is\r\n     * currently occuring. When mixing to multiple animations, `mixingTo` makes up a linked list. */\r\n    mixingTo: TrackEntry;\r\n\r\n    /** The listener for events generated by this track entry, or null.\r\n     *\r\n     * A track entry returned from {@link AnimationState#setAnimation()} is already the current animation\r\n     * for the track, so the track entry listener {@link AnimationStateListener#start()} will not be called. */\r\n    listener: AnimationStateListener;\r\n\r\n    /** The index of the track where this track entry is either current or queued.\r\n     *\r\n     * See {@link AnimationState#getCurrent()}. */\r\n    trackIndex: number;\r\n\r\n    /** If true, the animation will repeat. If false it will not, instead its last frame is applied if played beyond its\r\n     * duration. */\r\n    loop: boolean;\r\n\r\n    /** If true, when mixing from the previous animation to this animation, the previous animation is applied as normal instead\r\n     * of being mixed out.\r\n     *\r\n     * When mixing between animations that key the same property, if a lower track also keys that property then the value will\r\n     * briefly dip toward the lower track value during the mix. This happens because the first animation mixes from 100% to 0%\r\n     * while the second animation mixes from 0% to 100%. Setting `holdPrevious` to true applies the first animation\r\n     * at 100% during the mix so the lower track value is overwritten. Such dipping does not occur on the lowest track which\r\n     * keys the property, only when a higher track also keys the property.\r\n     *\r\n     * Snapping will occur if `holdPrevious` is true and this animation does not key all the same properties as the\r\n     * previous animation. */\r\n    holdPrevious: boolean;\r\n\r\n    /** When the mix percentage ({@link #mixTime} / {@link #mixDuration}) is less than the\r\n     * `eventThreshold`, event timelines are applied while this animation is being mixed out. Defaults to 0, so event\r\n     * timelines are not applied while this animation is being mixed out. */\r\n    eventThreshold: number;\r\n\r\n    /** When the mix percentage ({@link #mixtime} / {@link #mixDuration}) is less than the\r\n     * `attachmentThreshold`, attachment timelines are applied while this animation is being mixed out. Defaults to\r\n     * 0, so attachment timelines are not applied while this animation is being mixed out. */\r\n    attachmentThreshold: number;\r\n\r\n    /** When the mix percentage ({@link #mixTime} / {@link #mixDuration}) is less than the\r\n     * `drawOrderThreshold`, draw order timelines are applied while this animation is being mixed out. Defaults to 0,\r\n     * so draw order timelines are not applied while this animation is being mixed out. */\r\n    drawOrderThreshold: number;\r\n\r\n    /** Seconds when this animation starts, both initially and after looping. Defaults to 0.\r\n     *\r\n     * When changing the `animationStart` time, it often makes sense to set {@link #animationLast} to the same\r\n     * value to prevent timeline keys before the start time from triggering. */\r\n    animationStart: number;\r\n\r\n    /** Seconds for the last frame of this animation. Non-looping animations won't play past this time. Looping animations will\r\n     * loop back to {@link #animationStart} at this time. Defaults to the animation {@link Animation#duration}. */\r\n    animationEnd: number;\r\n\r\n\r\n    /** The time in seconds this animation was last applied. Some timelines use this for one-time triggers. Eg, when this\r\n     * animation is applied, event timelines will fire all events between the `animationLast` time (exclusive) and\r\n     * `animationTime` (inclusive). Defaults to -1 to ensure triggers on frame 0 happen the first time this animation\r\n     * is applied. */\r\n    animationLast: number;\r\n\r\n    nextAnimationLast: number;\r\n\r\n    /** Seconds to postpone playing the animation. When this track entry is the current track entry, `delay`\r\n     * postpones incrementing the {@link #trackTime}. When this track entry is queued, `delay` is the time from\r\n     * the start of the previous animation to when this track entry will become the current track entry (ie when the previous\r\n     * track entry {@link TrackEntry#trackTime} >= this track entry's `delay`).\r\n     *\r\n     * {@link #timeScale} affects the delay. */\r\n    delay: number;\r\n\r\n    /** Current time in seconds this track entry has been the current track entry. The track time determines\r\n     * {@link #animationTime}. The track time can be set to start the animation at a time other than 0, without affecting\r\n     * looping. */\r\n    trackTime: number;\r\n\r\n    trackLast: number; nextTrackLast: number;\r\n\r\n    /** The track time in seconds when this animation will be removed from the track. Defaults to the highest possible float\r\n     * value, meaning the animation will be applied until a new animation is set or the track is cleared. If the track end time\r\n     * is reached, no other animations are queued for playback, and mixing from any previous animations is complete, then the\r\n     * properties keyed by the animation are set to the setup pose and the track is cleared.\r\n     *\r\n     * It may be desired to use {@link AnimationState#addEmptyAnimation()} rather than have the animation\r\n     * abruptly cease being applied. */\r\n    trackEnd: number;\r\n\r\n    /** Multiplier for the delta time when this track entry is updated, causing time for this animation to pass slower or\r\n     * faster. Defaults to 1.\r\n     *\r\n     * {@link #mixTime} is not affected by track entry time scale, so {@link #mixDuration} may need to be adjusted to\r\n     * match the animation speed.\r\n     *\r\n     * When using {@link AnimationState#addAnimation()} with a `delay` <= 0, note the\r\n     * {@link #delay} is set using the mix duration from the {@link AnimationStateData}, assuming time scale to be 1. If\r\n     * the time scale is not 1, the delay may need to be adjusted.\r\n     *\r\n     * See AnimationState {@link AnimationState#timeScale} for affecting all animations. */\r\n    timeScale: number;\r\n\r\n    /** Values < 1 mix this animation with the skeleton's current pose (usually the pose resulting from lower tracks). Defaults\r\n     * to 1, which overwrites the skeleton's current pose with this animation.\r\n     *\r\n     * Typically track 0 is used to completely pose the skeleton, then alpha is used on higher tracks. It doesn't make sense to\r\n     * use alpha on track 0 if the skeleton pose is from the last frame render. */\r\n    alpha: number;\r\n\r\n    /** Seconds from 0 to the {@link #getMixDuration()} when mixing from the previous animation to this animation. May be\r\n     * slightly more than `mixDuration` when the mix is complete. */\r\n    mixTime: number;\r\n\r\n    /** Seconds for mixing from the previous animation to this animation. Defaults to the value provided by AnimationStateData\r\n     * {@link AnimationStateData#getMix()} based on the animation before this animation (if any).\r\n     *\r\n     * A mix duration of 0 still mixes out over one frame to provide the track entry being mixed out a chance to revert the\r\n     * properties it was animating.\r\n     *\r\n     * The `mixDuration` can be set manually rather than use the value from\r\n     * {@link AnimationStateData#getMix()}. In that case, the `mixDuration` can be set for a new\r\n     * track entry only before {@link AnimationState#update(float)} is first called.\r\n     *\r\n     * When using {@link AnimationState#addAnimation()} with a `delay` <= 0, note the\r\n     * {@link #delay} is set using the mix duration from the {@link AnimationStateData}, not a mix duration set\r\n     * afterward. */\r\n    mixDuration: number; interruptAlpha: number; totalAlpha: number;\r\n\r\n    /** Controls how properties keyed in the animation are mixed with lower tracks. Defaults to {@link MixBlend#replace}, which\r\n     * replaces the values from the lower tracks with the animation values. {@link MixBlend#add} adds the animation values to\r\n     * the values from the lower tracks.\r\n     *\r\n     * The `mixBlend` can be set for a new track entry only before {@link AnimationState#apply()} is first\r\n     * called. */\r\n    mixBlend = MixBlend.replace;\r\n    timelineMode = new Array<number>();\r\n    timelineHoldMix = new Array<TrackEntry>();\r\n    timelinesRotation = new Array<number>();\r\n\r\n    reset () {\r\n        this.next = null;\r\n        this.mixingFrom = null;\r\n        this.mixingTo = null;\r\n        this.animation = null;\r\n        this.listener = null;\r\n        this.timelineMode.length = 0;\r\n        this.timelineHoldMix.length = 0;\r\n        this.timelinesRotation.length = 0;\r\n    }\r\n\r\n    /** Uses {@link #trackTime} to compute the `animationTime`, which is between {@link #animationStart}\r\n     * and {@link #animationEnd}. When the `trackTime` is 0, the `animationTime` is equal to the\r\n     * `animationStart` time. */\r\n    getAnimationTime () {\r\n        if (this.loop) {\r\n            let duration = this.animationEnd - this.animationStart;\r\n            if (duration == 0) return this.animationStart;\r\n            return (this.trackTime % duration) + this.animationStart;\r\n        }\r\n        return Math.min(this.trackTime + this.animationStart, this.animationEnd);\r\n    }\r\n\r\n    setAnimationLast(animationLast: number) {\r\n        this.animationLast = animationLast;\r\n        this.nextAnimationLast = animationLast;\r\n    }\r\n\r\n    /** Returns true if at least one loop has been completed.\r\n     *\r\n     * See {@link AnimationStateListener#complete()}. */\r\n    isComplete () {\r\n        return this.trackTime >= this.animationEnd - this.animationStart;\r\n    }\r\n\r\n    /** Resets the rotation directions for mixing this entry's rotate timelines. This can be useful to avoid bones rotating the\r\n     * long way around when using {@link #alpha} and starting animations on other tracks.\r\n     *\r\n     * Mixing with {@link MixBlend#replace} involves finding a rotation between two others, which has two possible solutions:\r\n     * the short way or the long way around. The two rotations likely change over time, so which direction is the short or long\r\n     * way also changes. If the short way was always chosen, bones would flip to the other side when that direction became the\r\n     * long way. TrackEntry chooses the short way the first time it is applied and remembers that direction. */\r\n    resetRotationDirections () {\r\n        this.timelinesRotation.length = 0;\r\n    }\r\n\r\n    //deprecated stuff\r\n    onComplete: (trackIndex: number, loopCount: number) => any;\r\n    onEvent: (trackIndex: number, event: Event) => any;\r\n    onStart: (trackIndex: number) => any;\r\n    onEnd: (trackIndex: number) => any;\r\n\r\n    private static deprecatedWarning1: Boolean = false;\r\n    private static deprecatedWarning2: Boolean = false;\r\n\r\n    get time() {\r\n        if (!TrackEntry.deprecatedWarning1) {\r\n            TrackEntry.deprecatedWarning1 = true;\r\n            console.warn(\"Spine Deprecation Warning: TrackEntry.time is deprecated, please use trackTime from now on.\");\r\n        }\r\n        return this.trackTime;\r\n    }\r\n\r\n    set time(value: number) {\r\n        if (!TrackEntry.deprecatedWarning1) {\r\n            TrackEntry.deprecatedWarning1 = true;\r\n            console.warn(\"Spine Deprecation Warning: TrackEntry.time is deprecated, please use trackTime from now on.\");\r\n        }\r\n        this.trackTime = value;\r\n    }\r\n\r\n    get endTime() {\r\n        if (!TrackEntry.deprecatedWarning2) {\r\n            TrackEntry.deprecatedWarning2 = true;\r\n            console.warn(\"Spine Deprecation Warning: TrackEntry.endTime is deprecated, please use trackEnd from now on.\");\r\n        }\r\n        return this.trackTime;\r\n    }\r\n\r\n    set endTime(value: number) {\r\n        if (!TrackEntry.deprecatedWarning2) {\r\n            TrackEntry.deprecatedWarning2 = true;\r\n            console.warn(\"Spine Deprecation Warning: TrackEntry.endTime is deprecated, please use trackEnd from now on.\");\r\n        }\r\n        this.trackTime = value;\r\n    }\r\n\r\n    loopsCount() {\r\n        return Math.floor(this.trackTime / this.trackEnd);\r\n    }\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport class EventQueue {\r\n    objects: Array<any> = [];\r\n    drainDisabled = false;\r\n    animState: AnimationState;\r\n\r\n    constructor(animState: AnimationState) {\r\n        this.animState = animState;\r\n    }\r\n\r\n    start (entry: TrackEntry) {\r\n        this.objects.push(EventType.start);\r\n        this.objects.push(entry);\r\n        this.animState.animationsChanged = true;\r\n    }\r\n\r\n    interrupt (entry: TrackEntry) {\r\n        this.objects.push(EventType.interrupt);\r\n        this.objects.push(entry);\r\n    }\r\n\r\n    end (entry: TrackEntry) {\r\n        this.objects.push(EventType.end);\r\n        this.objects.push(entry);\r\n        this.animState.animationsChanged = true;\r\n    }\r\n\r\n    dispose (entry: TrackEntry) {\r\n        this.objects.push(EventType.dispose);\r\n        this.objects.push(entry);\r\n    }\r\n\r\n    complete (entry: TrackEntry) {\r\n        this.objects.push(EventType.complete);\r\n        this.objects.push(entry);\r\n    }\r\n\r\n    event (entry: TrackEntry, event: Event) {\r\n        this.objects.push(EventType.event);\r\n        this.objects.push(entry);\r\n        this.objects.push(event);\r\n    }\r\n\r\n    private static deprecatedWarning1: Boolean = false;\r\n\r\n    deprecateStuff() {\r\n        if (!EventQueue.deprecatedWarning1) {\r\n            EventQueue.deprecatedWarning1 = true;\r\n            console.warn(\"Spine Deprecation Warning: onComplete, onStart, onEnd, onEvent art deprecated, please use listeners from now on. 'state.addListener({ complete: function(track, event) { } })'\");\r\n        }\r\n        return true;\r\n    }\r\n\r\n    drain () {\r\n        if (this.drainDisabled) return;\r\n        this.drainDisabled = true;\r\n\r\n        let objects = this.objects;\r\n        let listeners = this.animState.listeners;\r\n\r\n        for (let i = 0; i < objects.length; i += 2) {\r\n            let type = objects[i] as EventType;\r\n            let entry = objects[i + 1] as TrackEntry;\r\n            switch (type) {\r\n                case EventType.start:\r\n                    if (entry.listener != null && entry.listener.start) entry.listener.start(entry);\r\n                    for (let ii = 0; ii < listeners.length; ii++)\r\n                        if (listeners[ii].start) listeners[ii].start(entry);\r\n                    //deprecation\r\n                    entry.onStart && this.deprecateStuff() && entry.onStart(entry.trackIndex);\r\n                    this.animState.onStart && this.deprecateStuff() && this.deprecateStuff && this.animState.onStart(entry.trackIndex);\r\n                    break;\r\n                case EventType.interrupt:\r\n                    if (entry.listener != null && entry.listener.interrupt) entry.listener.interrupt(entry);\r\n                    for (let ii = 0; ii < listeners.length; ii++)\r\n                        if (listeners[ii].interrupt) listeners[ii].interrupt(entry);\r\n                    break;\r\n                case EventType.end:\r\n                    if (entry.listener != null && entry.listener.end) entry.listener.end(entry);\r\n                    for (let ii = 0; ii < listeners.length; ii++)\r\n                        if (listeners[ii].end) listeners[ii].end(entry);\r\n                    //deprecation\r\n                    entry.onEnd && this.deprecateStuff() && entry.onEnd(entry.trackIndex);\r\n                    this.animState.onEnd && this.deprecateStuff() && this.animState.onEnd(entry.trackIndex);\r\n                // Fall through.\r\n                case EventType.dispose:\r\n                    if (entry.listener != null && entry.listener.dispose) entry.listener.dispose(entry);\r\n                    for (let ii = 0; ii < listeners.length; ii++)\r\n                        if (listeners[ii].dispose) listeners[ii].dispose(entry);\r\n                    this.animState.trackEntryPool.free(entry);\r\n                    break;\r\n                case EventType.complete:\r\n                    if (entry.listener != null && entry.listener.complete) entry.listener.complete(entry);\r\n                    for (let ii = 0; ii < listeners.length; ii++)\r\n                        if (listeners[ii].complete) listeners[ii].complete(entry);\r\n                    //deprecation\r\n\r\n                    let count = MathUtils.toInt(entry.loopsCount()) ;\r\n                    entry.onComplete && this.deprecateStuff() && entry.onComplete(entry.trackIndex, count);\r\n                    this.animState.onComplete && this.deprecateStuff() && this.animState.onComplete(entry.trackIndex, count);\r\n                    break;\r\n                case EventType.event:\r\n                    let event = objects[i++ + 2] as Event;\r\n                    if (entry.listener != null && entry.listener.event) entry.listener.event(entry, event);\r\n                    for (let ii = 0; ii < listeners.length; ii++)\r\n                        if (listeners[ii].event) listeners[ii].event(entry, event);\r\n                    //deprecation\r\n                    entry.onEvent && this.deprecateStuff() && entry.onEvent(entry.trackIndex, event);\r\n                    this.animState.onEvent && this.deprecateStuff() && this.animState.onEvent(entry.trackIndex, event);\r\n                    break;\r\n            }\r\n        }\r\n        this.clear();\r\n\r\n        this.drainDisabled = false;\r\n    }\r\n\r\n    clear () {\r\n        this.objects.length = 0;\r\n    }\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport enum EventType {\r\n    start, interrupt, end, dispose, complete, event\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport interface AnimationStateListener extends IAnimationStateListener {\r\n    /** Invoked when this entry has been set as the current entry. */\r\n    start? (entry: TrackEntry): void;\r\n\r\n    /** Invoked when another entry has replaced this entry as the current entry. This entry may continue being applied for\r\n     * mixing. */\r\n    interrupt? (entry: TrackEntry): void;\r\n\r\n    /** Invoked when this entry is no longer the current entry and will never be applied again. */\r\n    end? (entry: TrackEntry): void;\r\n\r\n    /** Invoked when this entry will be disposed. This may occur without the entry ever being set as the current entry.\r\n     * References to the entry should not be kept after dispose is called, as it may be destroyed or reused. */\r\n    dispose? (entry: TrackEntry): void;\r\n\r\n    /** Invoked every time this entry's animation completes a loop. */\r\n    complete? (entry: TrackEntry): void;\r\n\r\n    /** Invoked when this entry's animation triggers an event. */\r\n    event? (entry: TrackEntry, event: Event): void;\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport abstract class AnimationStateAdapter implements AnimationStateListener {\r\n    start (entry: TrackEntry) {\r\n    }\r\n\r\n    interrupt (entry: TrackEntry) {\r\n    }\r\n\r\n    end (entry: TrackEntry) {\r\n    }\r\n\r\n    dispose (entry: TrackEntry) {\r\n    }\r\n\r\n    complete (entry: TrackEntry) {\r\n    }\r\n\r\n    event (entry: TrackEntry, event: Event) {\r\n    }\r\n}\r\n","import {ConstraintData} from \"./Constraint\";\r\nimport type {SlotData} from \"./SlotData\";\r\nimport type {BoneData} from \"./BoneData\";\r\nimport { RotateMode, PositionMode } from \"@pixi-spine/base\";\r\n\r\n/**\r\n * @public\r\n */\r\nexport class PathConstraintData extends ConstraintData {\r\n    bones = new Array<BoneData>();\r\n    target: SlotData;\r\n    positionMode: PositionMode;\r\n    spacingMode: SpacingMode;\r\n    rotateMode: RotateMode;\r\n    offsetRotation: number;\r\n    position: number; spacing: number; rotateMix: number; translateMix: number;\r\n\r\n    constructor (name: string) {\r\n        super(name, 0, false);\r\n    }\r\n}\r\n/**\r\n * @public\r\n */\r\nexport enum SpacingMode {\r\n    Length, Fixed, Percent\r\n}\r\n","import {SkeletonData} from \"./SkeletonData\";\r\nimport {IAnimation, IAnimationStateData, Map} from '@pixi-spine/base';\r\nimport type { Animation } from \"./Animation\";\r\n\r\n/**\r\n * @public\r\n */\r\nexport class AnimationStateData implements IAnimationStateData<SkeletonData, Animation> {\r\n    skeletonData: SkeletonData;\r\n    animationToMixTime: Map<number> = {};\r\n    defaultMix = 0;\r\n\r\n    constructor(skeletonData: SkeletonData) {\r\n        if (skeletonData == null) throw new Error(\"skeletonData cannot be null.\");\r\n        this.skeletonData = skeletonData;\r\n    }\r\n\r\n    setMix(fromName: string, toName: string, duration: number) {\r\n        let from = this.skeletonData.findAnimation(fromName);\r\n        if (from == null) throw new Error(\"Animation not found: \" + fromName);\r\n        let to = this.skeletonData.findAnimation(toName);\r\n        if (to == null) throw new Error(\"Animation not found: \" + toName);\r\n        this.setMixWith(from, to, duration);\r\n    }\r\n\r\n    private static deprecatedWarning1: boolean = false;\r\n\r\n    setMixByName(fromName: string, toName: string, duration: number) {\r\n        if (!AnimationStateData.deprecatedWarning1) {\r\n            AnimationStateData.deprecatedWarning1 = true;\r\n            console.warn(\"Deprecation Warning: AnimationStateData.setMixByName is deprecated, please use setMix from now on.\");\r\n        }\r\n        this.setMix(fromName, toName, duration);\r\n    }\r\n\r\n    setMixWith(from: IAnimation, to: IAnimation, duration: number) {\r\n        if (from == null) throw new Error(\"from cannot be null.\");\r\n        if (to == null) throw new Error(\"to cannot be null.\");\r\n        let key = from.name + \".\" + to.name;\r\n        this.animationToMixTime[key] = duration;\r\n    }\r\n\r\n    getMix(from: IAnimation, to: IAnimation) {\r\n        let key = from.name + \".\" + to.name;\r\n        let value = this.animationToMixTime[key];\r\n        return value === undefined ? this.defaultMix : value;\r\n    }\r\n}\r\n","import {AttachmentLoader, RegionAttachment, MeshAttachment, BoundingBoxAttachment,\r\n    PathAttachment, PointAttachment, ClippingAttachment} from './attachments';\r\nimport type {TextureAtlas} from \"@pixi-spine/base\";\r\nimport type {Skin} from \"./Skin\";\r\n\r\n/**\r\n * @public\r\n */\r\nexport class AtlasAttachmentLoader implements AttachmentLoader {\r\n    atlas: TextureAtlas;\r\n\r\n    constructor(atlas: TextureAtlas) {\r\n        this.atlas = atlas;\r\n    }\r\n\r\n    /** @return May be null to not load an attachment. */\r\n    newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment {\r\n        let region = this.atlas.findRegion(path);\r\n        if (region == null) throw new Error(\"Region not found in atlas: \" + path + \" (region attachment: \" + name + \")\");\r\n        let attachment = new RegionAttachment(name);\r\n        attachment.region = region;\r\n        return attachment;\r\n    }\r\n\r\n    /** @return May be null to not load an attachment. */\r\n    newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment {\r\n        let region = this.atlas.findRegion(path);\r\n        if (region == null) throw new Error(\"Region not found in atlas: \" + path + \" (mesh attachment: \" + name + \")\");\r\n        let attachment = new MeshAttachment(name);\r\n        attachment.region = region;\r\n        return attachment;\r\n    }\r\n\r\n    /** @return May be null to not load an attachment. */\r\n    newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment {\r\n        return new BoundingBoxAttachment(name);\r\n    }\r\n\r\n    /** @return May be null to not load an attachment */\r\n    newPathAttachment(skin: Skin, name: string): PathAttachment {\r\n        return new PathAttachment(name);\r\n    }\r\n\r\n    newPointAttachment(skin: Skin, name: string): PointAttachment {\r\n        return new PointAttachment(name);\r\n    }\r\n\r\n    newClippingAttachment(skin: Skin, name: string): ClippingAttachment {\r\n        return new ClippingAttachment(name);\r\n    }\r\n}\r\n","import {Matrix} from '@pixi/math';\r\nimport {Updatable} from \"./Updatable\";\r\nimport {BoneData} from \"./BoneData\";\r\nimport {Skeleton} from \"./Skeleton\";\r\nimport {IBone, MathUtils, settings, TransformMode, Vector2} from \"@pixi-spine/base\";\r\n\r\n/**\r\n * @public\r\n */\r\nexport class Bone implements Updatable, IBone {\r\n    //be careful! Spine b,c is c,b in pixi matrix\r\n    matrix = new Matrix();\r\n\r\n    get worldX(): number {\r\n        return this.matrix.tx;\r\n    }\r\n\r\n    get worldY(): number {\r\n        return this.matrix.ty;\r\n    }\r\n\r\n    data: BoneData;\r\n    skeleton: Skeleton;\r\n    parent: Bone;\r\n    children = new Array<Bone>();\r\n    x = 0;\r\n    y = 0;\r\n    rotation = 0;\r\n    scaleX = 0;\r\n    scaleY = 0;\r\n    shearX = 0;\r\n    shearY = 0;\r\n    ax = 0;\r\n    ay = 0;\r\n    arotation = 0;\r\n    ascaleX = 0;\r\n    ascaleY = 0;\r\n    ashearX = 0;\r\n    ashearY = 0;\r\n    appliedValid = false;\r\n\r\n    sorted = false;\r\n    active = false;\r\n\r\n    /** @param parent May be null. */\r\n    constructor(data: BoneData, skeleton: Skeleton, parent: Bone) {\r\n        if (data == null) throw new Error(\"data cannot be null.\");\r\n        if (skeleton == null) throw new Error(\"skeleton cannot be null.\");\r\n        this.data = data;\r\n        this.skeleton = skeleton;\r\n        this.parent = parent;\r\n        this.setToSetupPose();\r\n    }\r\n\r\n    isActive () {\r\n        return this.active;\r\n    }\r\n\r\n    /** Same as {@link #updateWorldTransform()}. This method exists for Bone to implement {@link Updatable}. */\r\n    update() {\r\n        this.updateWorldTransformWith(this.x, this.y, this.rotation, this.scaleX, this.scaleY, this.shearX, this.shearY);\r\n    }\r\n\r\n    /** Computes the world transform using the parent bone and this bone's local transform. */\r\n    updateWorldTransform() {\r\n        this.updateWorldTransformWith(this.x, this.y, this.rotation, this.scaleX, this.scaleY, this.shearX, this.shearY);\r\n    }\r\n\r\n    /** Computes the world transform using the parent bone and the specified local transform. */\r\n    updateWorldTransformWith(x: number, y: number, rotation: number, scaleX: number, scaleY: number, shearX: number, shearY: number) {\r\n        this.ax = x;\r\n        this.ay = y;\r\n        this.arotation = rotation;\r\n        this.ascaleX = scaleX;\r\n        this.ascaleY = scaleY;\r\n        this.ashearX = shearX;\r\n        this.ashearY = shearY;\r\n        this.appliedValid = true;\r\n\r\n        let parent = this.parent;\r\n        let m = this.matrix;\r\n\r\n        let sx = this.skeleton.scaleX;\r\n        let sy = settings.yDown? -this.skeleton.scaleY : this.skeleton.scaleY;\r\n\r\n        if (parent == null) { // Root bone.\r\n            let skeleton = this.skeleton;\r\n            let rotationY = rotation + 90 + shearY;\r\n            m.a = MathUtils.cosDeg(rotation + shearX) * scaleX * sx;\r\n            m.c = MathUtils.cosDeg(rotationY) * scaleY * sx;\r\n            m.b = MathUtils.sinDeg(rotation + shearX) * scaleX * sy;\r\n            m.d = MathUtils.sinDeg(rotationY) * scaleY * sy;\r\n            m.tx = x * sx + skeleton.x;\r\n            m.ty = y * sy + skeleton.y;\r\n            return;\r\n        }\r\n\r\n        let pa = parent.matrix.a, pb = parent.matrix.c, pc = parent.matrix.b, pd = parent.matrix.d;\r\n        m.tx = pa * x + pb * y + parent.matrix.tx;\r\n        m.ty = pc * x + pd * y + parent.matrix.ty;\r\n        switch (this.data.transformMode) {\r\n            case TransformMode.Normal: {\r\n                let rotationY = rotation + 90 + shearY;\r\n                let la = MathUtils.cosDeg(rotation + shearX) * scaleX;\r\n                let lb = MathUtils.cosDeg(rotationY) * scaleY;\r\n                let lc = MathUtils.sinDeg(rotation + shearX) * scaleX;\r\n                let ld = MathUtils.sinDeg(rotationY) * scaleY;\r\n                m.a = pa * la + pb * lc;\r\n                m.c = pa * lb + pb * ld;\r\n                m.b = pc * la + pd * lc;\r\n                m.d = pc * lb + pd * ld;\r\n                return;\r\n            }\r\n            case TransformMode.OnlyTranslation: {\r\n                let rotationY = rotation + 90 + shearY;\r\n                m.a = MathUtils.cosDeg(rotation + shearX) * scaleX;\r\n                m.c = MathUtils.cosDeg(rotationY) * scaleY;\r\n                m.b = MathUtils.sinDeg(rotation + shearX) * scaleX;\r\n                m.d = MathUtils.sinDeg(rotationY) * scaleY;\r\n                break;\r\n            }\r\n            case TransformMode.NoRotationOrReflection: {\r\n                let s = pa * pa + pc * pc;\r\n                let prx = 0;\r\n                if (s > 0.0001) {\r\n                    s = Math.abs(pa * pd - pb * pc) / s;\r\n                    pa /= this.skeleton.scaleX;\r\n                    pc /= this.skeleton.scaleY;\r\n                    pb = pc * s;\r\n                    pd = pa * s;\r\n                    prx = Math.atan2(pc, pa) * MathUtils.radDeg;\r\n                } else {\r\n                    pa = 0;\r\n                    pc = 0;\r\n                    prx = 90 - Math.atan2(pd, pb) * MathUtils.radDeg;\r\n                }\r\n                let rx = rotation + shearX - prx;\r\n                let ry = rotation + shearY - prx + 90;\r\n                let la = MathUtils.cosDeg(rx) * scaleX;\r\n                let lb = MathUtils.cosDeg(ry) * scaleY;\r\n                let lc = MathUtils.sinDeg(rx) * scaleX;\r\n                let ld = MathUtils.sinDeg(ry) * scaleY;\r\n                m.a = pa * la - pb * lc;\r\n                m.c = pa * lb - pb * ld;\r\n                m.b = pc * la + pd * lc;\r\n                m.d = pc * lb + pd * ld;\r\n                break;\r\n            }\r\n            case TransformMode.NoScale:\r\n            case TransformMode.NoScaleOrReflection: {\r\n                let cos = MathUtils.cosDeg(rotation);\r\n                let sin = MathUtils.sinDeg(rotation);\r\n                let za = (pa * cos + pb * sin) / sx;\r\n                let zc = (pc * cos + pd * sin) / sy;\r\n                let s = Math.sqrt(za * za + zc * zc);\r\n                if (s > 0.00001) s = 1 / s;\r\n                za *= s;\r\n                zc *= s;\r\n                s = Math.sqrt(za * za + zc * zc);\r\n                if (\r\n                    this.data.transformMode == TransformMode.NoScale\r\n                    && (pa * pd - pb * pc < 0) != (settings.yDown?\r\n                    (this.skeleton.scaleX < 0 != this.skeleton.scaleY > 0) :\r\n                        (this.skeleton.scaleX < 0 != this.skeleton.scaleY < 0))\r\n                ) s = -s;\r\n                let r = Math.PI / 2 + Math.atan2(zc, za);\r\n                let zb = Math.cos(r) * s;\r\n                let zd = Math.sin(r) * s;\r\n                let la = MathUtils.cosDeg(shearX) * scaleX;\r\n                let lb = MathUtils.cosDeg(90 + shearY) * scaleY;\r\n                let lc = MathUtils.sinDeg(shearX) * scaleX;\r\n                let ld = MathUtils.sinDeg(90 + shearY) * scaleY;\r\n                m.a = za * la + zb * lc;\r\n                m.c = za * lb + zb * ld;\r\n                m.b = zc * la + zd * lc;\r\n                m.d = zc * lb + zd * ld;\r\n                break;\r\n            }\r\n        }\r\n        m.a *= sx;\r\n        m.c *= sx;\r\n        m.b *= sy;\r\n        m.d *= sy;\r\n    }\r\n\r\n    setToSetupPose() {\r\n        let data = this.data;\r\n        this.x = data.x;\r\n        this.y = data.y;\r\n        this.rotation = data.rotation;\r\n        this.scaleX = data.scaleX;\r\n        this.scaleY = data.scaleY;\r\n        this.shearX = data.shearX;\r\n        this.shearY = data.shearY;\r\n    }\r\n\r\n    getWorldRotationX() {\r\n        return Math.atan2(this.matrix.b, this.matrix.a) * MathUtils.radDeg;\r\n    }\r\n\r\n    getWorldRotationY() {\r\n        return Math.atan2(this.matrix.d, this.matrix.c) * MathUtils.radDeg;\r\n    }\r\n\r\n    getWorldScaleX() {\r\n        let m = this.matrix;\r\n        return Math.sqrt(m.a * m.a + m.c * m.c);\r\n    }\r\n\r\n    getWorldScaleY() {\r\n        let m = this.matrix;\r\n        return Math.sqrt(m.b * m.b + m.d * m.d);\r\n    }\r\n\r\n    /** Computes the individual applied transform values from the world transform. This can be useful to perform processing using\r\n     * the applied transform after the world transform has been modified directly (eg, by a constraint).\r\n     * <p>\r\n     * Some information is ambiguous in the world transform, such as -1,-1 scale versus 180 rotation. */\r\n    updateAppliedTransform() {\r\n        this.appliedValid = true;\r\n        let parent = this.parent;\r\n        let m = this.matrix;\r\n        if (parent == null) {\r\n            this.ax = m.tx;\r\n            this.ay = m.ty;\r\n            this.arotation = Math.atan2(m.b, m.a) * MathUtils.radDeg;\r\n            this.ascaleX = Math.sqrt(m.a * m.a + m.b * m.b);\r\n            this.ascaleY = Math.sqrt(m.c * m.c + m.d * m.d);\r\n            this.ashearX = 0;\r\n            this.ashearY = Math.atan2(m.a * m.c + m.b * m.d, m.a * m.d - m.b * m.c) * MathUtils.radDeg;\r\n            return;\r\n        }\r\n        let pm = parent.matrix;\r\n        let pid = 1 / (pm.a * pm.d - pm.b * pm.c);\r\n        let dx = m.tx - pm.tx, dy = m.ty - pm.ty;\r\n        this.ax = (dx * pm.d * pid - dy * pm.c * pid);\r\n        this.ay = (dy * pm.a * pid - dx * pm.b * pid);\r\n        let ia = pid * pm.d;\r\n        let id = pid * pm.a;\r\n        let ib = pid * pm.c;\r\n        let ic = pid * pm.b;\r\n        let ra = ia * m.a - ib * m.b;\r\n        let rb = ia * m.c - ib * m.d;\r\n        let rc = id * m.b - ic * m.a;\r\n        let rd = id * m.d - ic * m.c;\r\n        this.ashearX = 0;\r\n        this.ascaleX = Math.sqrt(ra * ra + rc * rc);\r\n        if (this.ascaleX > 0.0001) {\r\n            let det = ra * rd - rb * rc;\r\n            this.ascaleY = det / this.ascaleX;\r\n            this.ashearY = Math.atan2(ra * rb + rc * rd, det) * MathUtils.radDeg;\r\n            this.arotation = Math.atan2(rc, ra) * MathUtils.radDeg;\r\n        } else {\r\n            this.ascaleX = 0;\r\n            this.ascaleY = Math.sqrt(rb * rb + rd * rd);\r\n            this.ashearY = 0;\r\n            this.arotation = 90 - Math.atan2(rd, rb) * MathUtils.radDeg;\r\n        }\r\n    }\r\n\r\n    worldToLocal(world: Vector2) {\r\n        let m = this.matrix;\r\n        let a = m.a, b = m.c, c = m.b, d = m.d;\r\n        let invDet = 1 / (a * d - b * c);\r\n        let x = world.x - m.tx, y = world.y - m.ty;\r\n        world.x = (x * d * invDet - y * b * invDet);\r\n        world.y = (y * a * invDet - x * c * invDet);\r\n        return world;\r\n    }\r\n\r\n    localToWorld(local: Vector2) {\r\n        let m = this.matrix;\r\n        let x = local.x, y = local.y;\r\n        local.x = x * m.a + y * m.c + m.tx;\r\n        local.y = x * m.b + y * m.d + m.ty;\r\n        return local;\r\n    }\r\n\r\n    worldToLocalRotation (worldRotation: number) {\r\n        let sin = MathUtils.sinDeg(worldRotation), cos = MathUtils.cosDeg(worldRotation);\r\n        let mat = this.matrix;\r\n        return Math.atan2(mat.a * sin - mat.b * cos, mat.d * cos - mat.c * sin) * MathUtils.radDeg;\r\n    }\r\n\r\n    localToWorldRotation (localRotation: number) {\r\n        let sin = MathUtils.sinDeg(localRotation), cos = MathUtils.cosDeg(localRotation);\r\n        let mat = this.matrix;\r\n        return Math.atan2(cos * mat.b + sin * mat.d, cos * mat.a + sin * mat.c) * MathUtils.radDeg;\r\n    }\r\n\r\n    rotateWorld (degrees: number) {\r\n        let mat = this.matrix;\r\n        let a = mat.a, b = mat.c, c = mat.b, d = mat.d;\r\n        let cos = MathUtils.cosDeg(degrees), sin = MathUtils.sinDeg(degrees);\r\n        mat.a = cos * a - sin * c;\r\n        mat.c = cos * b - sin * d;\r\n        mat.b = sin * a + cos * c;\r\n        mat.d = sin * b + cos * d;\r\n        this.appliedValid = false;\r\n    }\r\n}\r\n","import {Color, TransformMode} from '@pixi-spine/base';\r\n\r\n/**\r\n * @public\r\n */\r\nexport class BoneData {\r\n    index: number;\r\n    name: string;\r\n    parent: BoneData;\r\n    length: number;\r\n    x = 0;\r\n    y = 0;\r\n    rotation = 0;\r\n    scaleX = 1;\r\n    scaleY = 1;\r\n    shearX = 0;\r\n    shearY = 0;\r\n    transformMode = TransformMode.Normal;\r\n    skinRequired = false;\r\n\r\n    color = new Color();\r\n\r\n    constructor(index: number, name: string, parent: BoneData) {\r\n        if (index < 0) throw new Error(\"index must be >= 0.\");\r\n        if (name == null) throw new Error(\"name cannot be null.\");\r\n        this.index = index;\r\n        this.name = name;\r\n        this.parent = parent;\r\n    }\r\n}\r\n","/**\r\n * @public\r\n */\r\nexport abstract class ConstraintData {\r\n    constructor(public name: string, public order: number, public skinRequired: boolean) { }\r\n}\r\n","import {EventData} from \"./EventData\";\nimport {IEvent} from \"@pixi-spine/base\";\n\n/**\n * @public\n */\nexport class Event implements IEvent {\n    data: EventData;\n    intValue: number;\n    floatValue: number;\n    stringValue: string;\n    time: number;\n    volume: number;\n    balance: number;\n\n\n    constructor(time: number, data: EventData) {\n        if (data == null) throw new Error(\"data cannot be null.\");\n        this.time = time;\n        this.data = data;\n    }\n}\n","import {IEventData} from \"@pixi-spine/base\";\n\n/**\n * @public\n */\nexport class EventData implements IEventData {\n    name: string;\n    intValue: number;\n    floatValue: number;\n    stringValue: string;\n    audioPath: string;\n    volume: number;\n    balance: number;\n\n    constructor (name: string) {\n        this.name = name;\n    }\n}\n","import {Updatable} from \"./Updatable\";\r\nimport {IkConstraintData} from \"./IkConstraintData\";\r\nimport {Bone} from \"./Bone\";\r\nimport {Skeleton} from \"./Skeleton\";\r\nimport {IIkConstraint, MathUtils, TransformMode} from \"@pixi-spine/base\";\r\n\r\n/**\r\n * @public\r\n */\r\nexport class IkConstraint implements IIkConstraint, Updatable {\r\n    data: IkConstraintData;\r\n    bones: Array<Bone>;\r\n    target: Bone;\r\n    bendDirection = 0;\r\n    compress = false;\r\n    stretch = false;\r\n    mix = 1;\r\n    softness = 0;\r\n    active = false;\r\n\r\n    constructor (data: IkConstraintData, skeleton: Skeleton) {\r\n        if (data == null) throw new Error(\"data cannot be null.\");\r\n        if (skeleton == null) throw new Error(\"skeleton cannot be null.\");\r\n        this.data = data;\r\n        this.mix = data.mix;\r\n        this.softness = data.softness;\r\n        this.bendDirection = data.bendDirection;\r\n        this.compress = data.compress;\r\n        this.stretch = data.stretch;\r\n\r\n        this.bones = new Array<Bone>();\r\n        for (let i = 0; i < data.bones.length; i++)\r\n            this.bones.push(skeleton.findBone(data.bones[i].name));\r\n        this.target = skeleton.findBone(data.target.name);\r\n    }\r\n\r\n    isActive () {\r\n        return this.active;\r\n    }\r\n\r\n    apply () {\r\n        this.update();\r\n    }\r\n\r\n    update () {\r\n        let target = this.target;\r\n        let bones = this.bones;\r\n        switch (bones.length) {\r\n            case 1:\r\n                this.apply1(bones[0], target.worldX, target.worldY, this.compress, this.stretch, this.data.uniform, this.mix);\r\n                break;\r\n            case 2:\r\n                this.apply2(bones[0], bones[1], target.worldX, target.worldY, this.bendDirection, this.stretch, this.softness, this.mix);\r\n                break;\r\n        }\r\n    }\r\n\r\n    /** Adjusts the bone rotation so the tip is as close to the target position as possible. The target is specified in the world\r\n     * coordinate system. */\r\n    apply1 (bone: Bone, targetX: number, targetY: number, compress: boolean, stretch: boolean, uniform: boolean, alpha: number) {\r\n        if (!bone.appliedValid) bone.updateAppliedTransform();\r\n        let p = bone.parent.matrix;\r\n\r\n\r\n        let pa = p.a, pb = p.c, pc = p.b, pd = p.d;\r\n        let rotationIK = -bone.ashearX - bone.arotation, tx = 0, ty = 0;\r\n\r\n        switch(bone.data.transformMode) {\r\n            case TransformMode.OnlyTranslation:\r\n                tx = targetX - bone.worldX;\r\n                ty = targetY - bone.worldY;\r\n                break;\r\n            case TransformMode.NoRotationOrReflection:\r\n                let s = Math.abs(pa * pd - pb * pc) / (pa * pa + pc * pc);\r\n                let sa = pa / bone.skeleton.scaleX;\r\n                let sc = pc / bone.skeleton.scaleY;\r\n                pb = -sc * s * bone.skeleton.scaleX;\r\n                pd = sa * s * bone.skeleton.scaleY;\r\n                rotationIK += Math.atan2(sc, sa) * MathUtils.radDeg;\r\n            // Fall through\r\n            default:\r\n                let x = targetX - p.tx, y = targetY - p.ty;\r\n                let d = pa * pd - pb * pc;\r\n                tx = (x * pd - y * pb) / d - bone.ax;\r\n                ty = (y * pa - x * pc) / d - bone.ay;\r\n        }\r\n        rotationIK += Math.atan2(ty, tx) * MathUtils.radDeg;\r\n\r\n        if (bone.ascaleX < 0) rotationIK += 180;\r\n        if (rotationIK > 180)\r\n            rotationIK -= 360;\r\n        else if (rotationIK < -180) rotationIK += 360;\r\n        let sx = bone.ascaleX, sy = bone.ascaleY;\r\n        if (compress || stretch) {\r\n            switch (bone.data.transformMode) {\r\n                case TransformMode.NoScale:\r\n                case TransformMode.NoScaleOrReflection:\r\n                    tx = targetX - bone.worldX;\r\n                    ty = targetY - bone.worldY;\r\n            }\r\n            let b = bone.data.length * sx, dd = Math.sqrt(tx * tx + ty * ty);\r\n            if ((compress && dd < b) || (stretch && dd > b) && b > 0.0001) {\r\n                let s = (dd / b - 1) * alpha + 1;\r\n                sx *= s;\r\n                if (uniform) sy *= s;\r\n            }\r\n        }\r\n        bone.updateWorldTransformWith(bone.ax, bone.ay, bone.arotation + rotationIK * alpha, sx, sy, bone.ashearX,\r\n            bone.ashearY);\r\n    }\r\n\r\n    /** Adjusts the parent and child bone rotations so the tip of the child is as close to the target position as possible. The\r\n     * target is specified in the world coordinate system.\r\n     * @param child A direct descendant of the parent bone. */\r\n    apply2 (parent: Bone, child: Bone, targetX: number, targetY: number, bendDir: number, stretch: boolean, softness: number, alpha: number) {\r\n        if (alpha == 0) {\r\n            child.updateWorldTransform();\r\n            return;\r\n        }\r\n        if (!parent.appliedValid) parent.updateAppliedTransform();\r\n        if (!child.appliedValid) child.updateAppliedTransform();\r\n        let px = parent.ax, py = parent.ay, psx = parent.ascaleX, sx = psx, psy = parent.ascaleY, csx = child.ascaleX;\r\n        let pmat = parent.matrix;\r\n        let os1 = 0, os2 = 0, s2 = 0;\r\n        if (psx < 0) {\r\n            psx = -psx;\r\n            os1 = 180;\r\n            s2 = -1;\r\n        } else {\r\n            os1 = 0;\r\n            s2 = 1;\r\n        }\r\n        if (psy < 0) {\r\n            psy = -psy;\r\n            s2 = -s2;\r\n        }\r\n        if (csx < 0) {\r\n            csx = -csx;\r\n            os2 = 180;\r\n        } else\r\n            os2 = 0;\r\n        let cx = child.ax, cy = 0, cwx = 0, cwy = 0, a = pmat.a, b = pmat.c, c = pmat.b, d = pmat.d;\r\n        let u = Math.abs(psx - psy) <= 0.0001;\r\n        if (!u) {\r\n            cy = 0;\r\n            cwx = a * cx + pmat.tx;\r\n            cwy = c * cx + pmat.ty;\r\n        } else {\r\n            cy = child.ay;\r\n            cwx = a * cx + b * cy + pmat.tx;\r\n            cwy = c * cx + d * cy + pmat.ty;\r\n        }\r\n        let pp = parent.parent.matrix;\r\n        a = pp.a;\r\n        b = pp.c;\r\n        c = pp.b;\r\n        d = pp.d;\r\n        let id = 1 / (a * d - b * c), x = cwx - pp.tx, y = cwy - pp.ty;\r\n        let dx = (x * d - y * b) * id - px, dy = (y * a - x * c) * id - py;\r\n        let l1 = Math.sqrt(dx * dx + dy * dy), l2 = child.data.length * csx, a1, a2;\r\n        if (l1 < 0.0001) {\r\n            this.apply1(parent, targetX, targetY, false, stretch, false, alpha);\r\n            child.updateWorldTransformWith(cx, cy, 0, child.ascaleX, child.ascaleY, child.ashearX, child.ashearY);\r\n            return;\r\n        }\r\n        x = targetX - pp.tx;\r\n        y = targetY - pp.ty;\r\n        let tx = (x * d - y * b) * id - px, ty = (y * a - x * c) * id - py;\r\n        let dd = tx * tx + ty * ty;\r\n        if (softness != 0) {\r\n            softness *= psx * (csx + 1) / 2;\r\n            let td = Math.sqrt(dd), sd = td - l1 - l2 * psx + softness;\r\n            if (sd > 0) {\r\n                let p = Math.min(1, sd / (softness * 2)) - 1;\r\n                p = (sd - softness * (1 - p * p)) / td;\r\n                tx -= p * tx;\r\n                ty -= p * ty;\r\n                dd = tx * tx + ty * ty;\r\n            }\r\n        }\r\n        outer:\r\n            if (u) {\r\n                l2 *= psx;\r\n                let cos = (dd - l1 * l1 - l2 * l2) / (2 * l1 * l2);\r\n                if (cos < -1)\r\n                    cos = -1;\r\n                else if (cos > 1) {\r\n                    cos = 1;\r\n                    if (stretch) sx *= (Math.sqrt(dd) / (l1 + l2) - 1) * alpha + 1;\r\n                }\r\n                a2 = Math.acos(cos) * bendDir;\r\n                a = l1 + l2 * cos;\r\n                b = l2 * Math.sin(a2);\r\n                a1 = Math.atan2(ty * a - tx * b, tx * a + ty * b);\r\n            } else {\r\n                a = psx * l2;\r\n                b = psy * l2;\r\n                let aa = a * a, bb = b * b, ta = Math.atan2(ty, tx);\r\n                c = bb * l1 * l1 + aa * dd - aa * bb;\r\n                let c1 = -2 * bb * l1, c2 = bb - aa;\r\n                d = c1 * c1 - 4 * c2 * c;\r\n                if (d >= 0) {\r\n                    let q = Math.sqrt(d);\r\n                    if (c1 < 0) q = -q;\r\n                    q = -(c1 + q) / 2;\r\n                    let r0 = q / c2, r1 = c / q;\r\n                    let r = Math.abs(r0) < Math.abs(r1) ? r0 : r1;\r\n                    if (r * r <= dd) {\r\n                        y = Math.sqrt(dd - r * r) * bendDir;\r\n                        a1 = ta - Math.atan2(y, r);\r\n                        a2 = Math.atan2(y / psy, (r - l1) / psx);\r\n                        break outer;\r\n                    }\r\n                }\r\n                let minAngle = MathUtils.PI, minX = l1 - a, minDist = minX * minX, minY = 0;\r\n                let maxAngle = 0, maxX = l1 + a, maxDist = maxX * maxX, maxY = 0;\r\n                c = -a * l1 / (aa - bb);\r\n                if (c >= -1 && c <= 1) {\r\n                    c = Math.acos(c);\r\n                    x = a * Math.cos(c) + l1;\r\n                    y = b * Math.sin(c);\r\n                    d = x * x + y * y;\r\n                    if (d < minDist) {\r\n                        minAngle = c;\r\n                        minDist = d;\r\n                        minX = x;\r\n                        minY = y;\r\n                    }\r\n                    if (d > maxDist) {\r\n                        maxAngle = c;\r\n                        maxDist = d;\r\n                        maxX = x;\r\n                        maxY = y;\r\n                    }\r\n                }\r\n                if (dd <= (minDist + maxDist) / 2) {\r\n                    a1 = ta - Math.atan2(minY * bendDir, minX);\r\n                    a2 = minAngle * bendDir;\r\n                } else {\r\n                    a1 = ta - Math.atan2(maxY * bendDir, maxX);\r\n                    a2 = maxAngle * bendDir;\r\n                }\r\n            }\r\n        let os = Math.atan2(cy, cx) * s2;\r\n        let rotation = parent.arotation;\r\n        a1 = (a1 - os) * MathUtils.radDeg + os1 - rotation;\r\n        if (a1 > 180)\r\n            a1 -= 360;\r\n        else if (a1 < -180) a1 += 360;\r\n        parent.updateWorldTransformWith(px, py, rotation + a1 * alpha, sx, parent.ascaleY, 0, 0);\r\n        rotation = child.arotation;\r\n        a2 = ((a2 + os) * MathUtils.radDeg - child.ashearX) * s2 + os2 - rotation;\r\n        if (a2 > 180)\r\n            a2 -= 360;\r\n        else if (a2 < -180) a2 += 360;\r\n        child.updateWorldTransformWith(cx, cy, rotation + a2 * alpha, child.ascaleX, child.ascaleY, child.ashearX, child.ashearY);\r\n    }\r\n}\r\n","import {ConstraintData} from \"./Constraint\";\r\nimport {BoneData} from \"./BoneData\";\r\nimport {IIkConstraintData} from \"@pixi-spine/base\";\r\n\r\n/**\r\n * @public\r\n */\r\nexport class IkConstraintData extends ConstraintData implements IIkConstraintData {\r\n    bones = new Array<BoneData>();\r\n    target: BoneData;\r\n    bendDirection = 1;\r\n    compress = false;\r\n    stretch = false;\r\n    uniform = false;\r\n    mix = 1;\r\n    softness = 0;\r\n\r\n    constructor (name: string) {\r\n        super(name, 0, false);\r\n    }\r\n}\r\n","import {PathAttachment} from \"./attachments\";\r\nimport {Updatable} from \"./Updatable\";\r\nimport {PathConstraintData, SpacingMode} from \"./PathConstraintData\";\r\nimport {Bone} from \"./Bone\";\r\nimport {Slot} from \"./Slot\";\r\nimport {Skeleton} from \"./Skeleton\";\r\nimport {MathUtils, PositionMode, RotateMode, Utils} from \"@pixi-spine/base\";\r\n/**\r\n * @public\r\n */\r\nexport class PathConstraint implements Updatable {\r\n    static NONE = -1; static BEFORE = -2; static AFTER = -3;\r\n    static epsilon = 0.00001;\r\n\r\n    data: PathConstraintData;\r\n    bones: Array<Bone>;\r\n    target: Slot;\r\n    position = 0; spacing = 0; rotateMix = 0; translateMix = 0;\r\n\r\n    spaces = new Array<number>(); positions = new Array<number>();\r\n    world = new Array<number>(); curves = new Array<number>(); lengths = new Array<number>();\r\n    segments = new Array<number>();\r\n\r\n    active = false;\r\n\r\n    constructor (data: PathConstraintData, skeleton: Skeleton) {\r\n        if (data == null) throw new Error(\"data cannot be null.\");\r\n        if (skeleton == null) throw new Error(\"skeleton cannot be null.\");\r\n        this.data = data;\r\n        this.bones = new Array<Bone>();\r\n        for (let i = 0, n = data.bones.length; i < n; i++)\r\n            this.bones.push(skeleton.findBone(data.bones[i].name));\r\n        this.target = skeleton.findSlot(data.target.name);\r\n        this.position = data.position;\r\n        this.spacing = data.spacing;\r\n        this.rotateMix = data.rotateMix;\r\n        this.translateMix = data.translateMix;\r\n    }\r\n\r\n    isActive () {\r\n        return this.active;\r\n    }\r\n\r\n    apply () {\r\n        this.update();\r\n    }\r\n\r\n    update () {\r\n        let attachment = this.target.getAttachment();\r\n        if (!(attachment instanceof PathAttachment)) return;\r\n\r\n        let rotateMix = this.rotateMix, translateMix = this.translateMix;\r\n        let translate = translateMix > 0, rotate = rotateMix > 0;\r\n        if (!translate && !rotate) return;\r\n\r\n        let data = this.data;\r\n        let spacingMode = data.spacingMode;\r\n        let lengthSpacing = spacingMode == SpacingMode.Length;\r\n        let rotateMode = data.rotateMode;\r\n        let tangents = rotateMode == RotateMode.Tangent, scale = rotateMode == RotateMode.ChainScale;\r\n        let boneCount = this.bones.length, spacesCount = tangents ? boneCount : boneCount + 1;\r\n        let bones = this.bones;\r\n        let spaces = Utils.setArraySize(this.spaces, spacesCount), lengths: Array<number> = null;\r\n        let spacing = this.spacing;\r\n        if (scale || lengthSpacing) {\r\n            if (scale) lengths = Utils.setArraySize(this.lengths, boneCount);\r\n            for (let i = 0, n = spacesCount - 1; i < n;) {\r\n                let bone = bones[i];\r\n                let setupLength = bone.data.length;\r\n                if (setupLength < PathConstraint.epsilon) {\r\n                    if (scale) lengths[i] = 0;\r\n                    spaces[++i] = 0;\r\n                } else {\r\n                    let x = setupLength * bone.matrix.a, y = setupLength * bone.matrix.b;\r\n                    let length = Math.sqrt(x * x + y * y);\r\n                    if (scale) lengths[i] = length;\r\n                    spaces[++i] = (lengthSpacing ? setupLength + spacing : spacing) * length / setupLength;\r\n                }\r\n            }\r\n        } else {\r\n            for (let i = 1; i < spacesCount; i++)\r\n                spaces[i] = spacing;\r\n        }\r\n\r\n        let positions = this.computeWorldPositions(<PathAttachment>attachment, spacesCount, tangents,\r\n            data.positionMode == PositionMode.Percent, spacingMode == SpacingMode.Percent);\r\n        let boneX = positions[0], boneY = positions[1], offsetRotation = data.offsetRotation;\r\n        let tip = false;\r\n        if (offsetRotation == 0)\r\n            tip = rotateMode == RotateMode.Chain;\r\n        else {\r\n            tip = false;\r\n            let p = this.target.bone.matrix;\r\n            offsetRotation *= p.a * p.d - p.b * p.c > 0 ? MathUtils.degRad : -MathUtils.degRad;\r\n        }\r\n        for (let i = 0, p = 3; i < boneCount; i++, p += 3) {\r\n            let bone = bones[i];\r\n            let mat = bone.matrix;\r\n            mat.tx += (boneX - mat.tx) * translateMix;\r\n            mat.ty += (boneY - mat.ty) * translateMix;\r\n            let x = positions[p], y = positions[p + 1], dx = x - boneX, dy = y - boneY;\r\n            if (scale) {\r\n                let length = lengths[i];\r\n                if (length != 0) {\r\n                    let s = (Math.sqrt(dx * dx + dy * dy) / length - 1) * rotateMix + 1;\r\n                    mat.a *= s;\r\n                    mat.b *= s;\r\n                }\r\n            }\r\n            boneX = x;\r\n            boneY = y;\r\n            if (rotate) {\r\n                let a = mat.a, b = mat.c, c = mat.b, d = mat.d, r = 0, cos = 0, sin = 0;\r\n                if (tangents)\r\n                    r = positions[p - 1];\r\n                else if (spaces[i + 1] == 0)\r\n                    r = positions[p + 2];\r\n                else\r\n                    r = Math.atan2(dy, dx);\r\n                r -= Math.atan2(c, a);\r\n                if (tip) {\r\n                    cos = Math.cos(r);\r\n                    sin = Math.sin(r);\r\n                    let length = bone.data.length;\r\n                    boneX += (length * (cos * a - sin * c) - dx) * rotateMix;\r\n                    boneY += (length * (sin * a + cos * c) - dy) * rotateMix;\r\n                } else {\r\n                    r += offsetRotation;\r\n                }\r\n                if (r > MathUtils.PI)\r\n                    r -= MathUtils.PI2;\r\n                else if (r < -MathUtils.PI) //\r\n                    r += MathUtils.PI2;\r\n                r *= rotateMix;\r\n                cos = Math.cos(r);\r\n                sin = Math.sin(r);\r\n                mat.a = cos * a - sin * c;\r\n                mat.c = cos * b - sin * d;\r\n                mat.b = sin * a + cos * c;\r\n                mat.d = sin * b + cos * d;\r\n            }\r\n            bone.appliedValid = false;\r\n        }\r\n    }\r\n\r\n    computeWorldPositions (path: PathAttachment, spacesCount: number, tangents: boolean, percentPosition: boolean,\r\n                           percentSpacing: boolean) {\r\n        let target = this.target;\r\n        let position = this.position;\r\n        let spaces = this.spaces, out = Utils.setArraySize(this.positions, spacesCount * 3 + 2), world: Array<number> = null;\r\n        let closed = path.closed;\r\n        let verticesLength = path.worldVerticesLength, curveCount = verticesLength / 6, prevCurve = PathConstraint.NONE;\r\n\r\n        if (!path.constantSpeed) {\r\n            let lengths = path.lengths;\r\n            curveCount -= closed ? 1 : 2;\r\n            let pathLength = lengths[curveCount];\r\n            if (percentPosition) position *= pathLength;\r\n            if (percentSpacing) {\r\n                for (let i = 0; i < spacesCount; i++)\r\n                    spaces[i] *= pathLength;\r\n            }\r\n            world = Utils.setArraySize(this.world, 8);\r\n            for (let i = 0, o = 0, curve = 0; i < spacesCount; i++, o += 3) {\r\n                let space = spaces[i];\r\n                position += space;\r\n                let p = position;\r\n\r\n                if (closed) {\r\n                    p %= pathLength;\r\n                    if (p < 0) p += pathLength;\r\n                    curve = 0;\r\n                } else if (p < 0) {\r\n                    if (prevCurve != PathConstraint.BEFORE) {\r\n                        prevCurve = PathConstraint.BEFORE;\r\n                        path.computeWorldVertices(target, 2, 4, world, 0, 2);\r\n                    }\r\n                    this.addBeforePosition(p, world, 0, out, o);\r\n                    continue;\r\n                } else if (p > pathLength) {\r\n                    if (prevCurve != PathConstraint.AFTER) {\r\n                        prevCurve = PathConstraint.AFTER;\r\n                        path.computeWorldVertices(target, verticesLength - 6, 4, world, 0, 2);\r\n                    }\r\n                    this.addAfterPosition(p - pathLength, world, 0, out, o);\r\n                    continue;\r\n                }\r\n\r\n                // Determine curve containing position.\r\n                for (;; curve++) {\r\n                    let length = lengths[curve];\r\n                    if (p > length) continue;\r\n                    if (curve == 0)\r\n                        p /= length;\r\n                    else {\r\n                        let prev = lengths[curve - 1];\r\n                        p = (p - prev) / (length - prev);\r\n                    }\r\n                    break;\r\n                }\r\n                if (curve != prevCurve) {\r\n                    prevCurve = curve;\r\n                    if (closed && curve == curveCount) {\r\n                        path.computeWorldVertices(target, verticesLength - 4, 4, world, 0, 2);\r\n                        path.computeWorldVertices(target, 0, 4, world, 4, 2);\r\n                    } else\r\n                        path.computeWorldVertices(target, curve * 6 + 2, 8, world, 0, 2);\r\n                }\r\n                this.addCurvePosition(p, world[0], world[1], world[2], world[3], world[4], world[5], world[6], world[7], out, o,\r\n                    tangents || (i > 0 && space == 0));\r\n            }\r\n            return out;\r\n        }\r\n\r\n        // World vertices.\r\n        if (closed) {\r\n            verticesLength += 2;\r\n            world = Utils.setArraySize(this.world, verticesLength);\r\n            path.computeWorldVertices(target, 2, verticesLength - 4, world, 0, 2);\r\n            path.computeWorldVertices(target, 0, 2, world, verticesLength - 4, 2);\r\n            world[verticesLength - 2] = world[0];\r\n            world[verticesLength - 1] = world[1];\r\n        } else {\r\n            curveCount--;\r\n            verticesLength -= 4;\r\n            world = Utils.setArraySize(this.world, verticesLength);\r\n            path.computeWorldVertices(target, 2, verticesLength, world, 0, 2);\r\n        }\r\n\r\n        // Curve lengths.\r\n        let curves = Utils.setArraySize(this.curves, curveCount);\r\n        let pathLength = 0;\r\n        let x1 = world[0], y1 = world[1], cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0, x2 = 0, y2 = 0;\r\n        let tmpx = 0, tmpy = 0, dddfx = 0, dddfy = 0, ddfx = 0, ddfy = 0, dfx = 0, dfy = 0;\r\n        for (let i = 0, w = 2; i < curveCount; i++, w += 6) {\r\n            cx1 = world[w];\r\n            cy1 = world[w + 1];\r\n            cx2 = world[w + 2];\r\n            cy2 = world[w + 3];\r\n            x2 = world[w + 4];\r\n            y2 = world[w + 5];\r\n            tmpx = (x1 - cx1 * 2 + cx2) * 0.1875;\r\n            tmpy = (y1 - cy1 * 2 + cy2) * 0.1875;\r\n            dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375;\r\n            dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375;\r\n            ddfx = tmpx * 2 + dddfx;\r\n            ddfy = tmpy * 2 + dddfy;\r\n            dfx = (cx1 - x1) * 0.75 + tmpx + dddfx * 0.16666667;\r\n            dfy = (cy1 - y1) * 0.75 + tmpy + dddfy * 0.16666667;\r\n            pathLength += Math.sqrt(dfx * dfx + dfy * dfy);\r\n            dfx += ddfx;\r\n            dfy += ddfy;\r\n            ddfx += dddfx;\r\n            ddfy += dddfy;\r\n            pathLength += Math.sqrt(dfx * dfx + dfy * dfy);\r\n            dfx += ddfx;\r\n            dfy += ddfy;\r\n            pathLength += Math.sqrt(dfx * dfx + dfy * dfy);\r\n            dfx += ddfx + dddfx;\r\n            dfy += ddfy + dddfy;\r\n            pathLength += Math.sqrt(dfx * dfx + dfy * dfy);\r\n            curves[i] = pathLength;\r\n            x1 = x2;\r\n            y1 = y2;\r\n        }\r\n        if (percentPosition) position *= pathLength;\r\n        if (percentSpacing) {\r\n            for (let i = 0; i < spacesCount; i++)\r\n                spaces[i] *= pathLength;\r\n        }\r\n\r\n        let segments = this.segments;\r\n        let curveLength = 0;\r\n        for (let i = 0, o = 0, curve = 0, segment = 0; i < spacesCount; i++, o += 3) {\r\n            let space = spaces[i];\r\n            position += space;\r\n            let p = position;\r\n\r\n            if (closed) {\r\n                p %= pathLength;\r\n                if (p < 0) p += pathLength;\r\n                curve = 0;\r\n            } else if (p < 0) {\r\n                this.addBeforePosition(p, world, 0, out, o);\r\n                continue;\r\n            } else if (p > pathLength) {\r\n                this.addAfterPosition(p - pathLength, world, verticesLength - 4, out, o);\r\n                continue;\r\n            }\r\n\r\n            // Determine curve containing position.\r\n            for (;; curve++) {\r\n                let length = curves[curve];\r\n                if (p > length) continue;\r\n                if (curve == 0)\r\n                    p /= length;\r\n                else {\r\n                    let prev = curves[curve - 1];\r\n                    p = (p - prev) / (length - prev);\r\n                }\r\n                break;\r\n            }\r\n\r\n            // Curve segment lengths.\r\n            if (curve != prevCurve) {\r\n                prevCurve = curve;\r\n                let ii = curve * 6;\r\n                x1 = world[ii];\r\n                y1 = world[ii + 1];\r\n                cx1 = world[ii + 2];\r\n                cy1 = world[ii + 3];\r\n                cx2 = world[ii + 4];\r\n                cy2 = world[ii + 5];\r\n                x2 = world[ii + 6];\r\n                y2 = world[ii + 7];\r\n                tmpx = (x1 - cx1 * 2 + cx2) * 0.03;\r\n                tmpy = (y1 - cy1 * 2 + cy2) * 0.03;\r\n                dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.006;\r\n                dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.006;\r\n                ddfx = tmpx * 2 + dddfx;\r\n                ddfy = tmpy * 2 + dddfy;\r\n                dfx = (cx1 - x1) * 0.3 + tmpx + dddfx * 0.16666667;\r\n                dfy = (cy1 - y1) * 0.3 + tmpy + dddfy * 0.16666667;\r\n                curveLength = Math.sqrt(dfx * dfx + dfy * dfy);\r\n                segments[0] = curveLength;\r\n                for (ii = 1; ii < 8; ii++) {\r\n                    dfx += ddfx;\r\n                    dfy += ddfy;\r\n                    ddfx += dddfx;\r\n                    ddfy += dddfy;\r\n                    curveLength += Math.sqrt(dfx * dfx + dfy * dfy);\r\n                    segments[ii] = curveLength;\r\n                }\r\n                dfx += ddfx;\r\n                dfy += ddfy;\r\n                curveLength += Math.sqrt(dfx * dfx + dfy * dfy);\r\n                segments[8] = curveLength;\r\n                dfx += ddfx + dddfx;\r\n                dfy += ddfy + dddfy;\r\n                curveLength += Math.sqrt(dfx * dfx + dfy * dfy);\r\n                segments[9] = curveLength;\r\n                segment = 0;\r\n            }\r\n\r\n            // Weight by segment length.\r\n            p *= curveLength;\r\n            for (;; segment++) {\r\n                let length = segments[segment];\r\n                if (p > length) continue;\r\n                if (segment == 0)\r\n                    p /= length;\r\n                else {\r\n                    let prev = segments[segment - 1];\r\n                    p = segment + (p - prev) / (length - prev);\r\n                }\r\n                break;\r\n            }\r\n            this.addCurvePosition(p * 0.1, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, tangents || (i > 0 && space == 0));\r\n        }\r\n        return out;\r\n    }\r\n\r\n    addBeforePosition (p: number, temp: Array<number>, i: number, out: Array<number>, o: number) {\r\n        let x1 = temp[i], y1 = temp[i + 1], dx = temp[i + 2] - x1, dy = temp[i + 3] - y1, r = Math.atan2(dy, dx);\r\n        out[o] = x1 + p * Math.cos(r);\r\n        out[o + 1] = y1 + p * Math.sin(r);\r\n        out[o + 2] = r;\r\n    }\r\n\r\n    addAfterPosition (p: number, temp: Array<number>, i: number, out: Array<number>, o: number) {\r\n        let x1 = temp[i + 2], y1 = temp[i + 3], dx = x1 - temp[i], dy = y1 - temp[i + 1], r = Math.atan2(dy, dx);\r\n        out[o] = x1 + p * Math.cos(r);\r\n        out[o + 1] = y1 + p * Math.sin(r);\r\n        out[o + 2] = r;\r\n    }\r\n\r\n    addCurvePosition (p: number, x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number,\r\n                      out: Array<number>, o: number, tangents: boolean) {\r\n        if (p == 0 || isNaN(p)) p = 0.0001;\r\n        let tt = p * p, ttt = tt * p, u = 1 - p, uu = u * u, uuu = uu * u;\r\n        let ut = u * p, ut3 = ut * 3, uut3 = u * ut3, utt3 = ut3 * p;\r\n        let x = x1 * uuu + cx1 * uut3 + cx2 * utt3 + x2 * ttt, y = y1 * uuu + cy1 * uut3 + cy2 * utt3 + y2 * ttt;\r\n        out[o] = x;\r\n        out[o + 1] = y;\r\n        if (tangents) out[o + 2] = Math.atan2(y - (y1 * uu + cy1 * ut * 2 + cy2 * tt), x - (x1 * uu + cx1 * ut * 2 + cx2 * tt));\r\n    }\r\n}\r\n","\r\nimport {Color, ISlot} from '@pixi-spine/base';\r\n\r\nimport type {Attachment} from './attachments/Attachment';\r\nimport type {Bone} from './Bone';\r\nimport type {SlotData} from './SlotData';\r\n\r\n/**\r\n * @public\r\n */\r\nexport class Slot implements ISlot {\r\n    //this is canon\r\n    blendMode: number;\r\n    data: SlotData;\r\n    bone: Bone;\r\n    color: Color;\r\n    darkColor: Color;\r\n    attachment: Attachment;\r\n    private attachmentTime: number;\r\n    attachmentState: number;\r\n    deform = new Array<number>();\r\n\r\n    constructor (data: SlotData, bone: Bone) {\r\n        if (data == null) throw new Error(\"data cannot be null.\");\r\n        if (bone == null) throw new Error(\"bone cannot be null.\");\r\n        this.data = data;\r\n        this.bone = bone;\r\n        this.color = new Color();\r\n        this.darkColor = data.darkColor == null ? null : new Color();\r\n        this.setToSetupPose();\r\n\r\n        this.blendMode = this.data.blendMode;\r\n    }\r\n\r\n    /** @return May be null. */\r\n    getAttachment (): Attachment {\r\n        return this.attachment;\r\n    }\r\n\r\n    /** Sets the attachment and if it changed, resets {@link #getAttachmentTime()} and clears {@link #getAttachmentVertices()}.\r\n     * @param attachment May be null. */\r\n    setAttachment (attachment: Attachment) {\r\n        if (this.attachment == attachment) return;\r\n        this.attachment = attachment;\r\n        this.attachmentTime = this.bone.skeleton.time;\r\n        this.deform.length = 0;\r\n    }\r\n\r\n    setAttachmentTime (time: number) {\r\n        this.attachmentTime = this.bone.skeleton.time - time;\r\n    }\r\n\r\n    /** Returns the time since the attachment was set. */\r\n    getAttachmentTime (): number {\r\n        return this.bone.skeleton.time - this.attachmentTime;\r\n    }\r\n\r\n    setToSetupPose () {\r\n        this.color.setFromColor(this.data.color);\r\n        if (this.darkColor != null) this.darkColor.setFromColor(this.data.darkColor);\r\n        if (this.data.attachmentName == null)\r\n            this.attachment = null;\r\n        else {\r\n            this.attachment = null;\r\n            this.setAttachment(this.bone.skeleton.getAttachment(this.data.index, this.data.attachmentName));\r\n        }\r\n    }\r\n}\r\n","import {Updatable} from \"./Updatable\";\r\nimport {TransformConstraintData} from \"./TransformConstraintData\";\r\nimport {Bone} from \"./Bone\";\r\nimport {MathUtils, Vector2} from \"@pixi-spine/base\";\r\nimport {Skeleton} from \"./Skeleton\";\r\n\r\n/**\r\n * @public\r\n */\r\nexport class TransformConstraint implements Updatable {\r\n    data: TransformConstraintData;\r\n    bones: Array<Bone>;\r\n    target: Bone;\r\n    rotateMix = 0;\r\n    translateMix = 0;\r\n    scaleMix = 0;\r\n    shearMix = 0;\r\n    temp = new Vector2();\r\n    active = false;\r\n\r\n    constructor(data: TransformConstraintData, skeleton: Skeleton) {\r\n        if (data == null) throw new Error(\"data cannot be null.\");\r\n        if (skeleton == null) throw new Error(\"skeleton cannot be null.\");\r\n        this.data = data;\r\n        this.rotateMix = data.rotateMix;\r\n        this.translateMix = data.translateMix;\r\n        this.scaleMix = data.scaleMix;\r\n        this.shearMix = data.shearMix;\r\n        this.bones = new Array<Bone>();\r\n        for (let i = 0; i < data.bones.length; i++)\r\n            this.bones.push(skeleton.findBone(data.bones[i].name));\r\n        this.target = skeleton.findBone(data.target.name);\r\n    }\r\n\r\n    isActive () {\r\n        return this.active;\r\n    }\r\n\r\n    apply() {\r\n        this.update();\r\n    }\r\n\r\n    update() {\r\n        if (this.data.local) {\r\n            if (this.data.relative)\r\n                this.applyRelativeLocal();\r\n            else\r\n                this.applyAbsoluteLocal();\r\n\r\n        } else {\r\n            if (this.data.relative)\r\n                this.applyRelativeWorld();\r\n            else\r\n                this.applyAbsoluteWorld();\r\n        }\r\n    }\r\n\r\n    applyAbsoluteWorld() {\r\n        let rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix,\r\n            shearMix = this.shearMix;\r\n        let target = this.target;\r\n        let targetMat = target.matrix;\r\n        let ta = targetMat.a, tb = targetMat.c, tc = targetMat.b, td = targetMat.d;\r\n        let degRadReflect = ta * td - tb * tc > 0 ? MathUtils.degRad : -MathUtils.degRad;\r\n        let offsetRotation = this.data.offsetRotation * degRadReflect;\r\n        let offsetShearY = this.data.offsetShearY * degRadReflect;\r\n        let bones = this.bones;\r\n        for (let i = 0, n = bones.length; i < n; i++) {\r\n            let bone = bones[i];\r\n            let modified = false;\r\n            let mat = bone.matrix;\r\n\r\n            if (rotateMix != 0) {\r\n                let a = mat.a, b = mat.c, c = mat.b, d = mat.d;\r\n                let r = Math.atan2(tc, ta) - Math.atan2(c, a) + offsetRotation;\r\n                if (r > MathUtils.PI)\r\n                    r -= MathUtils.PI2;\r\n                else if (r < -MathUtils.PI)\r\n                    r += MathUtils.PI2;\r\n                r *= rotateMix;\r\n                let cos = Math.cos(r), sin = Math.sin(r);\r\n                mat.a = cos * a - sin * c;\r\n                mat.c = cos * b - sin * d;\r\n                mat.b = sin * a + cos * c;\r\n                mat.d = sin * b + cos * d;\r\n                modified = true;\r\n            }\r\n\r\n            if (translateMix != 0) {\r\n                let temp = this.temp;\r\n                target.localToWorld(temp.set(this.data.offsetX, this.data.offsetY));\r\n                mat.tx += (temp.x - mat.tx) * translateMix;\r\n                mat.ty += (temp.y - mat.ty) * translateMix;\r\n                modified = true;\r\n            }\r\n\r\n            if (scaleMix > 0) {\r\n                let s = Math.sqrt(mat.a * mat.a + mat.b * mat.b);\r\n                let ts = Math.sqrt(ta * ta + tc * tc);\r\n                if (s > 0.00001) s = (s + (ts - s + this.data.offsetScaleX) * scaleMix) / s;\r\n                mat.a *= s;\r\n                mat.b *= s;\r\n                s = Math.sqrt(mat.c * mat.c + mat.d * mat.d);\r\n                ts = Math.sqrt(tb * tb + td * td);\r\n                if (s > 0.00001) s = (s + (ts - s + this.data.offsetScaleY) * scaleMix) / s;\r\n                mat.c *= s;\r\n                mat.d *= s;\r\n                modified = true;\r\n            }\r\n\r\n            if (shearMix > 0) {\r\n                let b = mat.c, d = mat.d;\r\n                let by = Math.atan2(d, b);\r\n                let r = Math.atan2(td, tb) - Math.atan2(tc, ta) - (by - Math.atan2(mat.b, mat.a));\r\n                if (r > MathUtils.PI)\r\n                    r -= MathUtils.PI2;\r\n                else if (r < -MathUtils.PI)\r\n                    r += MathUtils.PI2;\r\n                r = by + (r + offsetShearY) * shearMix;\r\n                let s = Math.sqrt(b * b + d * d);\r\n                mat.c = Math.cos(r) * s;\r\n                mat.d = Math.sin(r) * s;\r\n                modified = true;\r\n            }\r\n\r\n            if (modified) bone.appliedValid = false;\r\n        }\r\n    }\r\n\r\n    applyRelativeWorld() {\r\n        let rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix,\r\n            shearMix = this.shearMix;\r\n        let target = this.target;\r\n        let targetMat = target.matrix;\r\n        let ta = targetMat.a, tb = targetMat.c, tc = targetMat.b, td = targetMat.d;\r\n        let degRadReflect = ta * td - tb * tc > 0 ? MathUtils.degRad : -MathUtils.degRad;\r\n        let offsetRotation = this.data.offsetRotation * degRadReflect,\r\n            offsetShearY = this.data.offsetShearY * degRadReflect;\r\n        let bones = this.bones;\r\n        for (let i = 0, n = bones.length; i < n; i++) {\r\n            let bone = bones[i];\r\n            let modified = false;\r\n            let mat = bone.matrix;\r\n\r\n            if (rotateMix != 0) {\r\n                let a = mat.a, b = mat.c, c = mat.b, d = mat.d;\r\n                let r = Math.atan2(tc, ta) + offsetRotation;\r\n                if (r > MathUtils.PI)\r\n                    r -= MathUtils.PI2;\r\n                else if (r < -MathUtils.PI) r += MathUtils.PI2;\r\n                r *= rotateMix;\r\n                let cos = Math.cos(r), sin = Math.sin(r);\r\n                mat.a = cos * a - sin * c;\r\n                mat.c = cos * b - sin * d;\r\n                mat.b = sin * a + cos * c;\r\n                mat.d = sin * b + cos * d;\r\n                modified = true;\r\n            }\r\n\r\n            if (translateMix != 0) {\r\n                let temp = this.temp;\r\n                target.localToWorld(temp.set(this.data.offsetX, this.data.offsetY));\r\n                mat.tx += temp.x * translateMix;\r\n                mat.ty += temp.y * translateMix;\r\n                modified = true;\r\n            }\r\n\r\n            if (scaleMix > 0) {\r\n                let s = (Math.sqrt(ta * ta + tc * tc) - 1 + this.data.offsetScaleX) * scaleMix + 1;\r\n                mat.a *= s;\r\n                mat.b *= s;\r\n                s = (Math.sqrt(tb * tb + td * td) - 1 + this.data.offsetScaleY) * scaleMix + 1;\r\n                mat.c *= s;\r\n                mat.d *= s;\r\n                modified = true;\r\n            }\r\n\r\n            if (shearMix > 0) {\r\n                let r = Math.atan2(td, tb) - Math.atan2(tc, ta);\r\n                if (r > MathUtils.PI)\r\n                    r -= MathUtils.PI2;\r\n                else if (r < -MathUtils.PI) r += MathUtils.PI2;\r\n                let b = mat.c, d = mat.d;\r\n                r = Math.atan2(d, b) + (r - MathUtils.PI / 2 + offsetShearY) * shearMix;\r\n                let s = Math.sqrt(b * b + d * d);\r\n                mat.c = Math.cos(r) * s;\r\n                mat.d = Math.sin(r) * s;\r\n                modified = true;\r\n            }\r\n\r\n            if (modified) bone.appliedValid = false;\r\n        }\r\n    }\r\n\r\n    applyAbsoluteLocal() {\r\n        let rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix,\r\n            shearMix = this.shearMix;\r\n        let target = this.target;\r\n        if (!target.appliedValid) target.updateAppliedTransform();\r\n        let bones = this.bones;\r\n        for (let i = 0, n = bones.length; i < n; i++) {\r\n            let bone = bones[i];\r\n            if (!bone.appliedValid) bone.updateAppliedTransform();\r\n\r\n            let rotation = bone.arotation;\r\n            if (rotateMix != 0) {\r\n                let r = target.arotation - rotation + this.data.offsetRotation;\r\n                r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;\r\n                rotation += r * rotateMix;\r\n            }\r\n\r\n            let x = bone.ax, y = bone.ay;\r\n            if (translateMix != 0) {\r\n                x += (target.ax - x + this.data.offsetX) * translateMix;\r\n                y += (target.ay - y + this.data.offsetY) * translateMix;\r\n            }\r\n\r\n            let scaleX = bone.ascaleX, scaleY = bone.ascaleY;\r\n            if (scaleMix > 0) {\r\n                if (scaleX > 0.00001) scaleX = (scaleX + (target.ascaleX - scaleX + this.data.offsetScaleX) * scaleMix) / scaleX;\r\n                if (scaleY > 0.00001) scaleY = (scaleY + (target.ascaleY - scaleY + this.data.offsetScaleY) * scaleMix) / scaleY;\r\n            }\r\n\r\n            let shearY = bone.ashearY;\r\n            if (shearMix > 0) {\r\n                let r = target.ashearY - shearY + this.data.offsetShearY;\r\n                r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;\r\n                bone.shearY += r * shearMix;\r\n            }\r\n\r\n            bone.updateWorldTransformWith(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);\r\n        }\r\n    }\r\n\r\n    applyRelativeLocal() {\r\n        let rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix,\r\n            shearMix = this.shearMix;\r\n        let target = this.target;\r\n        if (!target.appliedValid) target.updateAppliedTransform();\r\n        let bones = this.bones;\r\n        for (let i = 0, n = bones.length; i < n; i++) {\r\n            let bone = bones[i];\r\n            if (!bone.appliedValid) bone.updateAppliedTransform();\r\n\r\n            let rotation = bone.arotation;\r\n            if (rotateMix != 0) rotation += (target.arotation + this.data.offsetRotation) * rotateMix;\r\n\r\n            let x = bone.ax, y = bone.ay;\r\n            if (translateMix != 0) {\r\n                x += (target.ax + this.data.offsetX) * translateMix;\r\n                y += (target.ay + this.data.offsetY) * translateMix;\r\n            }\r\n\r\n            let scaleX = bone.ascaleX, scaleY = bone.ascaleY;\r\n            if (scaleMix > 0) {\r\n                if (scaleX > 0.00001) scaleX *= ((target.ascaleX - 1 + this.data.offsetScaleX) * scaleMix) + 1;\r\n                if (scaleY > 0.00001) scaleY *= ((target.ascaleY - 1 + this.data.offsetScaleY) * scaleMix) + 1;\r\n            }\r\n\r\n            let shearY = bone.ashearY;\r\n            if (shearMix > 0) shearY += (target.ashearY + this.data.offsetShearY) * shearMix;\r\n\r\n            bone.updateWorldTransformWith(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);\r\n        }\r\n    }\r\n}\r\n","import {Attachment, RegionAttachment, MeshAttachment, PathAttachment} from './attachments';\r\nimport {Bone} from \"./Bone\";\r\nimport {Slot} from \"./Slot\";\r\nimport {Updatable} from \"./Updatable\";\r\nimport {SkeletonData} from \"./SkeletonData\";\r\nimport {IkConstraint} from \"./IkConstraint\";\r\nimport {TransformConstraint} from \"./TransformConstraint\";\r\nimport {PathConstraint} from \"./PathConstraint\";\r\nimport {Skin} from \"./Skin\";\r\nimport {Color, Utils, Vector2, ISkeleton} from \"@pixi-spine/base\";\r\n\r\n/**\r\n * @public\r\n */\r\nexport class Skeleton implements ISkeleton<SkeletonData, Bone, Slot, Skin> {\r\n    data: SkeletonData;\r\n    bones: Array<Bone>;\r\n    slots: Array<Slot>;\r\n    drawOrder: Array<Slot>;\r\n    ikConstraints: Array<IkConstraint>;\r\n    transformConstraints: Array<TransformConstraint>;\r\n    pathConstraints: Array<PathConstraint>;\r\n    _updateCache = new Array<Updatable>();\r\n    updateCacheReset = new Array<Updatable>();\r\n    skin: Skin;\r\n    color: Color;\r\n    time = 0;\r\n    scaleX = 1; scaleY = 1;\r\n    x = 0; y = 0;\r\n\r\n    constructor (data: SkeletonData) {\r\n        if (data == null) throw new Error(\"data cannot be null.\");\r\n        this.data = data;\r\n\r\n        this.bones = new Array<Bone>();\r\n        for (let i = 0; i < data.bones.length; i++) {\r\n            let boneData = data.bones[i];\r\n            let bone: Bone;\r\n            if (boneData.parent == null)\r\n                bone = new Bone(boneData, this, null);\r\n            else {\r\n                let parent = this.bones[boneData.parent.index];\r\n                bone = new Bone(boneData, this, parent);\r\n                parent.children.push(bone);\r\n            }\r\n            this.bones.push(bone);\r\n        }\r\n\r\n        this.slots = new Array<Slot>();\r\n        this.drawOrder = new Array<Slot>();\r\n        for (let i = 0; i < data.slots.length; i++) {\r\n            let slotData = data.slots[i];\r\n            let bone = this.bones[slotData.boneData.index];\r\n            let slot = new Slot(slotData, bone);\r\n            this.slots.push(slot);\r\n            this.drawOrder.push(slot);\r\n        }\r\n\r\n        this.ikConstraints = new Array<IkConstraint>();\r\n        for (let i = 0; i < data.ikConstraints.length; i++) {\r\n            let ikConstraintData = data.ikConstraints[i];\r\n            this.ikConstraints.push(new IkConstraint(ikConstraintData, this));\r\n        }\r\n\r\n        this.transformConstraints = new Array<TransformConstraint>();\r\n        for (let i = 0; i < data.transformConstraints.length; i++) {\r\n            let transformConstraintData = data.transformConstraints[i];\r\n            this.transformConstraints.push(new TransformConstraint(transformConstraintData, this));\r\n        }\r\n\r\n        this.pathConstraints = new Array<PathConstraint>();\r\n        for (let i = 0; i < data.pathConstraints.length; i++) {\r\n            let pathConstraintData = data.pathConstraints[i];\r\n            this.pathConstraints.push(new PathConstraint(pathConstraintData, this));\r\n        }\r\n\r\n        this.color = new Color(1, 1, 1, 1);\r\n        this.updateCache();\r\n    }\r\n\r\n    updateCache () {\r\n        let updateCache = this._updateCache;\r\n        updateCache.length = 0;\r\n        this.updateCacheReset.length = 0;\r\n\r\n        let bones = this.bones;\r\n        for (let i = 0, n = bones.length; i < n; i++) {\r\n            let bone = bones[i];\r\n            bone.sorted = bone.data.skinRequired;\r\n            bone.active = !bone.sorted;\r\n        }\r\n\r\n        if (this.skin != null) {\r\n            let skinBones = this.skin.bones;\r\n            for (let i = 0, n = this.skin.bones.length; i < n; i++) {\r\n                let bone = this.bones[skinBones[i].index];\r\n                do {\r\n                    bone.sorted = false;\r\n                    bone.active = true;\r\n                    bone = bone.parent;\r\n                } while (bone != null);\r\n            }\r\n        }\r\n\r\n        // IK first, lowest hierarchy depth first.\r\n        let ikConstraints = this.ikConstraints;\r\n        let transformConstraints = this.transformConstraints;\r\n        let pathConstraints = this.pathConstraints;\r\n        let ikCount = ikConstraints.length, transformCount = transformConstraints.length, pathCount = pathConstraints.length;\r\n        let constraintCount = ikCount + transformCount + pathCount;\r\n\r\n        outer:\r\n            for (let i = 0; i < constraintCount; i++) {\r\n                for (let ii = 0; ii < ikCount; ii++) {\r\n                    let constraint = ikConstraints[ii];\r\n                    if (constraint.data.order == i) {\r\n                        this.sortIkConstraint(constraint);\r\n                        continue outer;\r\n                    }\r\n                }\r\n                for (let ii = 0; ii < transformCount; ii++) {\r\n                    let constraint = transformConstraints[ii];\r\n                    if (constraint.data.order == i) {\r\n                        this.sortTransformConstraint(constraint);\r\n                        continue outer;\r\n                    }\r\n                }\r\n                for (let ii = 0; ii < pathCount; ii++) {\r\n                    let constraint = pathConstraints[ii];\r\n                    if (constraint.data.order == i) {\r\n                        this.sortPathConstraint(constraint);\r\n                        continue outer;\r\n                    }\r\n                }\r\n            }\r\n\r\n        for (let i = 0, n = bones.length; i < n; i++)\r\n            this.sortBone(bones[i]);\r\n    }\r\n\r\n    sortIkConstraint (constraint: IkConstraint) {\r\n        constraint.active = constraint.target.isActive() && (!constraint.data.skinRequired || (this.skin != null && Utils.contains(this.skin.constraints, constraint.data, true)));\r\n        if (!constraint.active) return;\r\n\r\n        let target = constraint.target;\r\n        this.sortBone(target);\r\n\r\n        let constrained = constraint.bones;\r\n        let parent = constrained[0];\r\n        this.sortBone(parent);\r\n\r\n        if (constrained.length > 1) {\r\n            let child = constrained[constrained.length - 1];\r\n            if (!(this._updateCache.indexOf(child) > -1)) this.updateCacheReset.push(child);\r\n        }\r\n\r\n        this._updateCache.push(constraint);\r\n\r\n        this.sortReset(parent.children);\r\n        constrained[constrained.length - 1].sorted = true;\r\n    }\r\n\r\n    sortPathConstraint (constraint: PathConstraint) {\r\n        constraint.active = constraint.target.bone.isActive() && (!constraint.data.skinRequired || (this.skin != null && Utils.contains(this.skin.constraints, constraint.data, true)));\r\n        if (!constraint.active) return;\r\n\r\n        let slot = constraint.target;\r\n        let slotIndex = slot.data.index;\r\n        let slotBone = slot.bone;\r\n        if (this.skin != null) this.sortPathConstraintAttachment(this.skin, slotIndex, slotBone);\r\n        if (this.data.defaultSkin != null && this.data.defaultSkin != this.skin)\r\n            this.sortPathConstraintAttachment(this.data.defaultSkin, slotIndex, slotBone);\r\n        for (let i = 0, n = this.data.skins.length; i < n; i++)\r\n            this.sortPathConstraintAttachment(this.data.skins[i], slotIndex, slotBone);\r\n\r\n        let attachment = slot.getAttachment();\r\n        if (attachment instanceof PathAttachment) this.sortPathConstraintAttachmentWith(attachment, slotBone);\r\n\r\n        let constrained = constraint.bones;\r\n        let boneCount = constrained.length;\r\n        for (let i = 0; i < boneCount; i++)\r\n            this.sortBone(constrained[i]);\r\n\r\n        this._updateCache.push(constraint);\r\n\r\n        for (let i = 0; i < boneCount; i++)\r\n            this.sortReset(constrained[i].children);\r\n        for (let i = 0; i < boneCount; i++)\r\n            constrained[i].sorted = true;\r\n    }\r\n\r\n    sortTransformConstraint (constraint: TransformConstraint) {\r\n        constraint.active = constraint.target.isActive() && (!constraint.data.skinRequired || (this.skin != null && Utils.contains(this.skin.constraints, constraint.data, true)));\r\n        if (!constraint.active) return;\r\n\r\n        this.sortBone(constraint.target);\r\n\r\n        let constrained = constraint.bones;\r\n        let boneCount = constrained.length;\r\n        if (constraint.data.local) {\r\n            for (let i = 0; i < boneCount; i++) {\r\n                let child = constrained[i];\r\n                this.sortBone(child.parent);\r\n                if (!(this._updateCache.indexOf(child) > -1)) this.updateCacheReset.push(child);\r\n            }\r\n        } else {\r\n            for (let i = 0; i < boneCount; i++) {\r\n                this.sortBone(constrained[i]);\r\n            }\r\n        }\r\n\r\n        this._updateCache.push(constraint);\r\n\r\n        for (let ii = 0; ii < boneCount; ii++)\r\n            this.sortReset(constrained[ii].children);\r\n        for (let ii = 0; ii < boneCount; ii++)\r\n            constrained[ii].sorted = true;\r\n    }\r\n\r\n    sortPathConstraintAttachment (skin: Skin, slotIndex: number, slotBone: Bone) {\r\n        let attachments = skin.attachments[slotIndex];\r\n        if (!attachments) return;\r\n        for (let key in attachments) {\r\n            this.sortPathConstraintAttachmentWith(attachments[key], slotBone);\r\n        }\r\n    }\r\n\r\n    sortPathConstraintAttachmentWith (attachment: Attachment, slotBone: Bone) {\r\n        if (!(attachment instanceof PathAttachment)) return;\r\n        let pathBones = (<PathAttachment>attachment).bones;\r\n        if (pathBones == null)\r\n            this.sortBone(slotBone);\r\n        else {\r\n            let bones = this.bones;\r\n            let i = 0;\r\n            while (i < pathBones.length) {\r\n                let boneCount = pathBones[i++];\r\n                for (let n = i + boneCount; i < n; i++) {\r\n                    let boneIndex = pathBones[i];\r\n                    this.sortBone(bones[boneIndex]);\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    sortBone (bone: Bone) {\r\n        if (bone.sorted) return;\r\n        let parent = bone.parent;\r\n        if (parent != null) this.sortBone(parent);\r\n        bone.sorted = true;\r\n        this._updateCache.push(bone);\r\n    }\r\n\r\n    sortReset (bones: Array<Bone>) {\r\n        for (let i = 0, n = bones.length; i < n; i++) {\r\n            let bone = bones[i];\r\n            if (!bone.active) continue;\r\n            if (bone.sorted) this.sortReset(bone.children);\r\n            bone.sorted = false;\r\n        }\r\n    }\r\n\r\n    /** Updates the world transform for each bone and applies constraints. */\r\n    updateWorldTransform () {\r\n        let updateCacheReset = this.updateCacheReset;\r\n        for (let i = 0, n = updateCacheReset.length; i < n; i++) {\r\n            let bone = updateCacheReset[i] as Bone;\r\n            bone.ax = bone.x;\r\n            bone.ay = bone.y;\r\n            bone.arotation = bone.rotation;\r\n            bone.ascaleX = bone.scaleX;\r\n            bone.ascaleY = bone.scaleY;\r\n            bone.ashearX = bone.shearX;\r\n            bone.ashearY = bone.shearY;\r\n            bone.appliedValid = true;\r\n        }\r\n        let updateCache = this._updateCache;\r\n        for (let i = 0, n = updateCache.length; i < n; i++)\r\n            updateCache[i].update();\r\n    }\r\n\r\n    /** Sets the bones, constraints, and slots to their setup pose values. */\r\n    setToSetupPose () {\r\n        this.setBonesToSetupPose();\r\n        this.setSlotsToSetupPose();\r\n    }\r\n\r\n    /** Sets the bones and constraints to their setup pose values. */\r\n    setBonesToSetupPose () {\r\n        let bones = this.bones;\r\n        for (let i = 0, n = bones.length; i < n; i++)\r\n            bones[i].setToSetupPose();\r\n\r\n        let ikConstraints = this.ikConstraints;\r\n        for (let i = 0, n = ikConstraints.length; i < n; i++) {\r\n            let constraint = ikConstraints[i];\r\n            constraint.mix = constraint.data.mix;\r\n            constraint.softness = constraint.data.softness;\r\n            constraint.bendDirection = constraint.data.bendDirection;\r\n            constraint.compress = constraint.data.compress;\r\n            constraint.stretch = constraint.data.stretch;\r\n        }\r\n\r\n        let transformConstraints = this.transformConstraints;\r\n        for (let i = 0, n = transformConstraints.length; i < n; i++) {\r\n            let constraint = transformConstraints[i];\r\n            let data = constraint.data;\r\n            constraint.rotateMix = data.rotateMix;\r\n            constraint.translateMix = data.translateMix;\r\n            constraint.scaleMix = data.scaleMix;\r\n            constraint.shearMix = data.shearMix;\r\n        }\r\n\r\n        let pathConstraints = this.pathConstraints;\r\n        for (let i = 0, n = pathConstraints.length; i < n; i++) {\r\n            let constraint = pathConstraints[i];\r\n            let data = constraint.data;\r\n            constraint.position = data.position;\r\n            constraint.spacing = data.spacing;\r\n            constraint.rotateMix = data.rotateMix;\r\n            constraint.translateMix = data.translateMix;\r\n        }\r\n    }\r\n\r\n    setSlotsToSetupPose () {\r\n        let slots = this.slots;\r\n        Utils.arrayCopy(slots, 0, this.drawOrder, 0, slots.length);\r\n        for (let i = 0, n = slots.length; i < n; i++)\r\n            slots[i].setToSetupPose();\r\n    }\r\n\r\n    /** @return May return null. */\r\n    getRootBone () {\r\n        if (this.bones.length == 0) return null;\r\n        return this.bones[0];\r\n    }\r\n\r\n    /** @return May be null. */\r\n    findBone (boneName: string) {\r\n        if (boneName == null) throw new Error(\"boneName cannot be null.\");\r\n        let bones = this.bones;\r\n        for (let i = 0, n = bones.length; i < n; i++) {\r\n            let bone = bones[i];\r\n            if (bone.data.name == boneName) return bone;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    /** @return -1 if the bone was not found. */\r\n    findBoneIndex (boneName: string) {\r\n        if (boneName == null) throw new Error(\"boneName cannot be null.\");\r\n        let bones = this.bones;\r\n        for (let i = 0, n = bones.length; i < n; i++)\r\n            if (bones[i].data.name == boneName) return i;\r\n        return -1;\r\n    }\r\n\r\n    /** @return May be null. */\r\n    findSlot (slotName: string) {\r\n        if (slotName == null) throw new Error(\"slotName cannot be null.\");\r\n        let slots = this.slots;\r\n        for (let i = 0, n = slots.length; i < n; i++) {\r\n            let slot = slots[i];\r\n            if (slot.data.name == slotName) return slot;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    /** @return -1 if the bone was not found. */\r\n    findSlotIndex (slotName: string) {\r\n        if (slotName == null) throw new Error(\"slotName cannot be null.\");\r\n        let slots = this.slots;\r\n        for (let i = 0, n = slots.length; i < n; i++)\r\n            if (slots[i].data.name == slotName) return i;\r\n        return -1;\r\n    }\r\n\r\n    /** Sets a skin by name.\r\n     * @see #setSkin(Skin) */\r\n    setSkinByName (skinName: string) {\r\n        let skin = this.data.findSkin(skinName);\r\n        if (skin == null) throw new Error(\"Skin not found: \" + skinName);\r\n        this.setSkin(skin);\r\n    }\r\n\r\n    /** Sets the skin used to look up attachments before looking in the {@link SkeletonData#getDefaultSkin() default skin}.\r\n     * Attachments from the new skin are attached if the corresponding attachment from the old skin was attached. If there was no\r\n     * old skin, each slot's setup mode attachment is attached from the new skin.\r\n     * @param newSkin May be null. */\r\n    setSkin (newSkin: Skin) {\r\n        if (newSkin == this.skin) return;\r\n        if (newSkin != null) {\r\n            if (this.skin != null)\r\n                newSkin.attachAll(this, this.skin);\r\n            else {\r\n                let slots = this.slots;\r\n                for (let i = 0, n = slots.length; i < n; i++) {\r\n                    let slot = slots[i];\r\n                    let name = slot.data.attachmentName;\r\n                    if (name != null) {\r\n                        let attachment: Attachment = newSkin.getAttachment(i, name);\r\n                        if (attachment != null) slot.setAttachment(attachment);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        this.skin = newSkin;\r\n        this.updateCache();\r\n    }\r\n\r\n    /** @return May be null. */\r\n    getAttachmentByName (slotName: string, attachmentName: string): Attachment {\r\n        return this.getAttachment(this.data.findSlotIndex(slotName), attachmentName);\r\n    }\r\n\r\n    /** @return May be null. */\r\n    getAttachment (slotIndex: number, attachmentName: string): Attachment {\r\n        if (attachmentName == null) throw new Error(\"attachmentName cannot be null.\");\r\n        if (this.skin != null) {\r\n            let attachment: Attachment = this.skin.getAttachment(slotIndex, attachmentName);\r\n            if (attachment != null) return attachment;\r\n        }\r\n        if (this.data.defaultSkin != null) return this.data.defaultSkin.getAttachment(slotIndex, attachmentName);\r\n        return null;\r\n    }\r\n\r\n    /** @param attachmentName May be null. */\r\n    setAttachment (slotName: string, attachmentName?: string) {\r\n        if (slotName == null) throw new Error(\"slotName cannot be null.\");\r\n        let slots = this.slots;\r\n        for (let i = 0, n = slots.length; i < n; i++) {\r\n            let slot = slots[i];\r\n            if (slot.data.name == slotName) {\r\n                let attachment: Attachment = null;\r\n                if (attachmentName != null) {\r\n                    attachment = this.getAttachment(i, attachmentName);\r\n                    if (attachment == null)\r\n                        throw new Error(\"Attachment not found: \" + attachmentName + \", for slot: \" + slotName);\r\n                }\r\n                slot.setAttachment(attachment);\r\n                return;\r\n            }\r\n        }\r\n        throw new Error(\"Slot not found: \" + slotName);\r\n    }\r\n\r\n    /** @return May be null. */\r\n    findIkConstraint (constraintName: string) {\r\n        if (constraintName == null) throw new Error(\"constraintName cannot be null.\");\r\n        let ikConstraints = this.ikConstraints;\r\n        for (let i = 0, n = ikConstraints.length; i < n; i++) {\r\n            let ikConstraint = ikConstraints[i];\r\n            if (ikConstraint.data.name == constraintName) return ikConstraint;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    /** @return May be null. */\r\n    findTransformConstraint (constraintName: string) {\r\n        if (constraintName == null) throw new Error(\"constraintName cannot be null.\");\r\n        let transformConstraints = this.transformConstraints;\r\n        for (let i = 0, n = transformConstraints.length; i < n; i++) {\r\n            let constraint = transformConstraints[i];\r\n            if (constraint.data.name == constraintName) return constraint;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    /** @return May be null. */\r\n    findPathConstraint (constraintName: string) {\r\n        if (constraintName == null) throw new Error(\"constraintName cannot be null.\");\r\n        let pathConstraints = this.pathConstraints;\r\n        for (let i = 0, n = pathConstraints.length; i < n; i++) {\r\n            let constraint = pathConstraints[i];\r\n            if (constraint.data.name == constraintName) return constraint;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    /** Returns the axis aligned bounding box (AABB) of the region and mesh attachments for the current pose.\r\n     * @param offset The distance from the skeleton origin to the bottom left corner of the AABB.\r\n     * @param size The width and height of the AABB.\r\n     * @param temp Working memory */\r\n    getBounds (offset: Vector2, size: Vector2, temp: Array<number> = new Array<number>(2)) {\r\n        if (offset == null) throw new Error(\"offset cannot be null.\");\r\n        if (size == null) throw new Error(\"size cannot be null.\");\r\n        let drawOrder = this.drawOrder;\r\n        let minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;\r\n        for (let i = 0, n = drawOrder.length; i < n; i++) {\r\n            let slot = drawOrder[i];\r\n            if (!slot.bone.active) continue;\r\n            let verticesLength = 0;\r\n            let vertices: ArrayLike<number> = null;\r\n            let attachment = slot.getAttachment();\r\n            if (attachment instanceof RegionAttachment) {\r\n                verticesLength = 8;\r\n                vertices = Utils.setArraySize(temp, verticesLength, 0);\r\n                (<RegionAttachment>attachment).computeWorldVertices(slot.bone, vertices, 0, 2);\r\n            } else if (attachment instanceof MeshAttachment) {\r\n                let mesh = (<MeshAttachment>attachment);\r\n                verticesLength = mesh.worldVerticesLength;\r\n                vertices = Utils.setArraySize(temp, verticesLength, 0);\r\n                mesh.computeWorldVertices(slot, 0, verticesLength, vertices, 0, 2);\r\n            }\r\n            if (vertices != null) {\r\n                for (let ii = 0, nn = vertices.length; ii < nn; ii += 2) {\r\n                    let x = vertices[ii], y = vertices[ii + 1];\r\n                    minX = Math.min(minX, x);\r\n                    minY = Math.min(minY, y);\r\n                    maxX = Math.max(maxX, x);\r\n                    maxY = Math.max(maxY, y);\r\n                }\r\n            }\r\n        }\r\n        offset.set(minX, minY);\r\n        size.set(maxX - minX, maxY - minY);\r\n    }\r\n\r\n    update (delta: number) {\r\n        this.time += delta;\r\n    }\r\n\r\n    get flipX(): boolean {\r\n        return this.scaleX == -1;\r\n    }\r\n\r\n    set flipX(value: boolean) {\r\n        if (!Skeleton.deprecatedWarning1) {\r\n            Skeleton.deprecatedWarning1 = true;\r\n            console.warn(\"Spine Deprecation Warning: `Skeleton.flipX/flipY` was deprecated, please use scaleX/scaleY\");\r\n        }\r\n        this.scaleX = value ? 1.0 : -1.0;\r\n    }\r\n\r\n    get flipY(): boolean {\r\n        return this.scaleY == -1;\r\n    }\r\n\r\n    set flipY(value: boolean) {\r\n        if (!Skeleton.deprecatedWarning1) {\r\n            Skeleton.deprecatedWarning1 = true;\r\n            console.warn(\"Spine Deprecation Warning: `Skeleton.flipX/flipY` was deprecated, please use scaleX/scaleY\");\r\n        }\r\n        this.scaleY = value ? 1.0 : -1.0;\r\n    }\r\n\r\n    private static deprecatedWarning1: boolean = false;\r\n}\r\n","import type {ISkeletonData} from '@pixi-spine/base';\r\nimport type {Animation} from \"./Animation\";\r\nimport {BoneData} from \"./BoneData\";\r\nimport {SlotData} from \"./SlotData\";\r\nimport {Skin} from \"./Skin\";\r\nimport {EventData} from \"./EventData\";\r\nimport {IkConstraintData} from \"./IkConstraintData\";\r\nimport {TransformConstraintData} from \"./TransformConstraintData\";\r\nimport {PathConstraintData} from \"./PathConstraintData\";\r\n\r\n/**\r\n * @public\r\n */\r\nexport class SkeletonData implements ISkeletonData<BoneData, SlotData, Skin, Animation, EventData, IkConstraintData, TransformConstraintData, PathConstraintData> {\r\n    name: string;\r\n    bones = new Array<BoneData>(); // Ordered parents first.\r\n    slots = new Array<SlotData>(); // Setup pose draw order.\r\n    skins = new Array<Skin>();\r\n    defaultSkin: Skin;\r\n    events = new Array<EventData>();\r\n    animations = new Array<Animation>();\r\n    ikConstraints = new Array<IkConstraintData>();\r\n    transformConstraints = new Array<TransformConstraintData>();\r\n    pathConstraints = new Array<PathConstraintData>();\r\n    x: number; y: number; width: number; height: number;\r\n    version: string; hash: string;\r\n\r\n    // Nonessential\r\n    fps = 0;\r\n    imagesPath: string;\r\n    audioPath: string;\r\n\r\n    findBone (boneName: string) {\r\n        if (boneName == null) throw new Error(\"boneName cannot be null.\");\r\n        let bones = this.bones;\r\n        for (let i = 0, n = bones.length; i < n; i++) {\r\n            let bone = bones[i];\r\n            if (bone.name == boneName) return bone;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    findBoneIndex (boneName: string) {\r\n        if (boneName == null) throw new Error(\"boneName cannot be null.\");\r\n        let bones = this.bones;\r\n        for (let i = 0, n = bones.length; i < n; i++)\r\n            if (bones[i].name == boneName) return i;\r\n        return -1;\r\n    }\r\n\r\n    findSlot (slotName: string) {\r\n        if (slotName == null) throw new Error(\"slotName cannot be null.\");\r\n        let slots = this.slots;\r\n        for (let i = 0, n = slots.length; i < n; i++) {\r\n            let slot = slots[i];\r\n            if (slot.name == slotName) return slot;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    findSlotIndex (slotName: string) {\r\n        if (slotName == null) throw new Error(\"slotName cannot be null.\");\r\n        let slots = this.slots;\r\n        for (let i = 0, n = slots.length; i < n; i++)\r\n            if (slots[i].name == slotName) return i;\r\n        return -1;\r\n    }\r\n\r\n    findSkin (skinName: string) {\r\n        if (skinName == null) throw new Error(\"skinName cannot be null.\");\r\n        let skins = this.skins;\r\n        for (let i = 0, n = skins.length; i < n; i++) {\r\n            let skin = skins[i];\r\n            if (skin.name == skinName) return skin;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    findEvent (eventDataName: string) {\r\n        if (eventDataName == null) throw new Error(\"eventDataName cannot be null.\");\r\n        let events = this.events;\r\n        for (let i = 0, n = events.length; i < n; i++) {\r\n            let event = events[i];\r\n            if (event.name == eventDataName) return event;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    findAnimation (animationName: string) {\r\n        if (animationName == null) throw new Error(\"animationName cannot be null.\");\r\n        let animations = this.animations;\r\n        for (let i = 0, n = animations.length; i < n; i++) {\r\n            let animation = animations[i];\r\n            if (animation.name == animationName) return animation;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    findIkConstraint (constraintName: string) {\r\n        if (constraintName == null) throw new Error(\"constraintName cannot be null.\");\r\n        let ikConstraints = this.ikConstraints;\r\n        for (let i = 0, n = ikConstraints.length; i < n; i++) {\r\n            let constraint = ikConstraints[i];\r\n            if (constraint.name == constraintName) return constraint;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    findTransformConstraint (constraintName: string) {\r\n        if (constraintName == null) throw new Error(\"constraintName cannot be null.\");\r\n        let transformConstraints = this.transformConstraints;\r\n        for (let i = 0, n = transformConstraints.length; i < n; i++) {\r\n            let constraint = transformConstraints[i];\r\n            if (constraint.name == constraintName) return constraint;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    findPathConstraint (constraintName: string) {\r\n        if (constraintName == null) throw new Error(\"constraintName cannot be null.\");\r\n        let pathConstraints = this.pathConstraints;\r\n        for (let i = 0, n = pathConstraints.length; i < n; i++) {\r\n            let constraint = pathConstraints[i];\r\n            if (constraint.name == constraintName) return constraint;\r\n        }\r\n        return null;\r\n    }\r\n\r\n    findPathConstraintIndex (pathConstraintName: string) {\r\n        if (pathConstraintName == null) throw new Error(\"pathConstraintName cannot be null.\");\r\n        let pathConstraints = this.pathConstraints;\r\n        for (let i = 0, n = pathConstraints.length; i < n; i++)\r\n            if (pathConstraints[i].name == pathConstraintName) return i;\r\n        return -1;\r\n    }\r\n}\r\n","import {Color} from '@pixi-spine/base';\r\n\r\nimport type {ISlotData} from '@pixi-spine/base';\r\nimport type {BLEND_MODES} from '@pixi/constants';\r\nimport {BoneData} from \"./BoneData\";\r\n\r\n/**\r\n * @public\r\n */\r\nexport class SlotData implements ISlotData {\r\n    index: number;\r\n    name: string;\r\n    boneData: BoneData;\r\n    color = new Color(1, 1, 1, 1);\r\n    darkColor: Color;\r\n    attachmentName: string;\r\n    blendMode: BLEND_MODES;\r\n\r\n    constructor (index: number, name: string, boneData: BoneData) {\r\n        if (index < 0) throw new Error(\"index must be >= 0.\");\r\n        if (name == null) throw new Error(\"name cannot be null.\");\r\n        if (boneData == null) throw new Error(\"boneData cannot be null.\");\r\n        this.index = index;\r\n        this.name = name;\r\n        this.boneData = boneData;\r\n    }\r\n}\r\n","import {BoneData} from './BoneData';\r\nimport {ConstraintData} from './Constraint';\r\n\r\n/**\r\n * @public\r\n */\r\nexport class TransformConstraintData extends ConstraintData {\r\n    bones = new Array<BoneData>();\r\n    target: BoneData;\r\n    rotateMix = 0; translateMix = 0; scaleMix = 0; shearMix = 0;\r\n    offsetRotation = 0; offsetX = 0; offsetY = 0; offsetScaleX = 0; offsetScaleY = 0; offsetShearY = 0;\r\n    relative = false;\r\n    local = false;\r\n\r\n    constructor (name: string) {\r\n        super(name, 0, false);\r\n    }\r\n}\r\n","import {Attachment, MeshAttachment} from './attachments';\r\nimport {BoneData} from \"./BoneData\";\r\nimport {ConstraintData} from \"./Constraint\";\r\nimport {Skeleton} from \"./Skeleton\";\r\n\r\nimport type {Map, ISkin} from '@pixi-spine/base';\r\n\r\n/**\r\n * @public\r\n */\r\nexport class SkinEntry {\r\n    constructor(public slotIndex: number, public name: string, public attachment: Attachment) { }\r\n}\r\n\r\n/**\r\n * @public\r\n */\r\nexport class Skin implements ISkin {\r\n    name: string;\r\n    attachments = new Array<Map<Attachment>>();\r\n    bones = Array<BoneData>();\r\n    constraints = new Array<ConstraintData>();\r\n\r\n    constructor (name: string) {\r\n        if (name == null) throw new Error(\"name cannot be null.\");\r\n        this.name = name;\r\n    }\r\n\r\n    setAttachment (slotIndex: number, name: string, attachment: Attachment) {\r\n        if (attachment == null) throw new Error(\"attachment cannot be null.\");\r\n        let attachments = this.attachments;\r\n        if (slotIndex >= attachments.length) attachments.length = slotIndex + 1;\r\n        if (!attachments[slotIndex]) attachments[slotIndex] = { };\r\n        attachments[slotIndex][name] = attachment;\r\n    }\r\n\r\n    addSkin (skin: Skin) {\r\n        for(let i = 0; i < skin.bones.length; i++) {\r\n            let bone = skin.bones[i];\r\n            let contained = false;\r\n            for (let j = 0; j < this.bones.length; j++) {\r\n                if (this.bones[j] == bone) {\r\n                    contained = true;\r\n                    break;\r\n                }\r\n            }\r\n            if (!contained) this.bones.push(bone);\r\n        }\r\n\r\n        for(let i = 0; i < skin.constraints.length; i++) {\r\n            let constraint = skin.constraints[i];\r\n            let contained = false;\r\n            for (let j = 0; j < this.constraints.length; j++) {\r\n                if (this.constraints[j] == constraint) {\r\n                    contained = true;\r\n                    break;\r\n                }\r\n            }\r\n            if (!contained) this.constraints.push(constraint);\r\n        }\r\n\r\n        let attachments = skin.getAttachments();\r\n        for (let i = 0; i < attachments.length; i++) {\r\n            var attachment = attachments[i];\r\n            this.setAttachment(attachment.slotIndex, attachment.name, attachment.attachment);\r\n        }\r\n    }\r\n\r\n    copySkin (skin: Skin) {\r\n        for(let i = 0; i < skin.bones.length; i++) {\r\n            let bone = skin.bones[i];\r\n            let contained = false;\r\n            for (let j = 0; j < this.bones.length; j++) {\r\n                if (this.bones[j] == bone) {\r\n                    contained = true;\r\n                    break;\r\n                }\r\n            }\r\n            if (!contained) this.bones.push(bone);\r\n        }\r\n\r\n        for(let i = 0; i < skin.constraints.length; i++) {\r\n            let constraint = skin.constraints[i];\r\n            let contained = false;\r\n            for (let j = 0; j < this.constraints.length; j++) {\r\n                if (this.constraints[j] == constraint) {\r\n                    contained = true;\r\n                    break;\r\n                }\r\n            }\r\n            if (!contained) this.constraints.push(constraint);\r\n        }\r\n\r\n        let attachments = skin.getAttachments();\r\n        for (let i = 0; i < attachments.length; i++) {\r\n            var attachment = attachments[i];\r\n            if (attachment.attachment == null) continue;\r\n            if (attachment.attachment instanceof MeshAttachment) {\r\n                attachment.attachment = attachment.attachment.newLinkedMesh();\r\n                this.setAttachment(attachment.slotIndex, attachment.name, attachment.attachment);\r\n            } else {\r\n                attachment.attachment = attachment.attachment.copy();\r\n                this.setAttachment(attachment.slotIndex, attachment.name, attachment.attachment);\r\n            }\r\n        }\r\n    }\r\n\r\n    /** @return May be null. */\r\n    getAttachment (slotIndex: number, name: string): Attachment {\r\n        let dictionary = this.attachments[slotIndex];\r\n        return dictionary ? dictionary[name] : null;\r\n    }\r\n\r\n    removeAttachment (slotIndex: number, name: string) {\r\n        let dictionary = this.attachments[slotIndex];\r\n        if (dictionary) dictionary[name] = null;\r\n    }\r\n\r\n    getAttachments (): Array<SkinEntry> {\r\n        let entries = new Array<SkinEntry>();\r\n        for (var i = 0; i < this.attachments.length; i++) {\r\n            let slotAttachments = this.attachments[i];\r\n            if (slotAttachments) {\r\n                for (let name in slotAttachments) {\r\n                    let attachment = slotAttachments[name];\r\n                    if (attachment) entries.push(new SkinEntry(i, name, attachment));\r\n                }\r\n            }\r\n        }\r\n        return entries;\r\n    }\r\n\r\n    getAttachmentsForSlot (slotIndex: number, attachments: Array<SkinEntry>) {\r\n        let slotAttachments = this.attachments[slotIndex];\r\n        if (slotAttachments) {\r\n            for (let name in slotAttachments) {\r\n                let attachment = slotAttachments[name];\r\n                if (attachment) attachments.push(new SkinEntry(slotIndex, name, attachment));\r\n            }\r\n        }\r\n    }\r\n\r\n    clear () {\r\n        this.attachments.length = 0;\r\n        this.bones.length = 0;\r\n        this.constraints.length = 0;\r\n    }\r\n\r\n    /** Attach each attachment in this skin if the corresponding attachment in the old skin is currently attached. */\r\n    attachAll (skeleton: Skeleton, oldSkin: Skin) {\r\n        let slotIndex = 0;\r\n        for (let i = 0; i < skeleton.slots.length; i++) {\r\n            let slot = skeleton.slots[i];\r\n            let slotAttachment = slot.getAttachment();\r\n            if (slotAttachment && slotIndex < oldSkin.attachments.length) {\r\n                let dictionary = oldSkin.attachments[slotIndex];\r\n                for (let key in dictionary) {\r\n                    let skinAttachment:Attachment = dictionary[key];\r\n                    if (slotAttachment == skinAttachment) {\r\n                        let attachment = this.getAttachment(slotIndex, key);\r\n                        if (attachment != null) slot.setAttachment(attachment);\r\n                        break;\r\n                    }\r\n                }\r\n            }\r\n            slotIndex++;\r\n        }\r\n    }\r\n}\r\n","import type {Attachment, AttachmentLoader, MeshAttachment, VertexAttachment} from './attachments';\r\nimport {Animation} from './Animation';\r\nimport {Event} from './Event';\r\nimport {SkeletonData} from './SkeletonData';\r\nimport {SlotData} from './SlotData';\r\nimport {BoneData} from './BoneData';\r\nimport {IkConstraintData} from './IkConstraintData';\r\nimport {TransformConstraintData} from './TransformConstraintData';\r\nimport {PathConstraintData, SpacingMode} from './PathConstraintData';\r\nimport {Skin} from './Skin';\r\nimport {EventData} from './EventData';\r\nimport {\r\n    AttachmentTimeline,\r\n    ColorTimeline, CurveTimeline, DeformTimeline, DrawOrderTimeline, EventTimeline,\r\n    IkConstraintTimeline,\r\n    PathConstraintMixTimeline,\r\n    PathConstraintPositionTimeline,\r\n    PathConstraintSpacingTimeline,\r\n    RotateTimeline,\r\n    ScaleTimeline,\r\n    ShearTimeline,\r\n    Timeline,\r\n    TransformConstraintTimeline,\r\n    TranslateTimeline,\r\n    TwoColorTimeline\r\n} from './Animation';\r\nimport {AttachmentType, BinaryInput, Color, PositionMode, RotateMode, TransformMode, Utils} from '@pixi-spine/base';\r\nimport {BLEND_MODES} from '@pixi/constants';\r\n\r\n/**\r\n * @public\r\n */\r\nexport class SkeletonBinary {\r\n    static AttachmentTypeValues = [ 0 /*AttachmentType.Region*/, 1/*AttachmentType.BoundingBox*/, 2/*AttachmentType.Mesh*/, 3/*AttachmentType.LinkedMesh*/, 4/*AttachmentType.Path*/, 5/*AttachmentType.Point*/, 6/*AttachmentType.Clipping*/ ];\r\n    static TransformModeValues = [TransformMode.Normal, TransformMode.OnlyTranslation, TransformMode.NoRotationOrReflection, TransformMode.NoScale, TransformMode.NoScaleOrReflection];\r\n    static PositionModeValues = [ PositionMode.Fixed, PositionMode.Percent ];\r\n    static SpacingModeValues = [ SpacingMode.Length, SpacingMode.Fixed, SpacingMode.Percent];\r\n    static RotateModeValues = [ RotateMode.Tangent, RotateMode.Chain, RotateMode.ChainScale ];\r\n    static BlendModeValues = [ BLEND_MODES.NORMAL, BLEND_MODES.ADD, BLEND_MODES.MULTIPLY, BLEND_MODES.SCREEN];\r\n\r\n    static BONE_ROTATE = 0;\r\n    static BONE_TRANSLATE = 1;\r\n    static BONE_SCALE = 2;\r\n    static BONE_SHEAR = 3;\r\n\r\n    static SLOT_ATTACHMENT = 0;\r\n    static SLOT_COLOR = 1;\r\n    static SLOT_TWO_COLOR = 2;\r\n\r\n    static PATH_POSITION = 0;\r\n    static PATH_SPACING = 1;\r\n    static PATH_MIX = 2;\r\n\r\n    static CURVE_LINEAR = 0;\r\n    static CURVE_STEPPED = 1;\r\n    static CURVE_BEZIER = 2;\r\n\r\n    attachmentLoader: AttachmentLoader;\r\n    scale = 1;\r\n    private linkedMeshes = new Array<LinkedMesh>();\r\n\r\n    constructor (attachmentLoader: AttachmentLoader) {\r\n        this.attachmentLoader = attachmentLoader;\r\n    }\r\n\r\n    readSkeletonData (binary: Uint8Array): SkeletonData {\r\n        let scale = this.scale;\r\n\r\n        let skeletonData = new SkeletonData();\r\n        skeletonData.name = \"\"; // BOZO\r\n\r\n        let input = new BinaryInput(binary);\r\n\r\n        skeletonData.hash = input.readString();\r\n        skeletonData.version = input.readString();\r\n        if (skeletonData.version === '3.8.75')\r\n        {\r\n            let error = `Unsupported skeleton data, 3.8.75 is deprecated, please export with a newer version of Spine.`;\r\n            console.error(error);\r\n        }\r\n        skeletonData.x = input.readFloat();\r\n        skeletonData.y = input.readFloat();\r\n        skeletonData.width = input.readFloat();\r\n        skeletonData.height = input.readFloat();\r\n\r\n        let nonessential = input.readBoolean();\r\n        if (nonessential) {\r\n            skeletonData.fps = input.readFloat();\r\n\r\n            skeletonData.imagesPath = input.readString();\r\n            skeletonData.audioPath = input.readString();\r\n        }\r\n\r\n        let n = 0;\r\n        // Strings.\r\n        n = input.readInt(true)\r\n        for (let i = 0; i < n; i++)\r\n            input.strings.push(input.readString());\r\n\r\n        // Bones.\r\n        n = input.readInt(true)\r\n        for (let i = 0; i < n; i++) {\r\n            let name = input.readString();\r\n            let parent = i == 0 ? null : skeletonData.bones[input.readInt(true)];\r\n            let data = new BoneData(i, name, parent);\r\n            data.rotation = input.readFloat();\r\n            data.x = input.readFloat() * scale;\r\n            data.y = input.readFloat() * scale;\r\n            data.scaleX = input.readFloat();\r\n            data.scaleY = input.readFloat();\r\n            data.shearX = input.readFloat();\r\n            data.shearY = input.readFloat();\r\n            data.length = input.readFloat() * scale;\r\n            data.transformMode = SkeletonBinary.TransformModeValues[input.readInt(true)];\r\n            data.skinRequired = input.readBoolean();\r\n            if (nonessential) Color.rgba8888ToColor(data.color, input.readInt32());\r\n            skeletonData.bones.push(data);\r\n        }\r\n\r\n        // Slots.\r\n        n = input.readInt(true);\r\n        for (let i = 0; i < n; i++) {\r\n            let slotName = input.readString();\r\n            let boneData = skeletonData.bones[input.readInt(true)];\r\n            let data = new SlotData(i, slotName, boneData);\r\n            Color.rgba8888ToColor(data.color, input.readInt32());\r\n\r\n            let darkColor = input.readInt32();\r\n            if (darkColor != -1) Color.rgb888ToColor(data.darkColor = new Color(), darkColor);\r\n\r\n            data.attachmentName = input.readStringRef();\r\n            data.blendMode = SkeletonBinary.BlendModeValues[input.readInt(true)];\r\n            skeletonData.slots.push(data);\r\n        }\r\n\r\n        // IK constraints.\r\n        n = input.readInt(true);\r\n        for (let i = 0, nn; i < n; i++) {\r\n            let data = new IkConstraintData(input.readString());\r\n            data.order = input.readInt(true);\r\n            data.skinRequired = input.readBoolean();\r\n            nn = input.readInt(true);\r\n            for (let ii = 0; ii < nn; ii++)\r\n                data.bones.push(skeletonData.bones[input.readInt(true)]);\r\n            data.target = skeletonData.bones[input.readInt(true)];\r\n            data.mix = input.readFloat();\r\n            data.softness = input.readFloat() * scale;\r\n            data.bendDirection = input.readByte();\r\n            data.compress = input.readBoolean();\r\n            data.stretch = input.readBoolean();\r\n            data.uniform = input.readBoolean();\r\n            skeletonData.ikConstraints.push(data);\r\n        }\r\n\r\n        // Transform constraints.\r\n        n = input.readInt(true);\r\n        for (let i = 0, nn; i < n; i++) {\r\n            let data = new TransformConstraintData(input.readString());\r\n            data.order = input.readInt(true);\r\n            data.skinRequired = input.readBoolean();\r\n            nn = input.readInt(true);\r\n            for (let ii = 0; ii < nn; ii++)\r\n                data.bones.push(skeletonData.bones[input.readInt(true)]);\r\n            data.target = skeletonData.bones[input.readInt(true)];\r\n            data.local = input.readBoolean();\r\n            data.relative = input.readBoolean();\r\n            data.offsetRotation = input.readFloat();\r\n            data.offsetX = input.readFloat() * scale;\r\n            data.offsetY = input.readFloat() * scale;\r\n            data.offsetScaleX = input.readFloat();\r\n            data.offsetScaleY = input.readFloat();\r\n            data.offsetShearY = input.readFloat();\r\n            data.rotateMix = input.readFloat();\r\n            data.translateMix = input.readFloat();\r\n            data.scaleMix = input.readFloat();\r\n            data.shearMix = input.readFloat();\r\n            skeletonData.transformConstraints.push(data);\r\n        }\r\n\r\n        // Path constraints.\r\n        n = input.readInt(true);\r\n        for (let i = 0, nn; i < n; i++) {\r\n            let data = new PathConstraintData(input.readString());\r\n            data.order = input.readInt(true);\r\n            data.skinRequired = input.readBoolean();\r\n            nn = input.readInt(true);\r\n            for (let ii = 0; ii < nn; ii++)\r\n                data.bones.push(skeletonData.bones[input.readInt(true)]);\r\n            data.target = skeletonData.slots[input.readInt(true)];\r\n            data.positionMode = SkeletonBinary.PositionModeValues[input.readInt(true)];\r\n            data.spacingMode = SkeletonBinary.SpacingModeValues[input.readInt(true)];\r\n            data.rotateMode = SkeletonBinary.RotateModeValues[input.readInt(true)];\r\n            data.offsetRotation = input.readFloat();\r\n            data.position = input.readFloat();\r\n            if (data.positionMode == PositionMode.Fixed) data.position *= scale;\r\n            data.spacing = input.readFloat();\r\n            if (data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed) data.spacing *= scale;\r\n            data.rotateMix = input.readFloat();\r\n            data.translateMix = input.readFloat();\r\n            skeletonData.pathConstraints.push(data);\r\n        }\r\n\r\n        // Default skin.\r\n        let defaultSkin = this.readSkin(input, skeletonData, true, nonessential);\r\n        if (defaultSkin != null) {\r\n            skeletonData.defaultSkin = defaultSkin;\r\n            skeletonData.skins.push(defaultSkin);\r\n        }\r\n\r\n        // Skins.\r\n        {\r\n            let i = skeletonData.skins.length;\r\n            Utils.setArraySize(skeletonData.skins, n = i + input.readInt(true));\r\n            for (; i < n; i++)\r\n                skeletonData.skins[i] = this.readSkin(input, skeletonData, false, nonessential);\r\n        }\r\n\r\n        // Linked meshes.\r\n        n = this.linkedMeshes.length;\r\n        for (let i = 0; i < n; i++) {\r\n            let linkedMesh = this.linkedMeshes[i];\r\n            let skin = linkedMesh.skin == null ? skeletonData.defaultSkin : skeletonData.findSkin(linkedMesh.skin);\r\n            if (skin == null) throw new Error(\"Skin not found: \" + linkedMesh.skin);\r\n            let parent = skin.getAttachment(linkedMesh.slotIndex, linkedMesh.parent);\r\n            if (parent == null) throw new Error(\"Parent mesh not found: \" + linkedMesh.parent);\r\n            linkedMesh.mesh.deformAttachment = linkedMesh.inheritDeform ? parent as VertexAttachment : linkedMesh.mesh;\r\n            linkedMesh.mesh.setParentMesh(parent as MeshAttachment);\r\n            // linkedMesh.mesh.updateUVs();\r\n        }\r\n        this.linkedMeshes.length = 0;\r\n\r\n        // Events.\r\n        n = input.readInt(true);\r\n        for (let i = 0; i < n; i++) {\r\n            let data = new EventData(input.readStringRef());\r\n            data.intValue = input.readInt(false);\r\n            data.floatValue = input.readFloat();\r\n            data.stringValue = input.readString();\r\n            data.audioPath = input.readString();\r\n            if (data.audioPath != null) {\r\n                data.volume = input.readFloat();\r\n                data.balance = input.readFloat();\r\n            }\r\n            skeletonData.events.push(data);\r\n        }\r\n\r\n        // Animations.\r\n        n = input.readInt(true);\r\n        for (let i = 0; i < n; i++)\r\n            skeletonData.animations.push(this.readAnimation(input, input.readString(), skeletonData));\r\n        return skeletonData;\r\n    }\r\n\r\n    private readSkin (input: BinaryInput, skeletonData: SkeletonData, defaultSkin: boolean, nonessential: boolean): Skin {\r\n        let skin = null;\r\n        let slotCount = 0;\r\n\r\n        if (defaultSkin) {\r\n            slotCount = input.readInt(true)\r\n            if (slotCount == 0) return null;\r\n            skin = new Skin(\"default\");\r\n        } else {\r\n            skin = new Skin(input.readStringRef());\r\n            skin.bones.length = input.readInt(true);\r\n            for (let i = 0, n = skin.bones.length; i < n; i++)\r\n                skin.bones[i] = skeletonData.bones[input.readInt(true)];\r\n\r\n            for (let i = 0, n = input.readInt(true); i < n; i++)\r\n                skin.constraints.push(skeletonData.ikConstraints[input.readInt(true)]);\r\n            for (let i = 0, n = input.readInt(true); i < n; i++)\r\n                skin.constraints.push(skeletonData.transformConstraints[input.readInt(true)]);\r\n            for (let i = 0, n = input.readInt(true); i < n; i++)\r\n                skin.constraints.push(skeletonData.pathConstraints[input.readInt(true)]);\r\n\r\n            slotCount = input.readInt(true);\r\n        }\r\n\r\n        for (let i = 0; i < slotCount; i++) {\r\n            let slotIndex = input.readInt(true);\r\n            for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) {\r\n                let name = input.readStringRef();\r\n                let attachment = this.readAttachment(input, skeletonData, skin, slotIndex, name, nonessential);\r\n                if (attachment != null) skin.setAttachment(slotIndex, name, attachment);\r\n            }\r\n        }\r\n        return skin;\r\n    }\r\n\r\n    private readAttachment(input: BinaryInput, skeletonData: SkeletonData, skin: Skin, slotIndex: number, attachmentName: string, nonessential: boolean): Attachment {\r\n        let scale = this.scale;\r\n\r\n        let name = input.readStringRef();\r\n        if (name == null) name = attachmentName;\r\n\r\n        let typeIndex = input.readByte();\r\n        let type = SkeletonBinary.AttachmentTypeValues[typeIndex];\r\n        switch (type) {\r\n        case AttachmentType.Region: {\r\n            let path = input.readStringRef();\r\n            let rotation = input.readFloat();\r\n            let x = input.readFloat();\r\n            let y = input.readFloat();\r\n            let scaleX = input.readFloat();\r\n            let scaleY = input.readFloat();\r\n            let width = input.readFloat();\r\n            let height = input.readFloat();\r\n            let color = input.readInt32();\r\n\r\n            if (path == null) path = name;\r\n            let region = this.attachmentLoader.newRegionAttachment(skin, name, path);\r\n            if (region == null) return null;\r\n            region.path = path;\r\n            region.x = x * scale;\r\n            region.y = y * scale;\r\n            region.scaleX = scaleX;\r\n            region.scaleY = scaleY;\r\n            region.rotation = rotation;\r\n            region.width = width * scale;\r\n            region.height = height * scale;\r\n            Color.rgba8888ToColor(region.color, color);\r\n            // region.updateOffset();\r\n            return region;\r\n        }\r\n        case AttachmentType.BoundingBox: {\r\n            let vertexCount = input.readInt(true);\r\n            let vertices = this.readVertices(input, vertexCount);\r\n            let color = nonessential ? input.readInt32() : 0;\r\n\r\n            let box = this.attachmentLoader.newBoundingBoxAttachment(skin, name);\r\n            if (box == null) return null;\r\n            box.worldVerticesLength = vertexCount << 1;\r\n            box.vertices = vertices.vertices;\r\n            box.bones = vertices.bones;\r\n            if (nonessential) Color.rgba8888ToColor(box.color, color);\r\n            return box;\r\n        }\r\n        case AttachmentType.Mesh: {\r\n            let path = input.readStringRef();\r\n            let color = input.readInt32();\r\n            let vertexCount = input.readInt(true);\r\n            let uvs = this.readFloatArray(input, vertexCount << 1, 1);\r\n            let triangles = this.readShortArray(input);\r\n            let vertices = this.readVertices(input, vertexCount);\r\n            let hullLength = input.readInt(true);\r\n            let edges = null;\r\n            let width = 0, height = 0;\r\n            if (nonessential) {\r\n                edges = this.readShortArray(input);\r\n                width = input.readFloat();\r\n                height = input.readFloat();\r\n            }\r\n\r\n            if (path == null) path = name;\r\n            let mesh = this.attachmentLoader.newMeshAttachment(skin, name, path);\r\n            if (mesh == null) return null;\r\n            mesh.path = path;\r\n            Color.rgba8888ToColor(mesh.color, color);\r\n            mesh.bones = vertices.bones;\r\n            mesh.vertices = vertices.vertices;\r\n            mesh.worldVerticesLength = vertexCount << 1;\r\n            mesh.triangles = triangles;\r\n            mesh.regionUVs = new Float32Array(uvs);\r\n            // mesh.updateUVs();\r\n            mesh.hullLength = hullLength << 1;\r\n            if (nonessential) {\r\n                mesh.edges = edges;\r\n                mesh.width = width * scale;\r\n                mesh.height = height * scale;\r\n            }\r\n            return mesh;\r\n        }\r\n        case AttachmentType.LinkedMesh: {\r\n            let path = input.readStringRef();\r\n            let color = input.readInt32();\r\n            let skinName = input.readStringRef();\r\n            let parent = input.readStringRef();\r\n            let inheritDeform = input.readBoolean();\r\n            let width = 0, height = 0;\r\n            if (nonessential) {\r\n                width = input.readFloat();\r\n                height = input.readFloat();\r\n            }\r\n\r\n            if (path == null) path = name;\r\n            let mesh = this.attachmentLoader.newMeshAttachment(skin, name, path);\r\n            if (mesh == null) return null;\r\n            mesh.path = path;\r\n            Color.rgba8888ToColor(mesh.color, color);\r\n            if (nonessential) {\r\n                mesh.width = width * scale;\r\n                mesh.height = height * scale;\r\n            }\r\n            this.linkedMeshes.push(new LinkedMesh(mesh, skinName, slotIndex, parent, inheritDeform));\r\n            return mesh;\r\n        }\r\n        case AttachmentType.Path: {\r\n            let closed = input.readBoolean();\r\n            let constantSpeed = input.readBoolean();\r\n            let vertexCount = input.readInt(true);\r\n            let vertices = this.readVertices(input, vertexCount);\r\n            let lengths = Utils.newArray(vertexCount / 3, 0);\r\n            for (let i = 0, n = lengths.length; i < n; i++)\r\n                lengths[i] = input.readFloat() * scale;\r\n            let color = nonessential ? input.readInt32() : 0;\r\n\r\n            let path = this.attachmentLoader.newPathAttachment(skin, name);\r\n            if (path == null) return null;\r\n            path.closed = closed;\r\n            path.constantSpeed = constantSpeed;\r\n            path.worldVerticesLength = vertexCount << 1;\r\n            path.vertices = vertices.vertices;\r\n            path.bones = vertices.bones;\r\n            path.lengths = lengths;\r\n            if (nonessential) Color.rgba8888ToColor(path.color, color);\r\n            return path;\r\n        }\r\n        case AttachmentType.Point: {\r\n            let rotation = input.readFloat();\r\n            let x = input.readFloat();\r\n            let y = input.readFloat();\r\n            let color = nonessential ? input.readInt32() : 0;\r\n\r\n            let point = this.attachmentLoader.newPointAttachment(skin, name);\r\n            if (point == null) return null;\r\n            point.x = x * scale;\r\n            point.y = y * scale;\r\n            point.rotation = rotation;\r\n            if (nonessential) Color.rgba8888ToColor(point.color, color);\r\n            return point;\r\n        }\r\n        case AttachmentType.Clipping: {\r\n            let endSlotIndex = input.readInt(true);\r\n            let vertexCount = input.readInt(true);\r\n            let vertices = this.readVertices(input, vertexCount);\r\n            let color = nonessential ? input.readInt32() : 0;\r\n\r\n            let clip = this.attachmentLoader.newClippingAttachment(skin, name);\r\n            if (clip == null) return null;\r\n            clip.endSlot = skeletonData.slots[endSlotIndex];\r\n            clip.worldVerticesLength = vertexCount << 1;\r\n            clip.vertices = vertices.vertices;\r\n            clip.bones = vertices.bones;\r\n            if (nonessential) Color.rgba8888ToColor(clip.color, color);\r\n            return clip;\r\n        }\r\n        }\r\n        return null;\r\n    }\r\n\r\n    private readVertices (input: BinaryInput, vertexCount: number): Vertices {\r\n        let verticesLength = vertexCount << 1;\r\n        let vertices = new Vertices();\r\n        let scale = this.scale;\r\n        if (!input.readBoolean()) {\r\n            vertices.vertices = this.readFloatArray(input, verticesLength, scale);\r\n            return vertices;\r\n        }\r\n        let weights = new Array<number>();\r\n        let bonesArray = new Array<number>();\r\n        for (let i = 0; i < vertexCount; i++) {\r\n            let boneCount = input.readInt(true);\r\n            bonesArray.push(boneCount);\r\n            for (let ii = 0; ii < boneCount; ii++) {\r\n                bonesArray.push(input.readInt(true));\r\n                weights.push(input.readFloat() * scale);\r\n                weights.push(input.readFloat() * scale);\r\n                weights.push(input.readFloat());\r\n            }\r\n        }\r\n        vertices.vertices = Utils.toFloatArray(weights);\r\n        vertices.bones = bonesArray;\r\n        return vertices;\r\n    }\r\n\r\n    private readFloatArray (input: BinaryInput, n: number, scale: number): number[] {\r\n        let array = new Array<number>(n);\r\n        if (scale == 1) {\r\n            for (let i = 0; i < n; i++)\r\n                array[i] = input.readFloat();\r\n        } else {\r\n            for (let i = 0; i < n; i++)\r\n                array[i] = input.readFloat() * scale;\r\n        }\r\n        return array;\r\n    }\r\n\r\n    private readShortArray (input: BinaryInput): number[] {\r\n        let n = input.readInt(true);\r\n        let array = new Array<number>(n);\r\n        for (let i = 0; i < n; i++)\r\n            array[i] = input.readShort();\r\n        return array;\r\n    }\r\n\r\n    private readAnimation (input: BinaryInput, name: string, skeletonData: SkeletonData): Animation {\r\n        let timelines = new Array<Timeline>();\r\n        let scale = this.scale;\r\n        let duration = 0;\r\n        let tempColor1 = new Color();\r\n        let tempColor2 = new Color();\r\n\r\n        // Slot timelines.\r\n        for (let i = 0, n = input.readInt(true); i < n; i++) {\r\n            let slotIndex = input.readInt(true);\r\n            for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) {\r\n                let timelineType = input.readByte();\r\n                let frameCount = input.readInt(true);\r\n                switch (timelineType) {\r\n                case SkeletonBinary.SLOT_ATTACHMENT: {\r\n                    let timeline = new AttachmentTimeline(frameCount);\r\n                    timeline.slotIndex = slotIndex;\r\n                    for (let frameIndex = 0; frameIndex < frameCount; frameIndex++)\r\n                        timeline.setFrame(frameIndex, input.readFloat(), input.readStringRef());\r\n                    timelines.push(timeline);\r\n                    duration = Math.max(duration, timeline.frames[frameCount - 1]);\r\n                    break;\r\n                }\r\n                case SkeletonBinary.SLOT_COLOR: {\r\n                    let timeline = new ColorTimeline(frameCount);\r\n                    timeline.slotIndex = slotIndex;\r\n                    for (let frameIndex = 0; frameIndex < frameCount; frameIndex++) {\r\n                        let time = input.readFloat();\r\n                        Color.rgba8888ToColor(tempColor1, input.readInt32());\r\n                        timeline.setFrame(frameIndex, time, tempColor1.r, tempColor1.g, tempColor1.b, tempColor1.a);\r\n                        if (frameIndex < frameCount - 1) this.readCurve(input, frameIndex, timeline);\r\n                    }\r\n                    timelines.push(timeline);\r\n                    duration = Math.max(duration, timeline.frames[(frameCount - 1) * ColorTimeline.ENTRIES]);\r\n                    break;\r\n                }\r\n                case SkeletonBinary.SLOT_TWO_COLOR: {\r\n                    let timeline = new TwoColorTimeline(frameCount);\r\n                    timeline.slotIndex = slotIndex;\r\n                    for (let frameIndex = 0; frameIndex < frameCount; frameIndex++) {\r\n                        let time = input.readFloat();\r\n                        Color.rgba8888ToColor(tempColor1, input.readInt32());\r\n                        Color.rgb888ToColor(tempColor2, input.readInt32());\r\n                        timeline.setFrame(frameIndex, time, tempColor1.r, tempColor1.g, tempColor1.b, tempColor1.a, tempColor2.r,\r\n                            tempColor2.g, tempColor2.b);\r\n                        if (frameIndex < frameCount - 1) this.readCurve(input, frameIndex, timeline);\r\n                    }\r\n                    timelines.push(timeline);\r\n                    duration = Math.max(duration, timeline.frames[(frameCount - 1) * TwoColorTimeline.ENTRIES]);\r\n                    break;\r\n                }\r\n                }\r\n            }\r\n        }\r\n\r\n        // Bone timelines.\r\n        for (let i = 0, n = input.readInt(true); i < n; i++) {\r\n            let boneIndex = input.readInt(true);\r\n            for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) {\r\n                let timelineType = input.readByte();\r\n                let frameCount = input.readInt(true);\r\n                switch (timelineType) {\r\n                case SkeletonBinary.BONE_ROTATE: {\r\n                    let timeline = new RotateTimeline(frameCount);\r\n                    timeline.boneIndex = boneIndex;\r\n                    for (let frameIndex = 0; frameIndex < frameCount; frameIndex++) {\r\n                        timeline.setFrame(frameIndex, input.readFloat(), input.readFloat());\r\n                        if (frameIndex < frameCount - 1) this.readCurve(input, frameIndex, timeline);\r\n                    }\r\n                    timelines.push(timeline);\r\n                    duration = Math.max(duration, timeline.frames[(frameCount - 1) * RotateTimeline.ENTRIES]);\r\n                    break;\r\n                }\r\n                case SkeletonBinary.BONE_TRANSLATE:\r\n                case SkeletonBinary.BONE_SCALE:\r\n                case SkeletonBinary.BONE_SHEAR: {\r\n                    let timeline;\r\n                    let timelineScale = 1;\r\n                    if (timelineType == SkeletonBinary.BONE_SCALE)\r\n                        timeline = new ScaleTimeline(frameCount);\r\n                    else if (timelineType == SkeletonBinary.BONE_SHEAR)\r\n                        timeline = new ShearTimeline(frameCount);\r\n                    else {\r\n                        timeline = new TranslateTimeline(frameCount);\r\n                        timelineScale = scale;\r\n                    }\r\n                    timeline.boneIndex = boneIndex;\r\n                    for (let frameIndex = 0; frameIndex < frameCount; frameIndex++) {\r\n                        timeline.setFrame(frameIndex, input.readFloat(), input.readFloat() * timelineScale,\r\n                            input.readFloat() * timelineScale);\r\n                        if (frameIndex < frameCount - 1) this.readCurve(input, frameIndex, timeline);\r\n                    }\r\n                    timelines.push(timeline);\r\n                    duration = Math.max(duration, timeline.frames[(frameCount - 1) * TranslateTimeline.ENTRIES]);\r\n                    break;\r\n                }\r\n                }\r\n            }\r\n        }\r\n\r\n        // IK constraint timelines.\r\n        for (let i = 0, n = input.readInt(true); i < n; i++) {\r\n            let index = input.readInt(true);\r\n            let frameCount = input.readInt(true);\r\n            let timeline = new IkConstraintTimeline(frameCount);\r\n            timeline.ikConstraintIndex = index;\r\n            for (let frameIndex = 0; frameIndex < frameCount; frameIndex++) {\r\n                timeline.setFrame(frameIndex, input.readFloat(), input.readFloat(), input.readFloat() * scale, input.readByte(), input.readBoolean(),\r\n                    input.readBoolean());\r\n                if (frameIndex < frameCount - 1) this.readCurve(input, frameIndex, timeline);\r\n            }\r\n            timelines.push(timeline);\r\n            duration = Math.max(duration, timeline.frames[(frameCount - 1) * IkConstraintTimeline.ENTRIES]);\r\n        }\r\n\r\n        // Transform constraint timelines.\r\n        for (let i = 0, n = input.readInt(true); i < n; i++) {\r\n            let index = input.readInt(true);\r\n            let frameCount = input.readInt(true);\r\n            let timeline = new TransformConstraintTimeline(frameCount);\r\n            timeline.transformConstraintIndex = index;\r\n            for (let frameIndex = 0; frameIndex < frameCount; frameIndex++) {\r\n                timeline.setFrame(frameIndex, input.readFloat(), input.readFloat(), input.readFloat(), input.readFloat(),\r\n                    input.readFloat());\r\n                if (frameIndex < frameCount - 1) this.readCurve(input, frameIndex, timeline);\r\n            }\r\n            timelines.push(timeline);\r\n            duration = Math.max(duration, timeline.frames[(frameCount - 1) * TransformConstraintTimeline.ENTRIES]);\r\n        }\r\n\r\n        // Path constraint timelines.\r\n        for (let i = 0, n = input.readInt(true); i < n; i++) {\r\n            let index = input.readInt(true);\r\n            let data = skeletonData.pathConstraints[index];\r\n            for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) {\r\n                let timelineType = input.readByte();\r\n                let frameCount = input.readInt(true);\r\n                switch (timelineType) {\r\n                case SkeletonBinary.PATH_POSITION:\r\n                case SkeletonBinary.PATH_SPACING: {\r\n                    let timeline;\r\n                    let timelineScale = 1;\r\n                    if (timelineType == SkeletonBinary.PATH_SPACING) {\r\n                        timeline = new PathConstraintSpacingTimeline(frameCount);\r\n                        if (data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed) timelineScale = scale;\r\n                    } else {\r\n                        timeline = new PathConstraintPositionTimeline(frameCount);\r\n                        if (data.positionMode == PositionMode.Fixed) timelineScale = scale;\r\n                    }\r\n                    timeline.pathConstraintIndex = index;\r\n                    for (let frameIndex = 0; frameIndex < frameCount; frameIndex++) {\r\n                        timeline.setFrame(frameIndex, input.readFloat(), input.readFloat() * timelineScale);\r\n                        if (frameIndex < frameCount - 1) this.readCurve(input, frameIndex, timeline);\r\n                    }\r\n                    timelines.push(timeline);\r\n                    duration = Math.max(duration, timeline.frames[(frameCount - 1) * PathConstraintPositionTimeline.ENTRIES]);\r\n                    break;\r\n                }\r\n                case SkeletonBinary.PATH_MIX: {\r\n                    let timeline = new PathConstraintMixTimeline(frameCount);\r\n                    timeline.pathConstraintIndex = index;\r\n                    for (let frameIndex = 0; frameIndex < frameCount; frameIndex++) {\r\n                        timeline.setFrame(frameIndex, input.readFloat(), input.readFloat(), input.readFloat());\r\n                        if (frameIndex < frameCount - 1) this.readCurve(input, frameIndex, timeline);\r\n                    }\r\n                    timelines.push(timeline);\r\n                    duration = Math.max(duration, timeline.frames[(frameCount - 1) * PathConstraintMixTimeline.ENTRIES]);\r\n                    break;\r\n                }\r\n                }\r\n            }\r\n        }\r\n\r\n        // Deform timelines.\r\n        for (let i = 0, n = input.readInt(true); i < n; i++) {\r\n            let skin = skeletonData.skins[input.readInt(true)];\r\n            for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) {\r\n                let slotIndex = input.readInt(true);\r\n                for (let iii = 0, nnn = input.readInt(true); iii < nnn; iii++) {\r\n                    let attachment = skin.getAttachment(slotIndex, input.readStringRef()) as VertexAttachment;\r\n                    let weighted = attachment.bones != null;\r\n                    let vertices = attachment.vertices;\r\n                    let deformLength = weighted ? vertices.length / 3 * 2 : vertices.length;\r\n\r\n                    let frameCount = input.readInt(true);\r\n                    let timeline = new DeformTimeline(frameCount);\r\n                    timeline.slotIndex = slotIndex;\r\n                    timeline.attachment = attachment;\r\n\r\n                    for (let frameIndex = 0; frameIndex < frameCount; frameIndex++) {\r\n                        let time = input.readFloat();\r\n                        let deform;\r\n                        let end = input.readInt(true);\r\n                        if (end == 0)\r\n                            deform = weighted ? Utils.newFloatArray(deformLength) : vertices;\r\n                        else {\r\n                            deform = Utils.newFloatArray(deformLength);\r\n                            let start = input.readInt(true);\r\n                            end += start;\r\n                            if (scale == 1) {\r\n                                for (let v = start; v < end; v++)\r\n                                    deform[v] = input.readFloat();\r\n                            } else {\r\n                                for (let v = start; v < end; v++)\r\n                                    deform[v] = input.readFloat() * scale;\r\n                            }\r\n                            if (!weighted) {\r\n                                for (let v = 0, vn = deform.length; v < vn; v++)\r\n                                    deform[v] += vertices[v];\r\n                            }\r\n                        }\r\n\r\n                        timeline.setFrame(frameIndex, time, deform);\r\n                        if (frameIndex < frameCount - 1) this.readCurve(input, frameIndex, timeline);\r\n                    }\r\n                    timelines.push(timeline);\r\n                    duration = Math.max(duration, timeline.frames[frameCount - 1]);\r\n                }\r\n            }\r\n        }\r\n\r\n        // Draw order timeline.\r\n        let drawOrderCount = input.readInt(true);\r\n        if (drawOrderCount > 0) {\r\n            let timeline = new DrawOrderTimeline(drawOrderCount);\r\n            let slotCount = skeletonData.slots.length;\r\n            for (let i = 0; i < drawOrderCount; i++) {\r\n                let time = input.readFloat();\r\n                let offsetCount = input.readInt(true);\r\n                let drawOrder = Utils.newArray(slotCount, 0);\r\n                for (let ii = slotCount - 1; ii >= 0; ii--)\r\n                    drawOrder[ii] = -1;\r\n                let unchanged = Utils.newArray(slotCount - offsetCount, 0);\r\n                let originalIndex = 0, unchangedIndex = 0;\r\n                for (let ii = 0; ii < offsetCount; ii++) {\r\n                    let slotIndex = input.readInt(true);\r\n                    // Collect unchanged items.\r\n                    while (originalIndex != slotIndex)\r\n                        unchanged[unchangedIndex++] = originalIndex++;\r\n                    // Set changed items.\r\n                    drawOrder[originalIndex + input.readInt(true)] = originalIndex++;\r\n                }\r\n                // Collect remaining unchanged items.\r\n                while (originalIndex < slotCount)\r\n                    unchanged[unchangedIndex++] = originalIndex++;\r\n                // Fill in unchanged items.\r\n                for (let ii = slotCount - 1; ii >= 0; ii--)\r\n                    if (drawOrder[ii] == -1) drawOrder[ii] = unchanged[--unchangedIndex];\r\n                timeline.setFrame(i, time, drawOrder);\r\n            }\r\n            timelines.push(timeline);\r\n            duration = Math.max(duration, timeline.frames[drawOrderCount - 1]);\r\n        }\r\n\r\n        // Event timeline.\r\n        let eventCount = input.readInt(true);\r\n        if (eventCount > 0) {\r\n            let timeline = new EventTimeline(eventCount);\r\n            for (let i = 0; i < eventCount; i++) {\r\n                let time = input.readFloat();\r\n                let eventData = skeletonData.events[input.readInt(true)];\r\n                let event = new Event(time, eventData);\r\n                event.intValue = input.readInt(false);\r\n                event.floatValue = input.readFloat();\r\n                event.stringValue = input.readBoolean() ? input.readString() : eventData.stringValue;\r\n                if (event.data.audioPath != null) {\r\n                    event.volume = input.readFloat();\r\n                    event.balance = input.readFloat();\r\n                }\r\n                timeline.setFrame(i, event);\r\n            }\r\n            timelines.push(timeline);\r\n            duration = Math.max(duration, timeline.frames[eventCount - 1]);\r\n        }\r\n\r\n        return new Animation(name, timelines, duration);\r\n    }\r\n\r\n    private readCurve (input: BinaryInput, frameIndex: number, timeline: CurveTimeline) {\r\n        switch (input.readByte()) {\r\n        case SkeletonBinary.CURVE_STEPPED:\r\n            timeline.setStepped(frameIndex);\r\n            break;\r\n        case SkeletonBinary.CURVE_BEZIER:\r\n            this.setCurve(timeline, frameIndex, input.readFloat(), input.readFloat(), input.readFloat(), input.readFloat());\r\n            break;\r\n        }\r\n    }\r\n\r\n    setCurve (timeline: CurveTimeline, frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number) {\r\n        timeline.setCurve(frameIndex, cx1, cy1, cx2, cy2);\r\n    }\r\n}\r\n\r\nclass LinkedMesh {\r\n    parent: string; skin: string;\r\n    slotIndex: number;\r\n    mesh: MeshAttachment;\r\n    inheritDeform: boolean;\r\n\r\n    constructor (mesh: MeshAttachment, skin: string, slotIndex: number, parent: string, inheritDeform: boolean) {\r\n        this.mesh = mesh;\r\n        this.skin = skin;\r\n        this.slotIndex = slotIndex;\r\n        this.parent = parent;\r\n        this.inheritDeform = inheritDeform;\r\n    }\r\n}\r\n\r\nclass Vertices {\r\n    constructor(public bones: Array<number> = null, public vertices: Array<number> | Float32Array = null) { }\r\n}\r\n","import {BoundingBoxAttachment} from \"./attachments\";\r\nimport {Pool, Utils} from \"@pixi-spine/base\";\r\nimport type {Skeleton} from \"./Skeleton\";\r\n\r\n/**\r\n * @public\r\n */\r\nexport class SkeletonBounds {\r\n    minX = 0; minY = 0; maxX = 0; maxY = 0;\r\n    boundingBoxes = new Array<BoundingBoxAttachment>();\r\n    polygons = new Array<ArrayLike<number>>();\r\n    private polygonPool = new Pool<ArrayLike<number>>(() => {\r\n        return Utils.newFloatArray(16);\r\n    });\r\n\r\n    update (skeleton: Skeleton, updateAabb: boolean) {\r\n        if (skeleton == null) throw new Error(\"skeleton cannot be null.\");\r\n        let boundingBoxes = this.boundingBoxes;\r\n        let polygons = this.polygons;\r\n        let polygonPool = this.polygonPool;\r\n        let slots = skeleton.slots;\r\n        let slotCount = slots.length;\r\n\r\n        boundingBoxes.length = 0;\r\n        polygonPool.freeAll(polygons);\r\n        polygons.length = 0;\r\n\r\n        for (let i = 0; i < slotCount; i++) {\r\n            let slot = slots[i];\r\n            if (!slot.bone.active) continue;\r\n            let attachment = slot.getAttachment();\r\n            if (attachment instanceof BoundingBoxAttachment) {\r\n                let boundingBox = attachment as BoundingBoxAttachment;\r\n                boundingBoxes.push(boundingBox);\r\n\r\n                let polygon = polygonPool.obtain();\r\n                if (polygon.length != boundingBox.worldVerticesLength) {\r\n                    polygon = Utils.newFloatArray(boundingBox.worldVerticesLength);\r\n                }\r\n                polygons.push(polygon);\r\n                boundingBox.computeWorldVertices(slot, 0, boundingBox.worldVerticesLength, polygon, 0, 2);\r\n            }\r\n        }\r\n\r\n        if (updateAabb) {\r\n            this.aabbCompute();\r\n        } else {\r\n            this.minX = Number.POSITIVE_INFINITY;\r\n            this.minY = Number.POSITIVE_INFINITY;\r\n            this.maxX = Number.NEGATIVE_INFINITY;\r\n            this.maxY = Number.NEGATIVE_INFINITY;\r\n        }\r\n    }\r\n\r\n    aabbCompute () {\r\n        let minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;\r\n        let polygons = this.polygons;\r\n        for (let i = 0, n = polygons.length; i < n; i++) {\r\n            let polygon = polygons[i];\r\n            let vertices = polygon;\r\n            for (let ii = 0, nn = polygon.length; ii < nn; ii += 2) {\r\n                let x = vertices[ii];\r\n                let y = vertices[ii + 1];\r\n                minX = Math.min(minX, x);\r\n                minY = Math.min(minY, y);\r\n                maxX = Math.max(maxX, x);\r\n                maxY = Math.max(maxY, y);\r\n            }\r\n        }\r\n        this.minX = minX;\r\n        this.minY = minY;\r\n        this.maxX = maxX;\r\n        this.maxY = maxY;\r\n    }\r\n\r\n    /** Returns true if the axis aligned bounding box contains the point. */\r\n    aabbContainsPoint (x: number, y: number) {\r\n        return x >= this.minX && x <= this.maxX && y >= this.minY && y <= this.maxY;\r\n    }\r\n\r\n    /** Returns true if the axis aligned bounding box intersects the line segment. */\r\n    aabbIntersectsSegment (x1: number, y1: number, x2: number, y2: number) {\r\n        let minX = this.minX;\r\n        let minY = this.minY;\r\n        let maxX = this.maxX;\r\n        let maxY = this.maxY;\r\n        if ((x1 <= minX && x2 <= minX) || (y1 <= minY && y2 <= minY) || (x1 >= maxX && x2 >= maxX) || (y1 >= maxY && y2 >= maxY))\r\n            return false;\r\n        let m = (y2 - y1) / (x2 - x1);\r\n        let y = m * (minX - x1) + y1;\r\n        if (y > minY && y < maxY) return true;\r\n        y = m * (maxX - x1) + y1;\r\n        if (y > minY && y < maxY) return true;\r\n        let x = (minY - y1) / m + x1;\r\n        if (x > minX && x < maxX) return true;\r\n        x = (maxY - y1) / m + x1;\r\n        if (x > minX && x < maxX) return true;\r\n        return false;\r\n    }\r\n\r\n    /** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */\r\n    aabbIntersectsSkeleton (bounds: SkeletonBounds) {\r\n        return this.minX < bounds.maxX && this.maxX > bounds.minX && this.minY < bounds.maxY && this.maxY > bounds.minY;\r\n    }\r\n\r\n    /** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more\r\n     * efficient to only call this method if {@link #aabbContainsPoint(float, float)} returns true. */\r\n    containsPoint (x: number, y: number): BoundingBoxAttachment {\r\n        let polygons = this.polygons;\r\n        for (let i = 0, n = polygons.length; i < n; i++)\r\n            if (this.containsPointPolygon(polygons[i], x, y)) return this.boundingBoxes[i];\r\n        return null;\r\n    }\r\n\r\n    /** Returns true if the polygon contains the point. */\r\n    containsPointPolygon (polygon: ArrayLike<number>, x: number, y: number) {\r\n        let vertices = polygon;\r\n        let nn = polygon.length;\r\n\r\n        let prevIndex = nn - 2;\r\n        let inside = false;\r\n        for (let ii = 0; ii < nn; ii += 2) {\r\n            let vertexY = vertices[ii + 1];\r\n            let prevY = vertices[prevIndex + 1];\r\n            if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {\r\n                let vertexX = vertices[ii];\r\n                if (vertexX + (y - vertexY) / (prevY - vertexY) * (vertices[prevIndex] - vertexX) < x) inside = !inside;\r\n            }\r\n            prevIndex = ii;\r\n        }\r\n        return inside;\r\n    }\r\n\r\n    /** Returns the first bounding box attachment that contains any part of the line segment, or null. When doing many checks, it\r\n     * is usually more efficient to only call this method if {@link #aabbIntersectsSegment(float, float, float, float)} returns\r\n     * true. */\r\n    intersectsSegment (x1: number, y1: number, x2: number, y2: number) {\r\n        let polygons = this.polygons;\r\n        for (let i = 0, n = polygons.length; i < n; i++)\r\n            if (this.intersectsSegmentPolygon(polygons[i], x1, y1, x2, y2)) return this.boundingBoxes[i];\r\n        return null;\r\n    }\r\n\r\n    /** Returns true if the polygon contains any part of the line segment. */\r\n    intersectsSegmentPolygon (polygon: ArrayLike<number>, x1: number, y1: number, x2: number, y2: number) {\r\n        let vertices = polygon;\r\n        let nn = polygon.length;\r\n\r\n        let width12 = x1 - x2, height12 = y1 - y2;\r\n        let det1 = x1 * y2 - y1 * x2;\r\n        let x3 = vertices[nn - 2], y3 = vertices[nn - 1];\r\n        for (let ii = 0; ii < nn; ii += 2) {\r\n            let x4 = vertices[ii], y4 = vertices[ii + 1];\r\n            let det2 = x3 * y4 - y3 * x4;\r\n            let width34 = x3 - x4, height34 = y3 - y4;\r\n            let det3 = width12 * height34 - height12 * width34;\r\n            let x = (det1 * width34 - width12 * det2) / det3;\r\n            if (((x >= x3 && x <= x4) || (x >= x4 && x <= x3)) && ((x >= x1 && x <= x2) || (x >= x2 && x <= x1))) {\r\n                let y = (det1 * height34 - height12 * det2) / det3;\r\n                if (((y >= y3 && y <= y4) || (y >= y4 && y <= y3)) && ((y >= y1 && y <= y2) || (y >= y2 && y <= y1))) return true;\r\n            }\r\n            x3 = x4;\r\n            y3 = y4;\r\n        }\r\n        return false;\r\n    }\r\n\r\n    /** Returns the polygon for the specified bounding box, or null. */\r\n    getPolygon (boundingBox: BoundingBoxAttachment) {\r\n        if (boundingBox == null) throw new Error(\"boundingBox cannot be null.\");\r\n        let index = this.boundingBoxes.indexOf(boundingBox);\r\n        return index == -1 ? null : this.polygons[index];\r\n    }\r\n\r\n    getWidth () {\r\n        return this.maxX - this.minX;\r\n    }\r\n\r\n    getHeight () {\r\n        return this.maxY - this.minY;\r\n    }\r\n}\r\n","import type {Attachment, AttachmentLoader, MeshAttachment, VertexAttachment} from './attachments';\r\nimport {Animation} from './Animation';\r\nimport {Event} from './Event';\r\nimport {SkeletonData} from './SkeletonData';\r\nimport {SlotData} from './SlotData';\r\nimport {BoneData} from './BoneData';\r\nimport {IkConstraintData} from './IkConstraintData';\r\nimport {TransformConstraintData} from './TransformConstraintData';\r\nimport {PathConstraintData, SpacingMode} from './PathConstraintData';\r\nimport {Skin} from './Skin';\r\nimport {EventData} from './EventData';\r\nimport {\r\n    AttachmentTimeline,\r\n    ColorTimeline, CurveTimeline, DeformTimeline, DrawOrderTimeline, EventTimeline,\r\n    IkConstraintTimeline,\r\n    PathConstraintMixTimeline,\r\n    PathConstraintPositionTimeline,\r\n    PathConstraintSpacingTimeline,\r\n    RotateTimeline,\r\n    ScaleTimeline,\r\n    ShearTimeline,\r\n    Timeline,\r\n    TransformConstraintTimeline,\r\n    TranslateTimeline,\r\n    TwoColorTimeline\r\n} from './Animation';\r\nimport {ArrayLike, Color, PositionMode, RotateMode, TransformMode, Utils, settings} from '@pixi-spine/base';\r\nimport {BLEND_MODES} from '@pixi/constants';\r\n\r\n/**\r\n * @public\r\n */\r\nexport class SkeletonJson {\r\n    attachmentLoader: AttachmentLoader;\r\n    scale = 1;\r\n    private linkedMeshes = new Array<LinkedMesh>();\r\n\r\n    constructor (attachmentLoader: AttachmentLoader) {\r\n        this.attachmentLoader = attachmentLoader;\r\n    }\r\n\r\n    readSkeletonData (json: string | any): SkeletonData {\r\n        let scale = this.scale;\r\n        let skeletonData = new SkeletonData();\r\n        let root = typeof(json) === \"string\" ? JSON.parse(json) : json;\r\n\r\n        // Skeleton\r\n        let skeletonMap = root.skeleton;\r\n        if (skeletonMap != null) {\r\n            skeletonData.hash = skeletonMap.hash;\r\n            skeletonData.version = skeletonMap.spine;\r\n            if (skeletonData.version.substr(0, 3) !== '3.8') {\r\n                let error = `Spine 3.8 loader cant load version ${skeletonMap.spine}. Please configure your pixi-spine bundle`;\r\n                console.error(error);\r\n            }\r\n            if (skeletonData.version === '3.8.75')\r\n            {\r\n                let error = `Unsupported skeleton data, 3.8.75 is deprecated, please export with a newer version of Spine.`;\r\n                console.error(error);\r\n            }\r\n            skeletonData.x = skeletonMap.x;\r\n            skeletonData.y = skeletonMap.y;\r\n            skeletonData.width = skeletonMap.width;\r\n            skeletonData.height = skeletonMap.height;\r\n            skeletonData.fps = skeletonMap.fps;\r\n            skeletonData.imagesPath = skeletonMap.images;\r\n        }\r\n\r\n        // Bones\r\n        if (root.bones) {\r\n            for (let i = 0; i < root.bones.length; i++) {\r\n                let boneMap = root.bones[i];\r\n\r\n                let parent: BoneData = null;\r\n                let parentName: string = this.getValue(boneMap, \"parent\", null);\r\n                if (parentName != null) {\r\n                    parent = skeletonData.findBone(parentName);\r\n                    if (parent == null) throw new Error(\"Parent bone not found: \" + parentName);\r\n                }\r\n                let data = new BoneData(skeletonData.bones.length, boneMap.name, parent);\r\n                data.length = this.getValue(boneMap, \"length\", 0) * scale;\r\n                data.x = this.getValue(boneMap, \"x\", 0) * scale;\r\n                data.y = this.getValue(boneMap, \"y\", 0) * scale;\r\n                data.rotation = this.getValue(boneMap, \"rotation\", 0);\r\n                data.scaleX = this.getValue(boneMap, \"scaleX\", 1);\r\n                data.scaleY = this.getValue(boneMap, \"scaleY\", 1);\r\n                data.shearX = this.getValue(boneMap, \"shearX\", 0);\r\n                data.shearY = this.getValue(boneMap, \"shearY\", 0);\r\n                data.transformMode = SkeletonJson.transformModeFromString(this.getValue(boneMap, \"transform\", \"normal\"));\r\n                data.skinRequired = this.getValue(boneMap, \"skin\", false);\r\n\r\n                skeletonData.bones.push(data);\r\n            }\r\n        }\r\n\r\n        // Slots.\r\n        if (root.slots) {\r\n            for (let i = 0; i < root.slots.length; i++) {\r\n                let slotMap = root.slots[i];\r\n                let slotName: string = slotMap.name;\r\n                let boneName: string = slotMap.bone;\r\n                let boneData = skeletonData.findBone(boneName);\r\n                if (boneData == null) throw new Error(\"Slot bone not found: \" + boneName);\r\n                let data = new SlotData(skeletonData.slots.length, slotName, boneData);\r\n\r\n                let color: string = this.getValue(slotMap, \"color\", null);\r\n                if (color != null) data.color.setFromString(color);\r\n\r\n                let dark: string = this.getValue(slotMap, \"dark\", null);\r\n                if (dark != null) {\r\n                    data.darkColor = new Color(1, 1, 1, 1);\r\n                    data.darkColor.setFromString(dark);\r\n                }\r\n\r\n                data.attachmentName = this.getValue(slotMap, \"attachment\", null);\r\n                data.blendMode = SkeletonJson.blendModeFromString(this.getValue(slotMap, \"blend\", \"normal\"));\r\n                skeletonData.slots.push(data);\r\n            }\r\n        }\r\n\r\n        // IK constraints\r\n        if (root.ik) {\r\n            for (let i = 0; i < root.ik.length; i++) {\r\n                let constraintMap = root.ik[i];\r\n                let data = new IkConstraintData(constraintMap.name);\r\n                data.order = this.getValue(constraintMap, \"order\", 0);\r\n                data.skinRequired = this.getValue(constraintMap, \"skin\", false);\r\n\r\n                for (let j = 0; j < constraintMap.bones.length; j++) {\r\n                    let boneName = constraintMap.bones[j];\r\n                    let bone = skeletonData.findBone(boneName);\r\n                    if (bone == null) throw new Error(\"IK bone not found: \" + boneName);\r\n                    data.bones.push(bone);\r\n                }\r\n\r\n                let targetName: string = constraintMap.target;\r\n                data.target = skeletonData.findBone(targetName);\r\n                if (data.target == null) throw new Error(\"IK target bone not found: \" + targetName);\r\n\r\n                data.mix = this.getValue(constraintMap, \"mix\", 1);\r\n                data.softness = this.getValue(constraintMap, \"softness\", 0) * scale;\r\n                data.bendDirection = this.getValue(constraintMap, \"bendPositive\", true) ? 1 : -1;\r\n                data.compress = this.getValue(constraintMap, \"compress\", false);\r\n                data.stretch = this.getValue(constraintMap, \"stretch\", false);\r\n                data.uniform = this.getValue(constraintMap, \"uniform\", false);\r\n\r\n                skeletonData.ikConstraints.push(data);\r\n            }\r\n        }\r\n\r\n        // Transform constraints.\r\n        if (root.transform) {\r\n            for (let i = 0; i < root.transform.length; i++) {\r\n                let constraintMap = root.transform[i];\r\n                let data = new TransformConstraintData(constraintMap.name);\r\n                data.order = this.getValue(constraintMap, \"order\", 0);\r\n                data.skinRequired = this.getValue(constraintMap, \"skin\", false);\r\n\r\n                for (let j = 0; j < constraintMap.bones.length; j++) {\r\n                    let boneName = constraintMap.bones[j];\r\n                    let bone = skeletonData.findBone(boneName);\r\n                    if (bone == null) throw new Error(\"Transform constraint bone not found: \" + boneName);\r\n                    data.bones.push(bone);\r\n                }\r\n\r\n                let targetName: string = constraintMap.target;\r\n                data.target = skeletonData.findBone(targetName);\r\n                if (data.target == null) throw new Error(\"Transform constraint target bone not found: \" + targetName);\r\n\r\n                data.local = this.getValue(constraintMap, \"local\", false);\r\n                data.relative = this.getValue(constraintMap, \"relative\", false);\r\n                data.offsetRotation = this.getValue(constraintMap, \"rotation\", 0);\r\n                data.offsetX = this.getValue(constraintMap, \"x\", 0) * scale;\r\n                data.offsetY = this.getValue(constraintMap, \"y\", 0) * scale;\r\n                data.offsetScaleX = this.getValue(constraintMap, \"scaleX\", 0);\r\n                data.offsetScaleY = this.getValue(constraintMap, \"scaleY\", 0);\r\n                data.offsetShearY = this.getValue(constraintMap, \"shearY\", 0);\r\n\r\n                data.rotateMix = this.getValue(constraintMap, \"rotateMix\", 1);\r\n                data.translateMix = this.getValue(constraintMap, \"translateMix\", 1);\r\n                data.scaleMix = this.getValue(constraintMap, \"scaleMix\", 1);\r\n                data.shearMix = this.getValue(constraintMap, \"shearMix\", 1);\r\n\r\n                skeletonData.transformConstraints.push(data);\r\n            }\r\n        }\r\n\r\n        // Path constraints.\r\n        if (root.path) {\r\n            for (let i = 0; i < root.path.length; i++) {\r\n                let constraintMap = root.path[i];\r\n                let data = new PathConstraintData(constraintMap.name);\r\n                data.order = this.getValue(constraintMap, \"order\", 0);\r\n                data.skinRequired = this.getValue(constraintMap, \"skin\", false);\r\n\r\n                for (let j = 0; j < constraintMap.bones.length; j++) {\r\n                    let boneName = constraintMap.bones[j];\r\n                    let bone = skeletonData.findBone(boneName);\r\n                    if (bone == null) throw new Error(\"Transform constraint bone not found: \" + boneName);\r\n                    data.bones.push(bone);\r\n                }\r\n\r\n                let targetName: string = constraintMap.target;\r\n                data.target = skeletonData.findSlot(targetName);\r\n                if (data.target == null) throw new Error(\"Path target slot not found: \" + targetName);\r\n\r\n                data.positionMode = SkeletonJson.positionModeFromString(this.getValue(constraintMap, \"positionMode\", \"percent\"));\r\n                data.spacingMode = SkeletonJson.spacingModeFromString(this.getValue(constraintMap, \"spacingMode\", \"length\"));\r\n                data.rotateMode = SkeletonJson.rotateModeFromString(this.getValue(constraintMap, \"rotateMode\", \"tangent\"));\r\n                data.offsetRotation = this.getValue(constraintMap, \"rotation\", 0);\r\n                data.position = this.getValue(constraintMap, \"position\", 0);\r\n                if (data.positionMode == PositionMode.Fixed) data.position *= scale;\r\n                data.spacing = this.getValue(constraintMap, \"spacing\", 0);\r\n                if (data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed) data.spacing *= scale;\r\n                data.rotateMix = this.getValue(constraintMap, \"rotateMix\", 1);\r\n                data.translateMix = this.getValue(constraintMap, \"translateMix\", 1);\r\n\r\n                skeletonData.pathConstraints.push(data);\r\n            }\r\n        }\r\n\r\n        // Skins.\r\n        if (root.skins) {\r\n            for (let i = 0; i < root.skins.length; i++) {\r\n                let skinMap = root.skins[i]\r\n                let skin = new Skin(skinMap.name);\r\n\r\n                if (skinMap.bones) {\r\n                    for (let ii = 0; ii < skinMap.bones.length; ii++) {\r\n                        let bone = skeletonData.findBone(skinMap.bones[ii]);\r\n                        if (bone == null) throw new Error(\"Skin bone not found: \" + skinMap.bones[i]);\r\n                        skin.bones.push(bone);\r\n                    }\r\n                }\r\n\r\n                if (skinMap.ik) {\r\n                    for (let ii = 0; ii < skinMap.ik.length; ii++) {\r\n                        let constraint = skeletonData.findIkConstraint(skinMap.ik[ii]);\r\n                        if (constraint == null) throw new Error(\"Skin IK constraint not found: \" + skinMap.ik[i]);\r\n                        skin.constraints.push(constraint);\r\n                    }\r\n                }\r\n\r\n                if (skinMap.transform) {\r\n                    for (let ii = 0; ii < skinMap.transform.length; ii++) {\r\n                        let constraint = skeletonData.findTransformConstraint(skinMap.transform[ii]);\r\n                        if (constraint == null) throw new Error(\"Skin transform constraint not found: \" + skinMap.transform[i]);\r\n                        skin.constraints.push(constraint);\r\n                    }\r\n                }\r\n\r\n                if (skinMap.path) {\r\n                    for (let ii = 0; ii < skinMap.path.length; ii++) {\r\n                        let constraint = skeletonData.findPathConstraint(skinMap.path[ii]);\r\n                        if (constraint == null) throw new Error(\"Skin path constraint not found: \" + skinMap.path[i]);\r\n                        skin.constraints.push(constraint);\r\n                    }\r\n                }\r\n\r\n                for (let slotName in skinMap.attachments) {\r\n                    let slot = skeletonData.findSlot(slotName);\r\n                    if (slot == null) throw new Error(\"Slot not found: \" + slotName);\r\n                    let slotMap = skinMap.attachments[slotName];\r\n                    for (let entryName in slotMap) {\r\n                        let attachment = this.readAttachment(slotMap[entryName], skin, slot.index, entryName, skeletonData);\r\n                        if (attachment != null) skin.setAttachment(slot.index, entryName, attachment);\r\n                    }\r\n                }\r\n                skeletonData.skins.push(skin);\r\n                if (skin.name == \"default\") skeletonData.defaultSkin = skin;\r\n            }\r\n        }\r\n\r\n        // Linked meshes.\r\n        for (let i = 0, n = this.linkedMeshes.length; i < n; i++) {\r\n            let linkedMesh = this.linkedMeshes[i];\r\n            let skin = linkedMesh.skin == null ? skeletonData.defaultSkin : skeletonData.findSkin(linkedMesh.skin);\r\n            if (skin == null) throw new Error(\"Skin not found: \" + linkedMesh.skin);\r\n            let parent = skin.getAttachment(linkedMesh.slotIndex, linkedMesh.parent);\r\n            if (parent == null) throw new Error(\"Parent mesh not found: \" + linkedMesh.parent);\r\n            linkedMesh.mesh.deformAttachment = linkedMesh.inheritDeform ? <VertexAttachment>parent : <VertexAttachment>linkedMesh.mesh;\r\n            linkedMesh.mesh.setParentMesh(<MeshAttachment> parent);\r\n            // linkedMesh.mesh.updateUVs();\r\n        }\r\n        this.linkedMeshes.length = 0;\r\n\r\n        // Events.\r\n        if (root.events) {\r\n            for (let eventName in root.events) {\r\n                let eventMap = root.events[eventName];\r\n                let data = new EventData(eventName);\r\n                data.intValue = this.getValue(eventMap, \"int\", 0);\r\n                data.floatValue = this.getValue(eventMap, \"float\", 0);\r\n                data.stringValue = this.getValue(eventMap, \"string\", \"\");\r\n                data.audioPath = this.getValue(eventMap, \"audio\", null);\r\n                if (data.audioPath != null) {\r\n                    data.volume = this.getValue(eventMap, \"volume\", 1);\r\n                    data.balance = this.getValue(eventMap, \"balance\", 0);\r\n                }\r\n                skeletonData.events.push(data);\r\n            }\r\n        }\r\n\r\n        // Animations.\r\n        if (root.animations) {\r\n            for (let animationName in root.animations) {\r\n                let animationMap = root.animations[animationName];\r\n                this.readAnimation(animationMap, animationName, skeletonData);\r\n            }\r\n        }\r\n\r\n        return skeletonData;\r\n    }\r\n\r\n    readAttachment (map: any, skin: Skin, slotIndex: number, name: string, skeletonData: SkeletonData): Attachment {\r\n        let scale = this.scale;\r\n        name = this.getValue(map, \"name\", name);\r\n\r\n        let type = this.getValue(map, \"type\", \"region\");\r\n\r\n        switch (type) {\r\n            case \"region\": {\r\n                let path = this.getValue(map, \"path\", name);\r\n                let region = this.attachmentLoader.newRegionAttachment(skin, name, path);\r\n                if (region == null) return null;\r\n                region.path = path;\r\n                region.x = this.getValue(map, \"x\", 0) * scale;\r\n                region.y = this.getValue(map, \"y\", 0) * scale;\r\n                region.scaleX = this.getValue(map, \"scaleX\", 1);\r\n                region.scaleY = this.getValue(map, \"scaleY\", 1);\r\n                region.rotation = this.getValue(map, \"rotation\", 0);\r\n                region.width = map.width * scale;\r\n                region.height = map.height * scale;\r\n\r\n                let color: string = this.getValue(map, \"color\", null);\r\n                if (color != null) region.color.setFromString(color);\r\n\r\n                // region.updateOffset();\r\n                return region;\r\n            }\r\n            case \"boundingbox\": {\r\n                let box = this.attachmentLoader.newBoundingBoxAttachment(skin, name);\r\n                if (box == null) return null;\r\n                this.readVertices(map, box, map.vertexCount << 1);\r\n                let color: string = this.getValue(map, \"color\", null);\r\n                if (color != null) box.color.setFromString(color);\r\n                return box;\r\n            }\r\n            case \"mesh\":\r\n            case \"linkedmesh\": {\r\n                let path = this.getValue(map, \"path\", name);\r\n                let mesh = this.attachmentLoader.newMeshAttachment(skin, name, path);\r\n                if (mesh == null) return null;\r\n                mesh.path = path;\r\n\r\n                let color = this.getValue(map, \"color\", null);\r\n                if (color != null) mesh.color.setFromString(color);\r\n\r\n                mesh.width = this.getValue(map, \"width\", 0) * scale;\r\n                mesh.height = this.getValue(map, \"height\", 0) * scale;\r\n\r\n                let parent: string = this.getValue(map, \"parent\", null);\r\n                if (parent != null) {\r\n                    this.linkedMeshes.push(new LinkedMesh(mesh, <string> this.getValue(map, \"skin\", null), slotIndex, parent, this.getValue(map, \"deform\", true)));\r\n                    return mesh;\r\n                }\r\n\r\n                let uvs: Array<number> = map.uvs;\r\n                this.readVertices(map, mesh, uvs.length);\r\n                mesh.triangles = map.triangles;\r\n                mesh.regionUVs = new Float32Array(uvs);\r\n                // mesh.updateUVs();\r\n\r\n                mesh.edges = this.getValue(map, \"edges\", null);\r\n                mesh.hullLength = this.getValue(map, \"hull\", 0) * 2;\r\n                return mesh;\r\n            }\r\n            case \"path\": {\r\n                let path = this.attachmentLoader.newPathAttachment(skin, name);\r\n                if (path == null) return null;\r\n                path.closed = this.getValue(map, \"closed\", false);\r\n                path.constantSpeed = this.getValue(map, \"constantSpeed\", true);\r\n\r\n                let vertexCount = map.vertexCount;\r\n                this.readVertices(map, path, vertexCount << 1);\r\n\r\n                let lengths: Array<number> = Utils.newArray(vertexCount / 3, 0);\r\n                for (let i = 0; i < map.lengths.length; i++)\r\n                    lengths[i] = map.lengths[i] * scale;\r\n                path.lengths = lengths;\r\n\r\n                let color: string = this.getValue(map, \"color\", null);\r\n                if (color != null) path.color.setFromString(color);\r\n                return path;\r\n            }\r\n            case \"point\": {\r\n                let point = this.attachmentLoader.newPointAttachment(skin, name);\r\n                if (point == null) return null;\r\n                point.x = this.getValue(map, \"x\", 0) * scale;\r\n                point.y = this.getValue(map, \"y\", 0) * scale;\r\n                point.rotation = this.getValue(map, \"rotation\", 0);\r\n\r\n                let color = this.getValue(map, \"color\", null);\r\n                if (color != null) point.color.setFromString(color);\r\n                return point;\r\n            }\r\n            case \"clipping\": {\r\n                let clip = this.attachmentLoader.newClippingAttachment(skin, name);\r\n                if (clip == null) return null;\r\n\r\n                let end = this.getValue(map, \"end\", null);\r\n                if (end != null) {\r\n                    let slot = skeletonData.findSlot(end);\r\n                    if (slot == null) throw new Error(\"Clipping end slot not found: \" + end);\r\n                    clip.endSlot = slot;\r\n                }\r\n\r\n                let vertexCount = map.vertexCount;\r\n                this.readVertices(map, clip, vertexCount << 1);\r\n\r\n                let color: string = this.getValue(map, \"color\", null);\r\n                if (color != null) clip.color.setFromString(color);\r\n                return clip;\r\n            }\r\n        }\r\n        return null;\r\n    }\r\n\r\n    readVertices (map: any, attachment: VertexAttachment, verticesLength: number) {\r\n        let scale = this.scale;\r\n        attachment.worldVerticesLength = verticesLength;\r\n        let vertices: Array<number> = map.vertices;\r\n        if (verticesLength == vertices.length) {\r\n            let scaledVertices = Utils.toFloatArray(vertices);\r\n            if (scale != 1) {\r\n                for (let i = 0, n = vertices.length; i < n; i++)\r\n                    scaledVertices[i] *= scale;\r\n            }\r\n            attachment.vertices = scaledVertices;\r\n            return;\r\n        }\r\n        let weights = new Array<number>();\r\n        let bones = new Array<number>();\r\n        for (let i = 0, n = vertices.length; i < n;) {\r\n            let boneCount = vertices[i++];\r\n            bones.push(boneCount);\r\n            for (let nn = i + boneCount * 4; i < nn; i += 4) {\r\n                bones.push(vertices[i]);\r\n                weights.push(vertices[i + 1] * scale);\r\n                weights.push(vertices[i + 2] * scale);\r\n                weights.push(vertices[i + 3]);\r\n            }\r\n        }\r\n        attachment.bones = bones;\r\n        attachment.vertices = Utils.toFloatArray(weights);\r\n    }\r\n\r\n    readAnimation (map: any, name: string, skeletonData: SkeletonData) {\r\n        let scale = this.scale;\r\n        let timelines = new Array<Timeline>();\r\n        let duration = 0;\r\n\r\n        // Slot timelines.\r\n        if (map.slots) {\r\n            for (let slotName in map.slots) {\r\n                let slotMap = map.slots[slotName];\r\n                let slotIndex = skeletonData.findSlotIndex(slotName);\r\n                if (slotIndex == -1) throw new Error(\"Slot not found: \" + slotName);\r\n                for (let timelineName in slotMap) {\r\n                    let timelineMap = slotMap[timelineName];\r\n                    if (timelineName == \"attachment\") {\r\n                        let timeline = new AttachmentTimeline(timelineMap.length);\r\n                        timeline.slotIndex = slotIndex;\r\n\r\n                        let frameIndex = 0;\r\n                        for (let i = 0; i < timelineMap.length; i++) {\r\n                            let valueMap = timelineMap[i];\r\n                            timeline.setFrame(frameIndex++, this.getValue(valueMap, \"time\", 0), valueMap.name);\r\n                        }\r\n                        timelines.push(timeline);\r\n                        duration = Math.max(duration, timeline.frames[timeline.getFrameCount() - 1]);\r\n                    } else if (timelineName == \"color\") {\r\n                        let timeline = new ColorTimeline(timelineMap.length);\r\n                        timeline.slotIndex = slotIndex;\r\n\r\n                        let frameIndex = 0;\r\n                        for (let i = 0; i < timelineMap.length; i++) {\r\n                            let valueMap = timelineMap[i];\r\n                            let color = new Color();\r\n                            color.setFromString(valueMap.color || \"ffffffff\");\r\n                            timeline.setFrame(frameIndex, this.getValue(valueMap, \"time\", 0), color.r, color.g, color.b, color.a);\r\n                            this.readCurve(valueMap, timeline, frameIndex);\r\n                            frameIndex++;\r\n                        }\r\n                        timelines.push(timeline);\r\n                        duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * ColorTimeline.ENTRIES]);\r\n\r\n                    } else if (timelineName == \"twoColor\") {\r\n                        let timeline = new TwoColorTimeline(timelineMap.length);\r\n                        timeline.slotIndex = slotIndex;\r\n\r\n                        let frameIndex = 0;\r\n                        for (let i = 0; i < timelineMap.length; i++) {\r\n                            let valueMap = timelineMap[i];\r\n                            let light = new Color();\r\n                            let dark = new Color();\r\n                            light.setFromString(valueMap.light);\r\n                            dark.setFromString(valueMap.dark);\r\n                            timeline.setFrame(frameIndex, this.getValue(valueMap, \"time\", 0), light.r, light.g, light.b, light.a, dark.r, dark.g, dark.b);\r\n                            this.readCurve(valueMap, timeline, frameIndex);\r\n                            frameIndex++;\r\n                        }\r\n                        timelines.push(timeline);\r\n                        duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * TwoColorTimeline.ENTRIES]);\r\n\r\n                    } else\r\n                        throw new Error(\"Invalid timeline type for a slot: \" + timelineName + \" (\" + slotName + \")\");\r\n                }\r\n            }\r\n        }\r\n\r\n        // Bone timelines.\r\n        if (map.bones) {\r\n            for (let boneName in map.bones) {\r\n                let boneMap = map.bones[boneName];\r\n                let boneIndex = skeletonData.findBoneIndex(boneName);\r\n                if (boneIndex == -1) throw new Error(\"Bone not found: \" + boneName);\r\n                for (let timelineName in boneMap) {\r\n                    let timelineMap = boneMap[timelineName];\r\n                    if (timelineName === \"rotate\") {\r\n                        let timeline = new RotateTimeline(timelineMap.length);\r\n                        timeline.boneIndex = boneIndex;\r\n\r\n                        let frameIndex = 0;\r\n                        for (let i = 0; i < timelineMap.length; i++) {\r\n                            let valueMap = timelineMap[i];\r\n                            timeline.setFrame(frameIndex, this.getValue(valueMap, \"time\", 0), this.getValue(valueMap, \"angle\", 0));\r\n                            this.readCurve(valueMap, timeline, frameIndex);\r\n                            frameIndex++;\r\n                        }\r\n                        timelines.push(timeline);\r\n                        duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * RotateTimeline.ENTRIES]);\r\n\r\n                    } else if (timelineName === \"translate\" || timelineName === \"scale\" || timelineName === \"shear\") {\r\n                        let timeline: TranslateTimeline = null;\r\n                        let timelineScale = 1, defaultValue = 0;\r\n                        if (timelineName === \"scale\") {\r\n                            timeline = new ScaleTimeline(timelineMap.length);\r\n                            defaultValue = 1;\r\n                        } else if (timelineName === \"shear\")\r\n                            timeline = new ShearTimeline(timelineMap.length);\r\n                        else {\r\n                            timeline = new TranslateTimeline(timelineMap.length);\r\n                            timelineScale = scale;\r\n                        }\r\n                        timeline.boneIndex = boneIndex;\r\n\r\n                        let frameIndex = 0;\r\n                        for (let i = 0; i < timelineMap.length; i++) {\r\n                            let valueMap = timelineMap[i];\r\n                            let x = this.getValue(valueMap, \"x\", defaultValue), y = this.getValue(valueMap, \"y\", defaultValue);\r\n                            timeline.setFrame(frameIndex, this.getValue(valueMap, \"time\", 0), x * timelineScale, y * timelineScale);\r\n                            this.readCurve(valueMap, timeline, frameIndex);\r\n                            frameIndex++;\r\n                        }\r\n                        timelines.push(timeline);\r\n                        duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * TranslateTimeline.ENTRIES]);\r\n\r\n                    } else\r\n                        throw new Error(\"Invalid timeline type for a bone: \" + timelineName + \" (\" + boneName + \")\");\r\n                }\r\n            }\r\n        }\r\n\r\n        // IK constraint timelines.\r\n        if (map.ik) {\r\n            for (let constraintName in map.ik) {\r\n                let constraintMap = map.ik[constraintName];\r\n                let constraint = skeletonData.findIkConstraint(constraintName);\r\n                let timeline = new IkConstraintTimeline(constraintMap.length);\r\n                timeline.ikConstraintIndex = skeletonData.ikConstraints.indexOf(constraint);\r\n                let frameIndex = 0;\r\n                for (let i = 0; i < constraintMap.length; i++) {\r\n                    let valueMap = constraintMap[i];\r\n                    timeline.setFrame(frameIndex, this.getValue(valueMap, \"time\", 0), this.getValue(valueMap, \"mix\", 1), this.getValue(valueMap, \"softness\", 0) * scale,\r\n                        this.getValue(valueMap, \"bendPositive\", true) ? 1 : -1, this.getValue(valueMap, \"compress\", false), this.getValue(valueMap, \"stretch\", false));\r\n                    this.readCurve(valueMap, timeline, frameIndex);\r\n                    frameIndex++;\r\n                }\r\n                timelines.push(timeline);\r\n                duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * IkConstraintTimeline.ENTRIES]);\r\n            }\r\n        }\r\n\r\n        // Transform constraint timelines.\r\n        if (map.transform) {\r\n            for (let constraintName in map.transform) {\r\n                let constraintMap = map.transform[constraintName];\r\n                let constraint = skeletonData.findTransformConstraint(constraintName);\r\n                let timeline = new TransformConstraintTimeline(constraintMap.length);\r\n                timeline.transformConstraintIndex = skeletonData.transformConstraints.indexOf(constraint);\r\n                let frameIndex = 0;\r\n                for (let i = 0; i < constraintMap.length; i++) {\r\n                    let valueMap = constraintMap[i];\r\n                    timeline.setFrame(frameIndex, this.getValue(valueMap, \"time\", 0), this.getValue(valueMap, \"rotateMix\", 1),\r\n                        this.getValue(valueMap, \"translateMix\", 1), this.getValue(valueMap, \"scaleMix\", 1), this.getValue(valueMap, \"shearMix\", 1));\r\n                    this.readCurve(valueMap, timeline, frameIndex);\r\n                    frameIndex++;\r\n                }\r\n                timelines.push(timeline);\r\n                duration = Math.max(duration,\r\n                    timeline.frames[(timeline.getFrameCount() - 1) * TransformConstraintTimeline.ENTRIES]);\r\n            }\r\n        }\r\n\r\n        // Path constraint timelines.\r\n        if (map.path) {\r\n            for (let constraintName in map.path) {\r\n                let constraintMap = map.path[constraintName];\r\n                let index = skeletonData.findPathConstraintIndex(constraintName);\r\n                if (index == -1) throw new Error(\"Path constraint not found: \" + constraintName);\r\n                let data = skeletonData.pathConstraints[index];\r\n                for (let timelineName in constraintMap) {\r\n                    let timelineMap = constraintMap[timelineName];\r\n                    if (timelineName === \"position\" || timelineName === \"spacing\") {\r\n                        let timeline: PathConstraintPositionTimeline = null;\r\n                        let timelineScale = 1;\r\n                        if (timelineName === \"spacing\") {\r\n                            timeline = new PathConstraintSpacingTimeline(timelineMap.length);\r\n                            if (data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed) timelineScale = scale;\r\n                        } else {\r\n                            timeline = new PathConstraintPositionTimeline(timelineMap.length);\r\n                            if (data.positionMode == PositionMode.Fixed) timelineScale = scale;\r\n                        }\r\n                        timeline.pathConstraintIndex = index;\r\n                        let frameIndex = 0;\r\n                        for (let i = 0; i < timelineMap.length; i++) {\r\n                            let valueMap = timelineMap[i];\r\n                            timeline.setFrame(frameIndex, this.getValue(valueMap, \"time\", 0), this.getValue(valueMap, timelineName, 0) * timelineScale);\r\n                            this.readCurve(valueMap, timeline, frameIndex);\r\n                            frameIndex++;\r\n                        }\r\n                        timelines.push(timeline);\r\n                        duration = Math.max(duration,\r\n                            timeline.frames[(timeline.getFrameCount() - 1) * PathConstraintPositionTimeline.ENTRIES]);\r\n                    } else if (timelineName === \"mix\") {\r\n                        let timeline = new PathConstraintMixTimeline(timelineMap.length);\r\n                        timeline.pathConstraintIndex = index;\r\n                        let frameIndex = 0;\r\n                        for (let i = 0; i < timelineMap.length; i++) {\r\n                            let valueMap = timelineMap[i];\r\n                            timeline.setFrame(frameIndex, this.getValue(valueMap, \"time\", 0), this.getValue(valueMap, \"rotateMix\", 1),\r\n                                this.getValue(valueMap, \"translateMix\", 1));\r\n                            this.readCurve(valueMap, timeline, frameIndex);\r\n                            frameIndex++;\r\n                        }\r\n                        timelines.push(timeline);\r\n                        duration = Math.max(duration,\r\n                            timeline.frames[(timeline.getFrameCount() - 1) * PathConstraintMixTimeline.ENTRIES]);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        // Deform timelines.\r\n        if (map.deform) {\r\n            for (let deformName in map.deform) {\r\n                let deformMap = map.deform[deformName];\r\n                let skin = skeletonData.findSkin(deformName);\r\n                if (skin == null) {\r\n                   if (settings.FAIL_ON_NON_EXISTING_SKIN) {\r\n                       throw new Error(\"Skin not found: \" + deformName);\r\n                   } else {\r\n                       continue;\r\n                   }\r\n                }\r\n                for (let slotName in deformMap) {\r\n                    let slotMap = deformMap[slotName];\r\n                    let slotIndex = skeletonData.findSlotIndex(slotName);\r\n                    if (slotIndex == -1) throw new Error(\"Slot not found: \" + slotMap.name);\r\n                    for (let timelineName in slotMap) {\r\n                        let timelineMap = slotMap[timelineName];\r\n                        let attachment = <VertexAttachment>skin.getAttachment(slotIndex, timelineName);\r\n                        if (attachment == null) throw new Error(\"Deform attachment not found: \" + timelineMap.name);\r\n                        let weighted = attachment.bones != null;\r\n                        let vertices = attachment.vertices;\r\n                        let deformLength = weighted ? vertices.length / 3 * 2 : vertices.length;\r\n\r\n                        let timeline = new DeformTimeline(timelineMap.length);\r\n                        timeline.slotIndex = slotIndex;\r\n                        timeline.attachment = attachment;\r\n\r\n                        let frameIndex = 0;\r\n                        for (let j = 0; j < timelineMap.length; j++) {\r\n                            let valueMap = timelineMap[j];\r\n                            let deform: ArrayLike<number>;\r\n                            let verticesValue: Array<Number> = this.getValue(valueMap, \"vertices\", null);\r\n                            if (verticesValue == null)\r\n                                deform = weighted ? Utils.newFloatArray(deformLength) : vertices;\r\n                            else {\r\n                                deform = Utils.newFloatArray(deformLength);\r\n                                let start = <number>this.getValue(valueMap, \"offset\", 0);\r\n                                Utils.arrayCopy(verticesValue, 0, deform, start, verticesValue.length);\r\n                                if (scale != 1) {\r\n                                    for (let i = start, n = i + verticesValue.length; i < n; i++)\r\n                                        deform[i] *= scale;\r\n                                }\r\n                                if (!weighted) {\r\n                                    for (let i = 0; i < deformLength; i++)\r\n                                        deform[i] += vertices[i];\r\n                                }\r\n                            }\r\n\r\n                            timeline.setFrame(frameIndex, this.getValue(valueMap, \"time\", 0), deform);\r\n                            this.readCurve(valueMap, timeline, frameIndex);\r\n                            frameIndex++;\r\n                        }\r\n                        timelines.push(timeline);\r\n                        duration = Math.max(duration, timeline.frames[timeline.getFrameCount() - 1]);\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        // Draw order timeline.\r\n        let drawOrderNode = map.drawOrder;\r\n        if (drawOrderNode == null) drawOrderNode = map.draworder;\r\n        if (drawOrderNode != null) {\r\n            let timeline = new DrawOrderTimeline(drawOrderNode.length);\r\n            let slotCount = skeletonData.slots.length;\r\n            let frameIndex = 0;\r\n            for (let j = 0; j < drawOrderNode.length; j++) {\r\n                let drawOrderMap = drawOrderNode[j];\r\n                let drawOrder: Array<number> = null;\r\n                let offsets = this.getValue(drawOrderMap, \"offsets\", null);\r\n                if (offsets != null) {\r\n                    drawOrder = Utils.newArray<number>(slotCount, -1);\r\n                    let unchanged = Utils.newArray<number>(slotCount - offsets.length, 0);\r\n                    let originalIndex = 0, unchangedIndex = 0;\r\n                    for (let i = 0; i < offsets.length; i++) {\r\n                        let offsetMap = offsets[i];\r\n                        let slotIndex = skeletonData.findSlotIndex(offsetMap.slot);\r\n                        if (slotIndex == -1) throw new Error(\"Slot not found: \" + offsetMap.slot);\r\n                        // Collect unchanged items.\r\n                        while (originalIndex != slotIndex)\r\n                            unchanged[unchangedIndex++] = originalIndex++;\r\n                        // Set changed items.\r\n                        drawOrder[originalIndex + offsetMap.offset] = originalIndex++;\r\n                    }\r\n                    // Collect remaining unchanged items.\r\n                    while (originalIndex < slotCount)\r\n                        unchanged[unchangedIndex++] = originalIndex++;\r\n                    // Fill in unchanged items.\r\n                    for (let i = slotCount - 1; i >= 0; i--)\r\n                        if (drawOrder[i] == -1) drawOrder[i] = unchanged[--unchangedIndex];\r\n                }\r\n                timeline.setFrame(frameIndex++, this.getValue(drawOrderMap, \"time\", 0), drawOrder);\r\n            }\r\n            timelines.push(timeline);\r\n            duration = Math.max(duration, timeline.frames[timeline.getFrameCount() - 1]);\r\n        }\r\n\r\n        // Event timeline.\r\n        if (map.events) {\r\n            let timeline = new EventTimeline(map.events.length);\r\n            let frameIndex = 0;\r\n            for (let i = 0; i < map.events.length; i++) {\r\n                let eventMap = map.events[i];\r\n                let eventData = skeletonData.findEvent(eventMap.name);\r\n                if (eventData == null) throw new Error(\"Event not found: \" + eventMap.name);\r\n                let event = new Event(Utils.toSinglePrecision(this.getValue(eventMap, \"time\", 0)), eventData);\r\n                event.intValue = this.getValue(eventMap, \"int\", eventData.intValue);\r\n                event.floatValue = this.getValue(eventMap, \"float\", eventData.floatValue);\r\n                event.stringValue = this.getValue(eventMap, \"string\", eventData.stringValue);\r\n                if (event.data.audioPath != null) {\r\n                    event.volume = this.getValue(eventMap, \"volume\", 1);\r\n                    event.balance = this.getValue(eventMap, \"balance\", 0);\r\n                }\r\n                timeline.setFrame(frameIndex++, event);\r\n            }\r\n            timelines.push(timeline);\r\n            duration = Math.max(duration, timeline.frames[timeline.getFrameCount() - 1]);\r\n        }\r\n\r\n        if (isNaN(duration)) {\r\n            throw new Error(\"Error while parsing animation, duration is NaN\");\r\n        }\r\n\r\n        skeletonData.animations.push(new Animation(name, timelines, duration));\r\n    }\r\n\r\n    readCurve (map: any, timeline: CurveTimeline, frameIndex: number) {\r\n        if (!map.hasOwnProperty(\"curve\")) return;\r\n        if (map.curve === \"stepped\")\r\n            timeline.setStepped(frameIndex);\r\n        else {\r\n            let curve: number = map.curve;\r\n            timeline.setCurve(frameIndex, curve, this.getValue(map, \"c2\", 0), this.getValue(map, \"c3\", 1), this.getValue(map, \"c4\", 1));\r\n        }\r\n    }\r\n\r\n    getValue (map: any, prop: string, defaultValue: any) {\r\n        return map[prop] !== undefined ? map[prop] : defaultValue;\r\n    }\r\n\r\n    static blendModeFromString (str: string) {\r\n        str = str.toLowerCase();\r\n        if (str == \"normal\") return BLEND_MODES.NORMAL;\r\n        if (str == \"additive\") return BLEND_MODES.ADD;\r\n        if (str == \"multiply\") return BLEND_MODES.MULTIPLY;\r\n        if (str == \"screen\") return BLEND_MODES.SCREEN;\r\n        throw new Error(`Unknown blend mode: ${str}`);\r\n    }\r\n\r\n    static positionModeFromString (str: string) {\r\n        str = str.toLowerCase();\r\n        if (str == \"fixed\") return PositionMode.Fixed;\r\n        if (str == \"percent\") return PositionMode.Percent;\r\n        throw new Error(`Unknown position mode: ${str}`);\r\n    }\r\n\r\n    static spacingModeFromString (str: string) {\r\n        str = str.toLowerCase();\r\n        if (str == \"length\") return SpacingMode.Length;\r\n        if (str == \"fixed\") return SpacingMode.Fixed;\r\n        if (str == \"percent\") return SpacingMode.Percent;\r\n        throw new Error(`Unknown position mode: ${str}`);\r\n    }\r\n\r\n    static rotateModeFromString (str: string) {\r\n        str = str.toLowerCase();\r\n        if (str == \"tangent\") return RotateMode.Tangent;\r\n        if (str == \"chain\") return RotateMode.Chain;\r\n        if (str == \"chainscale\") return RotateMode.ChainScale;\r\n        throw new Error(`Unknown rotate mode: ${str}`);\r\n    }\r\n\r\n    static transformModeFromString(str: string) {\r\n        str = str.toLowerCase();\r\n        if (str == \"normal\") return TransformMode.Normal;\r\n        if (str == \"onlytranslation\") return TransformMode.OnlyTranslation;\r\n        if (str == \"norotationorreflection\") return TransformMode.NoRotationOrReflection;\r\n        if (str == \"noscale\") return TransformMode.NoScale;\r\n        if (str == \"noscaleorreflection\") return TransformMode.NoScaleOrReflection;\r\n        throw new Error(`Unknown transform mode: ${str}`);\r\n    }\r\n}\r\n\r\nclass LinkedMesh {\r\n    parent: string; skin: string;\r\n    slotIndex: number;\r\n    mesh: MeshAttachment;\r\n    inheritDeform: boolean;\r\n\r\n    constructor (mesh: MeshAttachment, skin: string, slotIndex: number, parent: string, inheritDeform: boolean) {\r\n        this.mesh = mesh;\r\n        this.skin = skin;\r\n        this.slotIndex = slotIndex;\r\n        this.parent = parent;\r\n        this.inheritDeform = inheritDeform;\r\n    }\r\n}\r\n","import {SpineBase} from '@pixi-spine/base';\r\nimport {Skeleton} from \"./core/Skeleton\";\r\nimport {SkeletonData} from \"./core/SkeletonData\";\r\nimport {AnimationState} from \"./core/AnimationState\";\r\nimport {AnimationStateData} from \"./core/AnimationStateData\";\r\n\r\n/**\r\n * @public\r\n */\r\nexport class Spine extends SpineBase<Skeleton, SkeletonData, AnimationState, AnimationStateData> {\r\n    createSkeleton(spineData: SkeletonData) {\r\n        this.skeleton = new Skeleton(spineData);\r\n        this.skeleton.updateWorldTransform();\r\n        this.stateData = new AnimationStateData(spineData);\r\n        this.state = new AnimationState(this.stateData);\r\n    }\r\n}\r\n","import {SpineParser} from '@pixi-spine/loader-3.8';\r\nexport {SpineParser};\r\nexport * from '@pixi-spine/runtime-3.8';\r\nexport * from '@pixi-spine/base';\r\n\r\nSpineParser.registerLoaderPlugin();\r\n"],"sourceRoot":""}