[ts][player] Fixed text selection on speed slider modification in FF, added snapping to speed slider, added hiding timeline if mouse doesn't move for 1 second except when popup is active or mouse is over controls, decided against popup centered over button, removed Show prefix from debug popup, added hiding buttons if there is only one skin/animation, fixed control bone not moving when paused.

spine-sfml/cpp/example/main.cpp

@@ -444,7 +444,7 @@ void test (SkeletonData* skeletonData, Atlas* atlas) {
 	Skeleton skeleton(skeletonData);
 	AnimationStateData animationStateData(skeletonData);
 	AnimationState animationState(&animationStateData);
-	animationState.setAnimation(0, "drive", true);
+	animationState.setAnimation(0, "idle", true);
 
 	float d = 3;
 	for (int i = 0; i < 1; i++) {
@@ -459,6 +459,7 @@ int main () {
 	DebugExtension dbgExtension(SpineExtension::getInstance());
 	SpineExtension::setInstance(&dbgExtension);
 
+	testcase(test, "data/yellow_god.json", "data/yellow_god.skel", "data/yellow_god.atlas", 0.6f);
 	testcase(spineboy, "data/spineboy-pro.json", "data/spineboy-pro.skel", "data/spineboy.atlas", 0.6f);
 	testcase(stretchymanStrechyIk, "data/stretchyman-stretchy-ik.json", "data/stretchyman-stretchy-ik.skel", "data/stretchyman.atlas", 0.6f);
 	testcase(spineboy, "data/spineboy-ess.json", "data/spineboy-ess.skel", "data/spineboy.atlas", 0.6f);

spine-ts/build/spine-widget.d.ts

@@ -1,1820 +1,1822 @@
 declare module spine {
-	class Animation {
-		name: string;
-		timelines: Array<Timeline>;
-		duration: number;
-		constructor(name: string, timelines: Array<Timeline>, duration: number);
-		apply(skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-		static binarySearch(values: ArrayLike<number>, target: number, step?: number): number;
-		static linearSearch(values: ArrayLike<number>, target: number, step: number): number;
-	}
-	interface Timeline {
-		apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-		getPropertyId(): number;
-	}
-	enum MixBlend {
-		setup = 0,
-		first = 1,
-		replace = 2,
-		add = 3
-	}
-	enum MixDirection {
-		in = 0,
-		out = 1
-	}
-	enum TimelineType {
-		rotate = 0,
-		translate = 1,
-		scale = 2,
-		shear = 3,
-		attachment = 4,
-		color = 5,
-		deform = 6,
-		event = 7,
-		drawOrder = 8,
-		ikConstraint = 9,
-		transformConstraint = 10,
-		pathConstraintPosition = 11,
-		pathConstraintSpacing = 12,
-		pathConstraintMix = 13,
-		twoColor = 14
-	}
-	abstract class CurveTimeline implements Timeline {
-		static LINEAR: number;
-		static STEPPED: number;
-		static BEZIER: number;
-		static BEZIER_SIZE: number;
-		private curves;
-		abstract getPropertyId(): number;
-		constructor(frameCount: number);
-		getFrameCount(): number;
-		setLinear(frameIndex: number): void;
-		setStepped(frameIndex: number): void;
-		getCurveType(frameIndex: number): number;
-		setCurve(frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number): void;
-		getCurvePercent(frameIndex: number, percent: number): number;
-		abstract apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
-	class RotateTimeline extends CurveTimeline {
-		static ENTRIES: number;
-		static PREV_TIME: number;
-		static PREV_ROTATION: number;
-		static ROTATION: number;
-		boneIndex: number;
-		frames: ArrayLike<number>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		setFrame(frameIndex: number, time: number, degrees: number): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
-	class TranslateTimeline extends CurveTimeline {
-		static ENTRIES: number;
-		static PREV_TIME: number;
-		static PREV_X: number;
-		static PREV_Y: number;
-		static X: number;
-		static Y: number;
-		boneIndex: number;
-		frames: ArrayLike<number>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		setFrame(frameIndex: number, time: number, x: number, y: number): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
-	class ScaleTimeline extends TranslateTimeline {
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
-	class ShearTimeline extends TranslateTimeline {
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
-	class ColorTimeline extends CurveTimeline {
-		static ENTRIES: number;
-		static PREV_TIME: number;
-		static PREV_R: number;
-		static PREV_G: number;
-		static PREV_B: number;
-		static PREV_A: number;
-		static R: number;
-		static G: number;
-		static B: number;
-		static A: number;
-		slotIndex: number;
-		frames: ArrayLike<number>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
-	class TwoColorTimeline extends CurveTimeline {
-		static ENTRIES: number;
-		static PREV_TIME: number;
-		static PREV_R: number;
-		static PREV_G: number;
-		static PREV_B: number;
-		static PREV_A: number;
-		static PREV_R2: number;
-		static PREV_G2: number;
-		static PREV_B2: number;
-		static R: number;
-		static G: number;
-		static B: number;
-		static A: number;
-		static R2: number;
-		static G2: number;
-		static B2: number;
-		slotIndex: number;
-		frames: ArrayLike<number>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number, r2: number, g2: number, b2: number): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
-	class AttachmentTimeline implements Timeline {
-		slotIndex: number;
-		frames: ArrayLike<number>;
-		attachmentNames: Array<string>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		getFrameCount(): number;
-		setFrame(frameIndex: number, time: number, attachmentName: string): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
-	class DeformTimeline extends CurveTimeline {
-		slotIndex: number;
-		attachment: VertexAttachment;
-		frames: ArrayLike<number>;
-		frameVertices: Array<ArrayLike<number>>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
-	class EventTimeline implements Timeline {
-		frames: ArrayLike<number>;
-		events: Array<Event>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		getFrameCount(): number;
-		setFrame(frameIndex: number, event: Event): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
-	class DrawOrderTimeline implements Timeline {
-		frames: ArrayLike<number>;
-		drawOrders: Array<Array<number>>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		getFrameCount(): number;
-		setFrame(frameIndex: number, time: number, drawOrder: Array<number>): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
-	class IkConstraintTimeline extends CurveTimeline {
-		static ENTRIES: number;
-		static PREV_TIME: number;
-		static PREV_MIX: number;
-		static PREV_BEND_DIRECTION: number;
-		static PREV_COMPRESS: number;
-		static PREV_STRETCH: number;
-		static MIX: number;
-		static BEND_DIRECTION: number;
-		static COMPRESS: number;
-		static STRETCH: number;
-		ikConstraintIndex: number;
-		frames: ArrayLike<number>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		setFrame(frameIndex: number, time: number, mix: number, bendDirection: number, compress: boolean, stretch: boolean): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
-	class TransformConstraintTimeline extends CurveTimeline {
-		static ENTRIES: number;
-		static PREV_TIME: number;
-		static PREV_ROTATE: number;
-		static PREV_TRANSLATE: number;
-		static PREV_SCALE: number;
-		static PREV_SHEAR: number;
-		static ROTATE: number;
-		static TRANSLATE: number;
-		static SCALE: number;
-		static SHEAR: number;
-		transformConstraintIndex: number;
-		frames: ArrayLike<number>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		setFrame(frameIndex: number, time: number, rotateMix: number, translateMix: number, scaleMix: number, shearMix: number): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
-	class PathConstraintPositionTimeline extends CurveTimeline {
-		static ENTRIES: number;
-		static PREV_TIME: number;
-		static PREV_VALUE: number;
-		static VALUE: number;
-		pathConstraintIndex: number;
-		frames: ArrayLike<number>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		setFrame(frameIndex: number, time: number, value: number): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
-	class PathConstraintSpacingTimeline extends PathConstraintPositionTimeline {
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
-	class PathConstraintMixTimeline extends CurveTimeline {
-		static ENTRIES: number;
-		static PREV_TIME: number;
-		static PREV_ROTATE: number;
-		static PREV_TRANSLATE: number;
-		static ROTATE: number;
-		static TRANSLATE: number;
-		pathConstraintIndex: number;
-		frames: ArrayLike<number>;
-		constructor(frameCount: number);
-		getPropertyId(): number;
-		setFrame(frameIndex: number, time: number, rotateMix: number, translateMix: number): void;
-		apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-	}
+    class Animation {
+        name: string;
+        timelines: Array<Timeline>;
+        duration: number;
+        constructor(name: string, timelines: Array<Timeline>, duration: number);
+        apply(skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+        static binarySearch(values: ArrayLike<number>, target: number, step?: number): number;
+        static linearSearch(values: ArrayLike<number>, target: number, step: number): number;
+    }
+    interface Timeline {
+        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+        getPropertyId(): number;
+    }
+    enum MixBlend {
+        setup = 0,
+        first = 1,
+        replace = 2,
+        add = 3,
+    }
+    enum MixDirection {
+        in = 0,
+        out = 1,
+    }
+    enum TimelineType {
+        rotate = 0,
+        translate = 1,
+        scale = 2,
+        shear = 3,
+        attachment = 4,
+        color = 5,
+        deform = 6,
+        event = 7,
+        drawOrder = 8,
+        ikConstraint = 9,
+        transformConstraint = 10,
+        pathConstraintPosition = 11,
+        pathConstraintSpacing = 12,
+        pathConstraintMix = 13,
+        twoColor = 14,
+    }
+    abstract class CurveTimeline implements Timeline {
+        static LINEAR: number;
+        static STEPPED: number;
+        static BEZIER: number;
+        static BEZIER_SIZE: number;
+        private curves;
+        abstract getPropertyId(): number;
+        constructor(frameCount: number);
+        getFrameCount(): number;
+        setLinear(frameIndex: number): void;
+        setStepped(frameIndex: number): void;
+        getCurveType(frameIndex: number): number;
+        setCurve(frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number): void;
+        getCurvePercent(frameIndex: number, percent: number): number;
+        abstract apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
+    class RotateTimeline extends CurveTimeline {
+        static ENTRIES: number;
+        static PREV_TIME: number;
+        static PREV_ROTATION: number;
+        static ROTATION: number;
+        boneIndex: number;
+        frames: ArrayLike<number>;
+        constructor(frameCount: number);
+        getPropertyId(): number;
+        setFrame(frameIndex: number, time: number, degrees: number): void;
+        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
+    class TranslateTimeline extends CurveTimeline {
+        static ENTRIES: number;
+        static PREV_TIME: number;
+        static PREV_X: number;
+        static PREV_Y: number;
+        static X: number;
+        static Y: number;
+        boneIndex: number;
+        frames: ArrayLike<number>;
+        constructor(frameCount: number);
+        getPropertyId(): number;
+        setFrame(frameIndex: number, time: number, x: number, y: number): void;
+        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
+    class ScaleTimeline extends TranslateTimeline {
+        constructor(frameCount: number);
+        getPropertyId(): number;
+        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
+    class ShearTimeline extends TranslateTimeline {
+        constructor(frameCount: number);
+        getPropertyId(): number;
+        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
+    class ColorTimeline extends CurveTimeline {
+        static ENTRIES: number;
+        static PREV_TIME: number;
+        static PREV_R: number;
+        static PREV_G: number;
+        static PREV_B: number;
+        static PREV_A: number;
+        static R: number;
+        static G: number;
+        static B: number;
+        static A: number;
+        slotIndex: number;
+        frames: ArrayLike<number>;
+        constructor(frameCount: number);
+        getPropertyId(): number;
+        setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number): void;
+        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
+    class TwoColorTimeline extends CurveTimeline {
+        static ENTRIES: number;
+        static PREV_TIME: number;
+        static PREV_R: number;
+        static PREV_G: number;
+        static PREV_B: number;
+        static PREV_A: number;
+        static PREV_R2: number;
+        static PREV_G2: number;
+        static PREV_B2: number;
+        static R: number;
+        static G: number;
+        static B: number;
+        static A: number;
+        static R2: number;
+        static G2: number;
+        static B2: number;
+        slotIndex: number;
+        frames: ArrayLike<number>;
+        constructor(frameCount: number);
+        getPropertyId(): number;
+        setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number, r2: number, g2: number, b2: number): void;
+        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
+    class AttachmentTimeline implements Timeline {
+        slotIndex: number;
+        frames: ArrayLike<number>;
+        attachmentNames: Array<string>;
+        constructor(frameCount: number);
+        getPropertyId(): number;
+        getFrameCount(): number;
+        setFrame(frameIndex: number, time: number, attachmentName: string): void;
+        apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
+    class DeformTimeline extends CurveTimeline {
+        slotIndex: number;
+        attachment: VertexAttachment;
+        frames: ArrayLike<number>;
+        frameVertices: Array<ArrayLike<number>>;
+        constructor(frameCount: number);
+        getPropertyId(): number;
+        setFrame(frameIndex: number, time: number, vertices: ArrayLike<number>): void;
+        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
+    class EventTimeline implements Timeline {
+        frames: ArrayLike<number>;
+        events: Array<Event>;
+        constructor(frameCount: number);
+        getPropertyId(): number;
+        getFrameCount(): number;
+        setFrame(frameIndex: number, event: Event): void;
+        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
+    class DrawOrderTimeline implements Timeline {
+        frames: ArrayLike<number>;
+        drawOrders: Array<Array<number>>;
+        constructor(frameCount: number);
+        getPropertyId(): number;
+        getFrameCount(): number;
+        setFrame(frameIndex: number, time: number, drawOrder: Array<number>): void;
+        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
+    class IkConstraintTimeline extends CurveTimeline {
+        static ENTRIES: number;
+        static PREV_TIME: number;
+        static PREV_MIX: number;
+        static PREV_BEND_DIRECTION: number;
+        static PREV_COMPRESS: number;
+        static PREV_STRETCH: number;
+        static MIX: number;
+        static BEND_DIRECTION: number;
+        static COMPRESS: number;
+        static STRETCH: number;
+        ikConstraintIndex: number;
+        frames: ArrayLike<number>;
+        constructor(frameCount: number);
+        getPropertyId(): number;
+        setFrame(frameIndex: number, time: number, mix: number, bendDirection: number, compress: boolean, stretch: boolean): void;
+        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
+    class TransformConstraintTimeline extends CurveTimeline {
+        static ENTRIES: number;
+        static PREV_TIME: number;
+        static PREV_ROTATE: number;
+        static PREV_TRANSLATE: number;
+        static PREV_SCALE: number;
+        static PREV_SHEAR: number;
+        static ROTATE: number;
+        static TRANSLATE: number;
+        static SCALE: number;
+        static SHEAR: number;
+        transformConstraintIndex: number;
+        frames: ArrayLike<number>;
+        constructor(frameCount: number);
+        getPropertyId(): number;
+        setFrame(frameIndex: number, time: number, rotateMix: number, translateMix: number, scaleMix: number, shearMix: number): void;
+        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
+    class PathConstraintPositionTimeline extends CurveTimeline {
+        static ENTRIES: number;
+        static PREV_TIME: number;
+        static PREV_VALUE: number;
+        static VALUE: number;
+        pathConstraintIndex: number;
+        frames: ArrayLike<number>;
+        constructor(frameCount: number);
+        getPropertyId(): number;
+        setFrame(frameIndex: number, time: number, value: number): void;
+        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
+    class PathConstraintSpacingTimeline extends PathConstraintPositionTimeline {
+        constructor(frameCount: number);
+        getPropertyId(): number;
+        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
+    class PathConstraintMixTimeline extends CurveTimeline {
+        static ENTRIES: number;
+        static PREV_TIME: number;
+        static PREV_ROTATE: number;
+        static PREV_TRANSLATE: number;
+        static ROTATE: number;
+        static TRANSLATE: number;
+        pathConstraintIndex: number;
+        frames: ArrayLike<number>;
+        constructor(frameCount: number);
+        getPropertyId(): number;
+        setFrame(frameIndex: number, time: number, rotateMix: number, translateMix: number): void;
+        apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+    }
 }
 declare module spine {
-	class AnimationState {
-		static emptyAnimation: Animation;
-		static SUBSEQUENT: number;
-		static FIRST: number;
-		static HOLD: number;
-		static HOLD_MIX: number;
-		data: AnimationStateData;
-		tracks: TrackEntry[];
-		events: Event[];
-		listeners: AnimationStateListener2[];
-		queue: EventQueue;
-		propertyIDs: IntSet;
-		animationsChanged: boolean;
-		timeScale: number;
-		trackEntryPool: Pool<TrackEntry>;
-		constructor(data: AnimationStateData);
-		update(delta: number): void;
-		updateMixingFrom(to: TrackEntry, delta: number): boolean;
-		apply(skeleton: Skeleton): boolean;
-		applyMixingFrom(to: TrackEntry, skeleton: Skeleton, blend: MixBlend): number;
-		applyRotateTimeline(timeline: Timeline, skeleton: Skeleton, time: number, alpha: number, blend: MixBlend, timelinesRotation: Array<number>, i: number, firstFrame: boolean): void;
-		queueEvents(entry: TrackEntry, animationTime: number): void;
-		clearTracks(): void;
-		clearTrack(trackIndex: number): void;
-		setCurrent(index: number, current: TrackEntry, interrupt: boolean): void;
-		setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
-		setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
-		addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
-		addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
-		setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
-		addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
-		setEmptyAnimations(mixDuration: number): void;
-		expandToIndex(index: number): TrackEntry;
-		trackEntry(trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry): TrackEntry;
-		disposeNext(entry: TrackEntry): void;
-		_animationsChanged(): void;
-		setTimelineModes(entry: TrackEntry): void;
-		hasTimeline(entry: TrackEntry, id: number): boolean;
-		getCurrent(trackIndex: number): TrackEntry;
-		addListener(listener: AnimationStateListener2): void;
-		removeListener(listener: AnimationStateListener2): void;
-		clearListeners(): void;
-		clearListenerNotifications(): void;
-	}
-	class TrackEntry {
-		animation: Animation;
-		next: TrackEntry;
-		mixingFrom: TrackEntry;
-		mixingTo: TrackEntry;
-		listener: AnimationStateListener2;
-		trackIndex: number;
-		loop: boolean;
-		holdPrevious: boolean;
-		eventThreshold: number;
-		attachmentThreshold: number;
-		drawOrderThreshold: number;
-		animationStart: number;
-		animationEnd: number;
-		animationLast: number;
-		nextAnimationLast: number;
-		delay: number;
-		trackTime: number;
-		trackLast: number;
-		nextTrackLast: number;
-		trackEnd: number;
-		timeScale: number;
-		alpha: number;
-		mixTime: number;
-		mixDuration: number;
-		interruptAlpha: number;
-		totalAlpha: number;
-		mixBlend: MixBlend;
-		timelineMode: number[];
-		timelineHoldMix: TrackEntry[];
-		timelinesRotation: number[];
-		reset(): void;
-		getAnimationTime(): number;
-		setAnimationLast(animationLast: number): void;
-		isComplete(): boolean;
-		resetRotationDirections(): void;
-	}
-	class EventQueue {
-		objects: Array<any>;
-		drainDisabled: boolean;
-		animState: AnimationState;
-		constructor(animState: AnimationState);
-		start(entry: TrackEntry): void;
-		interrupt(entry: TrackEntry): void;
-		end(entry: TrackEntry): void;
-		dispose(entry: TrackEntry): void;
-		complete(entry: TrackEntry): void;
-		event(entry: TrackEntry, event: Event): void;
-		drain(): void;
-		clear(): void;
-	}
-	enum EventType {
-		start = 0,
-		interrupt = 1,
-		end = 2,
-		dispose = 3,
-		complete = 4,
-		event = 5
-	}
-	interface AnimationStateListener2 {
-		start(entry: TrackEntry): void;
-		interrupt(entry: TrackEntry): void;
-		end(entry: TrackEntry): void;
-		dispose(entry: TrackEntry): void;
-		complete(entry: TrackEntry): void;
-		event(entry: TrackEntry, event: Event): void;
-	}
-	abstract class AnimationStateAdapter2 implements AnimationStateListener2 {
-		start(entry: TrackEntry): void;
-		interrupt(entry: TrackEntry): void;
-		end(entry: TrackEntry): void;
-		dispose(entry: TrackEntry): void;
-		complete(entry: TrackEntry): void;
-		event(entry: TrackEntry, event: Event): void;
-	}
+    class AnimationState {
+        static emptyAnimation: Animation;
+        static SUBSEQUENT: number;
+        static FIRST: number;
+        static HOLD: number;
+        static HOLD_MIX: number;
+        data: AnimationStateData;
+        tracks: TrackEntry[];
+        events: Event[];
+        listeners: AnimationStateListener2[];
+        queue: EventQueue;
+        propertyIDs: IntSet;
+        animationsChanged: boolean;
+        timeScale: number;
+        trackEntryPool: Pool<TrackEntry>;
+        constructor(data: AnimationStateData);
+        update(delta: number): void;
+        updateMixingFrom(to: TrackEntry, delta: number): boolean;
+        apply(skeleton: Skeleton): boolean;
+        applyMixingFrom(to: TrackEntry, skeleton: Skeleton, blend: MixBlend): number;
+        applyRotateTimeline(timeline: Timeline, skeleton: Skeleton, time: number, alpha: number, blend: MixBlend, timelinesRotation: Array<number>, i: number, firstFrame: boolean): void;
+        queueEvents(entry: TrackEntry, animationTime: number): void;
+        clearTracks(): void;
+        clearTrack(trackIndex: number): void;
+        setCurrent(index: number, current: TrackEntry, interrupt: boolean): void;
+        setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
+        setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
+        addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
+        addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
+        setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
+        addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
+        setEmptyAnimations(mixDuration: number): void;
+        expandToIndex(index: number): TrackEntry;
+        trackEntry(trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry): TrackEntry;
+        disposeNext(entry: TrackEntry): void;
+        _animationsChanged(): void;
+        setTimelineModes(entry: TrackEntry): void;
+        hasTimeline(entry: TrackEntry, id: number): boolean;
+        getCurrent(trackIndex: number): TrackEntry;
+        addListener(listener: AnimationStateListener2): void;
+        removeListener(listener: AnimationStateListener2): void;
+        clearListeners(): void;
+        clearListenerNotifications(): void;
+    }
+    class TrackEntry {
+        animation: Animation;
+        next: TrackEntry;
+        mixingFrom: TrackEntry;
+        mixingTo: TrackEntry;
+        listener: AnimationStateListener2;
+        trackIndex: number;
+        loop: boolean;
+        holdPrevious: boolean;
+        eventThreshold: number;
+        attachmentThreshold: number;
+        drawOrderThreshold: number;
+        animationStart: number;
+        animationEnd: number;
+        animationLast: number;
+        nextAnimationLast: number;
+        delay: number;
+        trackTime: number;
+        trackLast: number;
+        nextTrackLast: number;
+        trackEnd: number;
+        timeScale: number;
+        alpha: number;
+        mixTime: number;
+        mixDuration: number;
+        interruptAlpha: number;
+        totalAlpha: number;
+        mixBlend: MixBlend;
+        timelineMode: number[];
+        timelineHoldMix: TrackEntry[];
+        timelinesRotation: number[];
+        reset(): void;
+        getAnimationTime(): number;
+        setAnimationLast(animationLast: number): void;
+        isComplete(): boolean;
+        resetRotationDirections(): void;
+    }
+    class EventQueue {
+        objects: Array<any>;
+        drainDisabled: boolean;
+        animState: AnimationState;
+        constructor(animState: AnimationState);
+        start(entry: TrackEntry): void;
+        interrupt(entry: TrackEntry): void;
+        end(entry: TrackEntry): void;
+        dispose(entry: TrackEntry): void;
+        complete(entry: TrackEntry): void;
+        event(entry: TrackEntry, event: Event): void;
+        drain(): void;
+        clear(): void;
+    }
+    enum EventType {
+        start = 0,
+        interrupt = 1,
+        end = 2,
+        dispose = 3,
+        complete = 4,
+        event = 5,
+    }
+    interface AnimationStateListener2 {
+        start(entry: TrackEntry): void;
+        interrupt(entry: TrackEntry): void;
+        end(entry: TrackEntry): void;
+        dispose(entry: TrackEntry): void;
+        complete(entry: TrackEntry): void;
+        event(entry: TrackEntry, event: Event): void;
+    }
+    abstract class AnimationStateAdapter2 implements AnimationStateListener2 {
+        start(entry: TrackEntry): void;
+        interrupt(entry: TrackEntry): void;
+        end(entry: TrackEntry): void;
+        dispose(entry: TrackEntry): void;
+        complete(entry: TrackEntry): void;
+        event(entry: TrackEntry, event: Event): void;
+    }
 }
 declare module spine {
-	class AnimationStateData {
-		skeletonData: SkeletonData;
-		animationToMixTime: Map<number>;
-		defaultMix: number;
-		constructor(skeletonData: SkeletonData);
-		setMix(fromName: string, toName: string, duration: number): void;
-		setMixWith(from: Animation, to: Animation, duration: number): void;
-		getMix(from: Animation, to: Animation): number;
-	}
+    class AnimationStateData {
+        skeletonData: SkeletonData;
+        animationToMixTime: Map<number>;
+        defaultMix: number;
+        constructor(skeletonData: SkeletonData);
+        setMix(fromName: string, toName: string, duration: number): void;
+        setMixWith(from: Animation, to: Animation, duration: number): void;
+        getMix(from: Animation, to: Animation): number;
+    }
 }
 declare module spine {
-	class AssetManager implements Disposable {
-		private pathPrefix;
-		private textureLoader;
-		private assets;
-		private errors;
-		private toLoad;
-		private loaded;
-		constructor(textureLoader: (image: HTMLImageElement) => any, pathPrefix?: string);
-		private static downloadText;
-		private static downloadBinary;
-		loadText(path: string, success?: (path: string, text: string) => void, error?: (path: string, error: string) => void): void;
-		loadTexture(path: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
-		loadTextureData(path: string, data: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
-		loadTextureAtlas(path: string, success?: (path: string, atlas: TextureAtlas) => void, error?: (path: string, error: string) => void): void;
-		get(path: string): any;
-		remove(path: string): void;
-		removeAll(): void;
-		isLoadingComplete(): boolean;
-		getToLoad(): number;
-		getLoaded(): number;
-		dispose(): void;
-		hasErrors(): boolean;
-		getErrors(): Map<string>;
-	}
+    class AssetManager implements Disposable {
+        private pathPrefix;
+        private textureLoader;
+        private assets;
+        private errors;
+        private toLoad;
+        private loaded;
+        constructor(textureLoader: (image: HTMLImageElement) => any, pathPrefix?: string);
+        private static downloadText(url, success, error);
+        private static downloadBinary(url, success, error);
+        loadText(path: string, success?: (path: string, text: string) => void, error?: (path: string, error: string) => void): void;
+        loadTexture(path: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
+        loadTextureData(path: string, data: string, success?: (path: string, image: HTMLImageElement) => void, error?: (path: string, error: string) => void): void;
+        loadTextureAtlas(path: string, success?: (path: string, atlas: TextureAtlas) => void, error?: (path: string, error: string) => void): void;
+        get(path: string): any;
+        remove(path: string): void;
+        removeAll(): void;
+        isLoadingComplete(): boolean;
+        getToLoad(): number;
+        getLoaded(): number;
+        dispose(): void;
+        hasErrors(): boolean;
+        getErrors(): Map<string>;
+    }
 }
 declare module spine {
-	class AtlasAttachmentLoader implements AttachmentLoader {
-		atlas: TextureAtlas;
-		constructor(atlas: TextureAtlas);
-		newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
-		newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
-		newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
-		newPathAttachment(skin: Skin, name: string): PathAttachment;
-		newPointAttachment(skin: Skin, name: string): PointAttachment;
-		newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
-	}
+    class AtlasAttachmentLoader implements AttachmentLoader {
+        atlas: TextureAtlas;
+        constructor(atlas: TextureAtlas);
+        newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
+        newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
+        newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
+        newPathAttachment(skin: Skin, name: string): PathAttachment;
+        newPointAttachment(skin: Skin, name: string): PointAttachment;
+        newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
+    }
 }
 declare module spine {
-	enum BlendMode {
-		Normal = 0,
-		Additive = 1,
-		Multiply = 2,
-		Screen = 3
-	}
+    enum BlendMode {
+        Normal = 0,
+        Additive = 1,
+        Multiply = 2,
+        Screen = 3,
+    }
 }
 declare module spine {
-	class Bone implements Updatable {
-		data: BoneData;
-		skeleton: Skeleton;
-		parent: Bone;
-		children: Bone[];
-		x: number;
-		y: number;
-		rotation: number;
-		scaleX: number;
-		scaleY: number;
-		shearX: number;
-		shearY: number;
-		ax: number;
-		ay: number;
-		arotation: number;
-		ascaleX: number;
-		ascaleY: number;
-		ashearX: number;
-		ashearY: number;
-		appliedValid: boolean;
-		a: number;
-		b: number;
-		worldX: number;
-		c: number;
-		d: number;
-		worldY: number;
-		sorted: boolean;
-		constructor(data: BoneData, skeleton: Skeleton, parent: Bone);
-		update(): void;
-		updateWorldTransform(): void;
-		updateWorldTransformWith(x: number, y: number, rotation: number, scaleX: number, scaleY: number, shearX: number, shearY: number): void;
-		setToSetupPose(): void;
-		getWorldRotationX(): number;
-		getWorldRotationY(): number;
-		getWorldScaleX(): number;
-		getWorldScaleY(): number;
-		updateAppliedTransform(): void;
-		worldToLocal(world: Vector2): Vector2;
-		localToWorld(local: Vector2): Vector2;
-		worldToLocalRotation(worldRotation: number): number;
-		localToWorldRotation(localRotation: number): number;
-		rotateWorld(degrees: number): void;
-	}
+    class Bone implements Updatable {
+        data: BoneData;
+        skeleton: Skeleton;
+        parent: Bone;
+        children: Bone[];
+        x: number;
+        y: number;
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+        shearX: number;
+        shearY: number;
+        ax: number;
+        ay: number;
+        arotation: number;
+        ascaleX: number;
+        ascaleY: number;
+        ashearX: number;
+        ashearY: number;
+        appliedValid: boolean;
+        a: number;
+        b: number;
+        worldX: number;
+        c: number;
+        d: number;
+        worldY: number;
+        sorted: boolean;
+        constructor(data: BoneData, skeleton: Skeleton, parent: Bone);
+        update(): void;
+        updateWorldTransform(): void;
+        updateWorldTransformWith(x: number, y: number, rotation: number, scaleX: number, scaleY: number, shearX: number, shearY: number): void;
+        setToSetupPose(): void;
+        getWorldRotationX(): number;
+        getWorldRotationY(): number;
+        getWorldScaleX(): number;
+        getWorldScaleY(): number;
+        updateAppliedTransform(): void;
+        worldToLocal(world: Vector2): Vector2;
+        localToWorld(local: Vector2): Vector2;
+        worldToLocalRotation(worldRotation: number): number;
+        localToWorldRotation(localRotation: number): number;
+        rotateWorld(degrees: number): void;
+    }
 }
 declare module spine {
-	class BoneData {
-		index: number;
-		name: string;
-		parent: BoneData;
-		length: number;
-		x: number;
-		y: number;
-		rotation: number;
-		scaleX: number;
-		scaleY: number;
-		shearX: number;
-		shearY: number;
-		transformMode: TransformMode;
-		constructor(index: number, name: string, parent: BoneData);
-	}
-	enum TransformMode {
-		Normal = 0,
-		OnlyTranslation = 1,
-		NoRotationOrReflection = 2,
-		NoScale = 3,
-		NoScaleOrReflection = 4
-	}
+    class BoneData {
+        index: number;
+        name: string;
+        parent: BoneData;
+        length: number;
+        x: number;
+        y: number;
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+        shearX: number;
+        shearY: number;
+        transformMode: TransformMode;
+        constructor(index: number, name: string, parent: BoneData);
+    }
+    enum TransformMode {
+        Normal = 0,
+        OnlyTranslation = 1,
+        NoRotationOrReflection = 2,
+        NoScale = 3,
+        NoScaleOrReflection = 4,
+    }
 }
 declare module spine {
-	interface Constraint extends Updatable {
-		getOrder(): number;
-	}
+    interface Constraint extends Updatable {
+        getOrder(): number;
+    }
 }
 declare module spine {
-	class Event {
-		data: EventData;
-		intValue: number;
-		floatValue: number;
-		stringValue: string;
-		time: number;
-		volume: number;
-		balance: number;
-		constructor(time: number, data: EventData);
-	}
+    class Event {
+        data: EventData;
+        intValue: number;
+        floatValue: number;
+        stringValue: string;
+        time: number;
+        volume: number;
+        balance: number;
+        constructor(time: number, data: EventData);
+    }
 }
 declare module spine {
-	class EventData {
-		name: string;
-		intValue: number;
-		floatValue: number;
-		stringValue: string;
-		audioPath: string;
-		volume: number;
-		balance: number;
-		constructor(name: string);
-	}
+    class EventData {
+        name: string;
+        intValue: number;
+        floatValue: number;
+        stringValue: string;
+        audioPath: string;
+        volume: number;
+        balance: number;
+        constructor(name: string);
+    }
 }
 declare module spine {
-	class IkConstraint implements Constraint {
-		data: IkConstraintData;
-		bones: Array<Bone>;
-		target: Bone;
-		bendDirection: number;
-		compress: boolean;
-		stretch: boolean;
-		mix: number;
-		constructor(data: IkConstraintData, skeleton: Skeleton);
-		getOrder(): number;
-		apply(): void;
-		update(): void;
-		apply1(bone: Bone, targetX: number, targetY: number, compress: boolean, stretch: boolean, uniform: boolean, alpha: number): void;
-		apply2(parent: Bone, child: Bone, targetX: number, targetY: number, bendDir: number, stretch: boolean, alpha: number): void;
-	}
+    class IkConstraint implements Constraint {
+        data: IkConstraintData;
+        bones: Array<Bone>;
+        target: Bone;
+        bendDirection: number;
+        compress: boolean;
+        stretch: boolean;
+        mix: number;
+        constructor(data: IkConstraintData, skeleton: Skeleton);
+        getOrder(): number;
+        apply(): void;
+        update(): void;
+        apply1(bone: Bone, targetX: number, targetY: number, compress: boolean, stretch: boolean, uniform: boolean, alpha: number): void;
+        apply2(parent: Bone, child: Bone, targetX: number, targetY: number, bendDir: number, stretch: boolean, alpha: number): void;
+    }
 }
 declare module spine {
-	class IkConstraintData {
-		name: string;
-		order: number;
-		bones: BoneData[];
-		target: BoneData;
-		bendDirection: number;
-		compress: boolean;
-		stretch: boolean;
-		uniform: boolean;
-		mix: number;
-		constructor(name: string);
-	}
+    class IkConstraintData {
+        name: string;
+        order: number;
+        bones: BoneData[];
+        target: BoneData;
+        bendDirection: number;
+        compress: boolean;
+        stretch: boolean;
+        uniform: boolean;
+        mix: number;
+        constructor(name: string);
+    }
 }
 declare module spine {
-	class PathConstraint implements Constraint {
-		static NONE: number;
-		static BEFORE: number;
-		static AFTER: number;
-		static epsilon: number;
-		data: PathConstraintData;
-		bones: Array<Bone>;
-		target: Slot;
-		position: number;
-		spacing: number;
-		rotateMix: number;
-		translateMix: number;
-		spaces: number[];
-		positions: number[];
-		world: number[];
-		curves: number[];
-		lengths: number[];
-		segments: number[];
-		constructor(data: PathConstraintData, skeleton: Skeleton);
-		apply(): void;
-		update(): void;
-		computeWorldPositions(path: PathAttachment, spacesCount: number, tangents: boolean, percentPosition: boolean, percentSpacing: boolean): number[];
-		addBeforePosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
-		addAfterPosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
-		addCurvePosition(p: number, x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, out: Array<number>, o: number, tangents: boolean): void;
-		getOrder(): number;
-	}
+    class PathConstraint implements Constraint {
+        static NONE: number;
+        static BEFORE: number;
+        static AFTER: number;
+        static epsilon: number;
+        data: PathConstraintData;
+        bones: Array<Bone>;
+        target: Slot;
+        position: number;
+        spacing: number;
+        rotateMix: number;
+        translateMix: number;
+        spaces: number[];
+        positions: number[];
+        world: number[];
+        curves: number[];
+        lengths: number[];
+        segments: number[];
+        constructor(data: PathConstraintData, skeleton: Skeleton);
+        apply(): void;
+        update(): void;
+        computeWorldPositions(path: PathAttachment, spacesCount: number, tangents: boolean, percentPosition: boolean, percentSpacing: boolean): number[];
+        addBeforePosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
+        addAfterPosition(p: number, temp: Array<number>, i: number, out: Array<number>, o: number): void;
+        addCurvePosition(p: number, x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, out: Array<number>, o: number, tangents: boolean): void;
+        getOrder(): number;
+    }
 }
 declare module spine {
-	class PathConstraintData {
-		name: string;
-		order: number;
-		bones: BoneData[];
-		target: SlotData;
-		positionMode: PositionMode;
-		spacingMode: SpacingMode;
-		rotateMode: RotateMode;
-		offsetRotation: number;
-		position: number;
-		spacing: number;
-		rotateMix: number;
-		translateMix: number;
-		constructor(name: string);
-	}
-	enum PositionMode {
-		Fixed = 0,
-		Percent = 1
-	}
-	enum SpacingMode {
-		Length = 0,
-		Fixed = 1,
-		Percent = 2
-	}
-	enum RotateMode {
-		Tangent = 0,
-		Chain = 1,
-		ChainScale = 2
-	}
+    class PathConstraintData {
+        name: string;
+        order: number;
+        bones: BoneData[];
+        target: SlotData;
+        positionMode: PositionMode;
+        spacingMode: SpacingMode;
+        rotateMode: RotateMode;
+        offsetRotation: number;
+        position: number;
+        spacing: number;
+        rotateMix: number;
+        translateMix: number;
+        constructor(name: string);
+    }
+    enum PositionMode {
+        Fixed = 0,
+        Percent = 1,
+    }
+    enum SpacingMode {
+        Length = 0,
+        Fixed = 1,
+        Percent = 2,
+    }
+    enum RotateMode {
+        Tangent = 0,
+        Chain = 1,
+        ChainScale = 2,
+    }
 }
 declare module spine {
-	class SharedAssetManager implements Disposable {
-		private pathPrefix;
-		private clientAssets;
-		private queuedAssets;
-		private rawAssets;
-		private errors;
-		constructor(pathPrefix?: string);
-		private queueAsset;
-		loadText(clientId: string, path: string): void;
-		loadJson(clientId: string, path: string): void;
-		loadTexture(clientId: string, textureLoader: (image: HTMLImageElement) => any, path: string): void;
-		get(clientId: string, path: string): any;
-		private updateClientAssets;
-		isLoadingComplete(clientId: string): boolean;
-		dispose(): void;
-		hasErrors(): boolean;
-		getErrors(): Map<string>;
-	}
+    class SharedAssetManager implements Disposable {
+        private pathPrefix;
+        private clientAssets;
+        private queuedAssets;
+        private rawAssets;
+        private errors;
+        constructor(pathPrefix?: string);
+        private queueAsset(clientId, textureLoader, path);
+        loadText(clientId: string, path: string): void;
+        loadJson(clientId: string, path: string): void;
+        loadTexture(clientId: string, textureLoader: (image: HTMLImageElement) => any, path: string): void;
+        get(clientId: string, path: string): any;
+        private updateClientAssets(clientAssets);
+        isLoadingComplete(clientId: string): boolean;
+        dispose(): void;
+        hasErrors(): boolean;
+        getErrors(): Map<string>;
+    }
 }
 declare module spine {
-	class Skeleton {
-		data: SkeletonData;
-		bones: Array<Bone>;
-		slots: Array<Slot>;
-		drawOrder: Array<Slot>;
-		ikConstraints: Array<IkConstraint>;
-		transformConstraints: Array<TransformConstraint>;
-		pathConstraints: Array<PathConstraint>;
-		_updateCache: Updatable[];
-		updateCacheReset: Updatable[];
-		skin: Skin;
-		color: Color;
-		time: number;
-		scaleX: number;
-		scaleY: number;
-		x: number;
-		y: number;
-		constructor(data: SkeletonData);
-		updateCache(): void;
-		sortIkConstraint(constraint: IkConstraint): void;
-		sortPathConstraint(constraint: PathConstraint): void;
-		sortTransformConstraint(constraint: TransformConstraint): void;
-		sortPathConstraintAttachment(skin: Skin, slotIndex: number, slotBone: Bone): void;
-		sortPathConstraintAttachmentWith(attachment: Attachment, slotBone: Bone): void;
-		sortBone(bone: Bone): void;
-		sortReset(bones: Array<Bone>): void;
-		updateWorldTransform(): void;
-		setToSetupPose(): void;
-		setBonesToSetupPose(): void;
-		setSlotsToSetupPose(): void;
-		getRootBone(): Bone;
-		findBone(boneName: string): Bone;
-		findBoneIndex(boneName: string): number;
-		findSlot(slotName: string): Slot;
-		findSlotIndex(slotName: string): number;
-		setSkinByName(skinName: string): void;
-		setSkin(newSkin: Skin): void;
-		getAttachmentByName(slotName: string, attachmentName: string): Attachment;
-		getAttachment(slotIndex: number, attachmentName: string): Attachment;
-		setAttachment(slotName: string, attachmentName: string): void;
-		findIkConstraint(constraintName: string): IkConstraint;
-		findTransformConstraint(constraintName: string): TransformConstraint;
-		findPathConstraint(constraintName: string): PathConstraint;
-		getBounds(offset: Vector2, size: Vector2, temp?: Array<number>): void;
-		update(delta: number): void;
-	}
+    class Skeleton {
+        data: SkeletonData;
+        bones: Array<Bone>;
+        slots: Array<Slot>;
+        drawOrder: Array<Slot>;
+        ikConstraints: Array<IkConstraint>;
+        transformConstraints: Array<TransformConstraint>;
+        pathConstraints: Array<PathConstraint>;
+        _updateCache: Updatable[];
+        updateCacheReset: Updatable[];
+        skin: Skin;
+        color: Color;
+        time: number;
+        scaleX: number;
+        scaleY: number;
+        x: number;
+        y: number;
+        constructor(data: SkeletonData);
+        updateCache(): void;
+        sortIkConstraint(constraint: IkConstraint): void;
+        sortPathConstraint(constraint: PathConstraint): void;
+        sortTransformConstraint(constraint: TransformConstraint): void;
+        sortPathConstraintAttachment(skin: Skin, slotIndex: number, slotBone: Bone): void;
+        sortPathConstraintAttachmentWith(attachment: Attachment, slotBone: Bone): void;
+        sortBone(bone: Bone): void;
+        sortReset(bones: Array<Bone>): void;
+        updateWorldTransform(): void;
+        setToSetupPose(): void;
+        setBonesToSetupPose(): void;
+        setSlotsToSetupPose(): void;
+        getRootBone(): Bone;
+        findBone(boneName: string): Bone;
+        findBoneIndex(boneName: string): number;
+        findSlot(slotName: string): Slot;
+        findSlotIndex(slotName: string): number;
+        setSkinByName(skinName: string): void;
+        setSkin(newSkin: Skin): void;
+        getAttachmentByName(slotName: string, attachmentName: string): Attachment;
+        getAttachment(slotIndex: number, attachmentName: string): Attachment;
+        setAttachment(slotName: string, attachmentName: string): void;
+        findIkConstraint(constraintName: string): IkConstraint;
+        findTransformConstraint(constraintName: string): TransformConstraint;
+        findPathConstraint(constraintName: string): PathConstraint;
+        getBounds(offset: Vector2, size: Vector2, temp?: Array<number>): void;
+        update(delta: number): void;
+    }
 }
 declare module spine {
-	class SkeletonBounds {
-		minX: number;
-		minY: number;
-		maxX: number;
-		maxY: number;
-		boundingBoxes: BoundingBoxAttachment[];
-		polygons: ArrayLike<number>[];
-		private polygonPool;
-		update(skeleton: Skeleton, updateAabb: boolean): void;
-		aabbCompute(): void;
-		aabbContainsPoint(x: number, y: number): boolean;
-		aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number): boolean;
-		aabbIntersectsSkeleton(bounds: SkeletonBounds): boolean;
-		containsPoint(x: number, y: number): BoundingBoxAttachment;
-		containsPointPolygon(polygon: ArrayLike<number>, x: number, y: number): boolean;
-		intersectsSegment(x1: number, y1: number, x2: number, y2: number): BoundingBoxAttachment;
-		intersectsSegmentPolygon(polygon: ArrayLike<number>, x1: number, y1: number, x2: number, y2: number): boolean;
-		getPolygon(boundingBox: BoundingBoxAttachment): ArrayLike<number>;
-		getWidth(): number;
-		getHeight(): number;
-	}
+    class SkeletonBounds {
+        minX: number;
+        minY: number;
+        maxX: number;
+        maxY: number;
+        boundingBoxes: BoundingBoxAttachment[];
+        polygons: ArrayLike<number>[];
+        private polygonPool;
+        update(skeleton: Skeleton, updateAabb: boolean): void;
+        aabbCompute(): void;
+        aabbContainsPoint(x: number, y: number): boolean;
+        aabbIntersectsSegment(x1: number, y1: number, x2: number, y2: number): boolean;
+        aabbIntersectsSkeleton(bounds: SkeletonBounds): boolean;
+        containsPoint(x: number, y: number): BoundingBoxAttachment;
+        containsPointPolygon(polygon: ArrayLike<number>, x: number, y: number): boolean;
+        intersectsSegment(x1: number, y1: number, x2: number, y2: number): BoundingBoxAttachment;
+        intersectsSegmentPolygon(polygon: ArrayLike<number>, x1: number, y1: number, x2: number, y2: number): boolean;
+        getPolygon(boundingBox: BoundingBoxAttachment): ArrayLike<number>;
+        getWidth(): number;
+        getHeight(): number;
+    }
 }
 declare module spine {
-	class SkeletonClipping {
-		private triangulator;
-		private clippingPolygon;
-		private clipOutput;
-		clippedVertices: number[];
-		clippedTriangles: number[];
-		private scratch;
-		private clipAttachment;
-		private clippingPolygons;
-		clipStart(slot: Slot, clip: ClippingAttachment): number;
-		clipEndWithSlot(slot: Slot): void;
-		clipEnd(): void;
-		isClipping(): boolean;
-		clipTriangles(vertices: ArrayLike<number>, verticesLength: number, triangles: ArrayLike<number>, trianglesLength: number, uvs: ArrayLike<number>, light: Color, dark: Color, twoColor: boolean): void;
-		clip(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, clippingArea: Array<number>, output: Array<number>): boolean;
-		static makeClockwise(polygon: ArrayLike<number>): void;
-	}
+    class SkeletonClipping {
+        private triangulator;
+        private clippingPolygon;
+        private clipOutput;
+        clippedVertices: number[];
+        clippedTriangles: number[];
+        private scratch;
+        private clipAttachment;
+        private clippingPolygons;
+        clipStart(slot: Slot, clip: ClippingAttachment): number;
+        clipEndWithSlot(slot: Slot): void;
+        clipEnd(): void;
+        isClipping(): boolean;
+        clipTriangles(vertices: ArrayLike<number>, verticesLength: number, triangles: ArrayLike<number>, trianglesLength: number, uvs: ArrayLike<number>, light: Color, dark: Color, twoColor: boolean): void;
+        clip(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, clippingArea: Array<number>, output: Array<number>): boolean;
+        static makeClockwise(polygon: ArrayLike<number>): void;
+    }
 }
 declare module spine {
-	class SkeletonData {
-		name: string;
-		bones: BoneData[];
-		slots: SlotData[];
-		skins: Skin[];
-		defaultSkin: Skin;
-		events: EventData[];
-		animations: Animation[];
-		ikConstraints: IkConstraintData[];
-		transformConstraints: TransformConstraintData[];
-		pathConstraints: PathConstraintData[];
-		width: number;
-		height: number;
-		version: string;
-		hash: string;
-		fps: number;
-		imagesPath: string;
-		findBone(boneName: string): BoneData;
-		findBoneIndex(boneName: string): number;
-		findSlot(slotName: string): SlotData;
-		findSlotIndex(slotName: string): number;
-		findSkin(skinName: string): Skin;
-		findEvent(eventDataName: string): EventData;
-		findAnimation(animationName: string): Animation;
-		findIkConstraint(constraintName: string): IkConstraintData;
-		findTransformConstraint(constraintName: string): TransformConstraintData;
-		findPathConstraint(constraintName: string): PathConstraintData;
-		findPathConstraintIndex(pathConstraintName: string): number;
-	}
+    class SkeletonData {
+        name: string;
+        bones: BoneData[];
+        slots: SlotData[];
+        skins: Skin[];
+        defaultSkin: Skin;
+        events: EventData[];
+        animations: Animation[];
+        ikConstraints: IkConstraintData[];
+        transformConstraints: TransformConstraintData[];
+        pathConstraints: PathConstraintData[];
+        width: number;
+        height: number;
+        version: string;
+        hash: string;
+        fps: number;
+        imagesPath: string;
+        findBone(boneName: string): BoneData;
+        findBoneIndex(boneName: string): number;
+        findSlot(slotName: string): SlotData;
+        findSlotIndex(slotName: string): number;
+        findSkin(skinName: string): Skin;
+        findEvent(eventDataName: string): EventData;
+        findAnimation(animationName: string): Animation;
+        findIkConstraint(constraintName: string): IkConstraintData;
+        findTransformConstraint(constraintName: string): TransformConstraintData;
+        findPathConstraint(constraintName: string): PathConstraintData;
+        findPathConstraintIndex(pathConstraintName: string): number;
+    }
 }
 declare module spine {
-	class SkeletonJson {
-		attachmentLoader: AttachmentLoader;
-		scale: number;
-		private linkedMeshes;
-		constructor(attachmentLoader: AttachmentLoader);
-		readSkeletonData(json: string | any): SkeletonData;
-		readAttachment(map: any, skin: Skin, slotIndex: number, name: string, skeletonData: SkeletonData): Attachment;
-		readVertices(map: any, attachment: VertexAttachment, verticesLength: number): void;
-		readAnimation(map: any, name: string, skeletonData: SkeletonData): void;
-		readCurve(map: any, timeline: CurveTimeline, frameIndex: number): void;
-		getValue(map: any, prop: string, defaultValue: any): any;
-		static blendModeFromString(str: string): BlendMode;
-		static positionModeFromString(str: string): PositionMode;
-		static spacingModeFromString(str: string): SpacingMode;
-		static rotateModeFromString(str: string): RotateMode;
-		static transformModeFromString(str: string): TransformMode;
-	}
+    class SkeletonJson {
+        attachmentLoader: AttachmentLoader;
+        scale: number;
+        private linkedMeshes;
+        constructor(attachmentLoader: AttachmentLoader);
+        readSkeletonData(json: string | any): SkeletonData;
+        readAttachment(map: any, skin: Skin, slotIndex: number, name: string, skeletonData: SkeletonData): Attachment;
+        readVertices(map: any, attachment: VertexAttachment, verticesLength: number): void;
+        readAnimation(map: any, name: string, skeletonData: SkeletonData): void;
+        readCurve(map: any, timeline: CurveTimeline, frameIndex: number): void;
+        getValue(map: any, prop: string, defaultValue: any): any;
+        static blendModeFromString(str: string): BlendMode;
+        static positionModeFromString(str: string): PositionMode;
+        static spacingModeFromString(str: string): SpacingMode;
+        static rotateModeFromString(str: string): RotateMode;
+        static transformModeFromString(str: string): TransformMode;
+    }
 }
 declare module spine {
-	class Skin {
-		name: string;
-		attachments: Map<Attachment>[];
-		constructor(name: string);
-		addAttachment(slotIndex: number, name: string, attachment: Attachment): void;
-		getAttachment(slotIndex: number, name: string): Attachment;
-		attachAll(skeleton: Skeleton, oldSkin: Skin): void;
-	}
+    class Skin {
+        name: string;
+        attachments: Map<Attachment>[];
+        constructor(name: string);
+        addAttachment(slotIndex: number, name: string, attachment: Attachment): void;
+        getAttachment(slotIndex: number, name: string): Attachment;
+        attachAll(skeleton: Skeleton, oldSkin: Skin): void;
+    }
 }
 declare module spine {
-	class Slot {
-		data: SlotData;
-		bone: Bone;
-		color: Color;
-		darkColor: Color;
-		private attachment;
-		private attachmentTime;
-		attachmentVertices: number[];
-		constructor(data: SlotData, bone: Bone);
-		getAttachment(): Attachment;
-		setAttachment(attachment: Attachment): void;
-		setAttachmentTime(time: number): void;
-		getAttachmentTime(): number;
-		setToSetupPose(): void;
-	}
+    class Slot {
+        data: SlotData;
+        bone: Bone;
+        color: Color;
+        darkColor: Color;
+        private attachment;
+        private attachmentTime;
+        attachmentVertices: number[];
+        constructor(data: SlotData, bone: Bone);
+        getAttachment(): Attachment;
+        setAttachment(attachment: Attachment): void;
+        setAttachmentTime(time: number): void;
+        getAttachmentTime(): number;
+        setToSetupPose(): void;
+    }
 }
 declare module spine {
-	class SlotData {
-		index: number;
-		name: string;
-		boneData: BoneData;
-		color: Color;
-		darkColor: Color;
-		attachmentName: string;
-		blendMode: BlendMode;
-		constructor(index: number, name: string, boneData: BoneData);
-	}
+    class SlotData {
+        index: number;
+        name: string;
+        boneData: BoneData;
+        color: Color;
+        darkColor: Color;
+        attachmentName: string;
+        blendMode: BlendMode;
+        constructor(index: number, name: string, boneData: BoneData);
+    }
 }
 declare module spine {
-	abstract class Texture {
-		protected _image: HTMLImageElement;
-		constructor(image: HTMLImageElement);
-		getImage(): HTMLImageElement;
-		abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
-		abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
-		abstract dispose(): void;
-		static filterFromString(text: string): TextureFilter;
-		static wrapFromString(text: string): TextureWrap;
-	}
-	enum TextureFilter {
-		Nearest = 9728,
-		Linear = 9729,
-		MipMap = 9987,
-		MipMapNearestNearest = 9984,
-		MipMapLinearNearest = 9985,
-		MipMapNearestLinear = 9986,
-		MipMapLinearLinear = 9987
-	}
-	enum TextureWrap {
-		MirroredRepeat = 33648,
-		ClampToEdge = 33071,
-		Repeat = 10497
-	}
-	class TextureRegion {
-		renderObject: any;
-		u: number;
-		v: number;
-		u2: number;
-		v2: number;
-		width: number;
-		height: number;
-		rotate: boolean;
-		offsetX: number;
-		offsetY: number;
-		originalWidth: number;
-		originalHeight: number;
-	}
-	class FakeTexture extends spine.Texture {
-		setFilters(minFilter: spine.TextureFilter, magFilter: spine.TextureFilter): void;
-		setWraps(uWrap: spine.TextureWrap, vWrap: spine.TextureWrap): void;
-		dispose(): void;
-	}
+    abstract class Texture {
+        protected _image: HTMLImageElement;
+        constructor(image: HTMLImageElement);
+        getImage(): HTMLImageElement;
+        abstract setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
+        abstract setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
+        abstract dispose(): void;
+        static filterFromString(text: string): TextureFilter;
+        static wrapFromString(text: string): TextureWrap;
+    }
+    enum TextureFilter {
+        Nearest = 9728,
+        Linear = 9729,
+        MipMap = 9987,
+        MipMapNearestNearest = 9984,
+        MipMapLinearNearest = 9985,
+        MipMapNearestLinear = 9986,
+        MipMapLinearLinear = 9987,
+    }
+    enum TextureWrap {
+        MirroredRepeat = 33648,
+        ClampToEdge = 33071,
+        Repeat = 10497,
+    }
+    class TextureRegion {
+        renderObject: any;
+        u: number;
+        v: number;
+        u2: number;
+        v2: number;
+        width: number;
+        height: number;
+        rotate: boolean;
+        offsetX: number;
+        offsetY: number;
+        originalWidth: number;
+        originalHeight: number;
+    }
+    class FakeTexture extends spine.Texture {
+        setFilters(minFilter: spine.TextureFilter, magFilter: spine.TextureFilter): void;
+        setWraps(uWrap: spine.TextureWrap, vWrap: spine.TextureWrap): void;
+        dispose(): void;
+    }
 }
 declare module spine {
-	class TextureAtlas implements Disposable {
-		pages: TextureAtlasPage[];
-		regions: TextureAtlasRegion[];
-		constructor(atlasText: string, textureLoader: (path: string) => any);
-		private load;
-		findRegion(name: string): TextureAtlasRegion;
-		dispose(): void;
-	}
-	class TextureAtlasPage {
-		name: string;
-		minFilter: TextureFilter;
-		magFilter: TextureFilter;
-		uWrap: TextureWrap;
-		vWrap: TextureWrap;
-		texture: Texture;
-		width: number;
-		height: number;
-	}
-	class TextureAtlasRegion extends TextureRegion {
-		page: TextureAtlasPage;
-		name: string;
-		x: number;
-		y: number;
-		index: number;
-		rotate: boolean;
-		texture: Texture;
-	}
+    class TextureAtlas implements Disposable {
+        pages: TextureAtlasPage[];
+        regions: TextureAtlasRegion[];
+        constructor(atlasText: string, textureLoader: (path: string) => any);
+        private load(atlasText, textureLoader);
+        findRegion(name: string): TextureAtlasRegion;
+        dispose(): void;
+    }
+    class TextureAtlasPage {
+        name: string;
+        minFilter: TextureFilter;
+        magFilter: TextureFilter;
+        uWrap: TextureWrap;
+        vWrap: TextureWrap;
+        texture: Texture;
+        width: number;
+        height: number;
+    }
+    class TextureAtlasRegion extends TextureRegion {
+        page: TextureAtlasPage;
+        name: string;
+        x: number;
+        y: number;
+        index: number;
+        rotate: boolean;
+        texture: Texture;
+    }
 }
 declare module spine {
-	class TransformConstraint implements Constraint {
-		data: TransformConstraintData;
-		bones: Array<Bone>;
-		target: Bone;
-		rotateMix: number;
-		translateMix: number;
-		scaleMix: number;
-		shearMix: number;
-		temp: Vector2;
-		constructor(data: TransformConstraintData, skeleton: Skeleton);
-		apply(): void;
-		update(): void;
-		applyAbsoluteWorld(): void;
-		applyRelativeWorld(): void;
-		applyAbsoluteLocal(): void;
-		applyRelativeLocal(): void;
-		getOrder(): number;
-	}
+    class TransformConstraint implements Constraint {
+        data: TransformConstraintData;
+        bones: Array<Bone>;
+        target: Bone;
+        rotateMix: number;
+        translateMix: number;
+        scaleMix: number;
+        shearMix: number;
+        temp: Vector2;
+        constructor(data: TransformConstraintData, skeleton: Skeleton);
+        apply(): void;
+        update(): void;
+        applyAbsoluteWorld(): void;
+        applyRelativeWorld(): void;
+        applyAbsoluteLocal(): void;
+        applyRelativeLocal(): void;
+        getOrder(): number;
+    }
 }
 declare module spine {
-	class TransformConstraintData {
-		name: string;
-		order: number;
-		bones: BoneData[];
-		target: BoneData;
-		rotateMix: number;
-		translateMix: number;
-		scaleMix: number;
-		shearMix: number;
-		offsetRotation: number;
-		offsetX: number;
-		offsetY: number;
-		offsetScaleX: number;
-		offsetScaleY: number;
-		offsetShearY: number;
-		relative: boolean;
-		local: boolean;
-		constructor(name: string);
-	}
+    class TransformConstraintData {
+        name: string;
+        order: number;
+        bones: BoneData[];
+        target: BoneData;
+        rotateMix: number;
+        translateMix: number;
+        scaleMix: number;
+        shearMix: number;
+        offsetRotation: number;
+        offsetX: number;
+        offsetY: number;
+        offsetScaleX: number;
+        offsetScaleY: number;
+        offsetShearY: number;
+        relative: boolean;
+        local: boolean;
+        constructor(name: string);
+    }
 }
 declare module spine {
-	class Triangulator {
-		private convexPolygons;
-		private convexPolygonsIndices;
-		private indicesArray;
-		private isConcaveArray;
-		private triangles;
-		private polygonPool;
-		private polygonIndicesPool;
-		triangulate(verticesArray: ArrayLike<number>): Array<number>;
-		decompose(verticesArray: Array<number>, triangles: Array<number>): Array<Array<number>>;
-		private static isConcave;
-		private static positiveArea;
-		private static winding;
-	}
+    class Triangulator {
+        private convexPolygons;
+        private convexPolygonsIndices;
+        private indicesArray;
+        private isConcaveArray;
+        private triangles;
+        private polygonPool;
+        private polygonIndicesPool;
+        triangulate(verticesArray: ArrayLike<number>): Array<number>;
+        decompose(verticesArray: Array<number>, triangles: Array<number>): Array<Array<number>>;
+        private static isConcave(index, vertexCount, vertices, indices);
+        private static positiveArea(p1x, p1y, p2x, p2y, p3x, p3y);
+        private static winding(p1x, p1y, p2x, p2y, p3x, p3y);
+    }
 }
 declare module spine {
-	interface Updatable {
-		update(): void;
-	}
+    interface Updatable {
+        update(): void;
+    }
 }
 declare module spine {
-	interface Map<T> {
-		[key: string]: T;
-	}
-	class IntSet {
-		array: number[];
-		add(value: number): boolean;
-		contains(value: number): boolean;
-		remove(value: number): void;
-		clear(): void;
-	}
-	interface Disposable {
-		dispose(): void;
-	}
-	interface Restorable {
-		restore(): void;
-	}
-	class Color {
-		r: number;
-		g: number;
-		b: number;
-		a: number;
-		static WHITE: Color;
-		static RED: Color;
-		static GREEN: Color;
-		static BLUE: Color;
-		static MAGENTA: Color;
-		constructor(r?: number, g?: number, b?: number, a?: number);
-		set(r: number, g: number, b: number, a: number): this;
-		setFromColor(c: Color): this;
-		setFromString(hex: string): this;
-		add(r: number, g: number, b: number, a: number): this;
-		clamp(): this;
-	}
-	class MathUtils {
-		static PI: number;
-		static PI2: number;
-		static radiansToDegrees: number;
-		static radDeg: number;
-		static degreesToRadians: number;
-		static degRad: number;
-		static clamp(value: number, min: number, max: number): number;
-		static cosDeg(degrees: number): number;
-		static sinDeg(degrees: number): number;
-		static signum(value: number): number;
-		static toInt(x: number): number;
-		static cbrt(x: number): number;
-		static randomTriangular(min: number, max: number): number;
-		static randomTriangularWith(min: number, max: number, mode: number): number;
-	}
-	abstract class Interpolation {
-		protected abstract applyInternal(a: number): number;
-		apply(start: number, end: number, a: number): number;
-	}
-	class Pow extends Interpolation {
-		protected power: number;
-		constructor(power: number);
-		applyInternal(a: number): number;
-	}
-	class PowOut extends Pow {
-		constructor(power: number);
-		applyInternal(a: number): number;
-	}
-	class Utils {
-		static SUPPORTS_TYPED_ARRAYS: boolean;
-		static arrayCopy<T>(source: ArrayLike<T>, sourceStart: number, dest: ArrayLike<T>, destStart: number, numElements: number): void;
-		static setArraySize<T>(array: Array<T>, size: number, value?: any): Array<T>;
-		static ensureArrayCapacity<T>(array: Array<T>, size: number, value?: any): Array<T>;
-		static newArray<T>(size: number, defaultValue: T): Array<T>;
-		static newFloatArray(size: number): ArrayLike<number>;
-		static newShortArray(size: number): ArrayLike<number>;
-		static toFloatArray(array: Array<number>): number[] | Float32Array;
-		static toSinglePrecision(value: number): number;
-		static webkit602BugfixHelper(alpha: number, blend: MixBlend): void;
-	}
-	class DebugUtils {
-		static logBones(skeleton: Skeleton): void;
-	}
-	class Pool<T> {
-		private items;
-		private instantiator;
-		constructor(instantiator: () => T);
-		obtain(): T;
-		free(item: T): void;
-		freeAll(items: ArrayLike<T>): void;
-		clear(): void;
-	}
-	class Vector2 {
-		x: number;
-		y: number;
-		constructor(x?: number, y?: number);
-		set(x: number, y: number): Vector2;
-		length(): number;
-		normalize(): this;
-	}
-	class TimeKeeper {
-		maxDelta: number;
-		framesPerSecond: number;
-		delta: number;
-		totalTime: number;
-		private lastTime;
-		private frameCount;
-		private frameTime;
-		update(): void;
-	}
-	interface ArrayLike<T> {
-		length: number;
-		[n: number]: T;
-	}
-	class WindowedMean {
-		values: Array<number>;
-		addedValues: number;
-		lastValue: number;
-		mean: number;
-		dirty: boolean;
-		constructor(windowSize?: number);
-		hasEnoughData(): boolean;
-		addValue(value: number): void;
-		getMean(): number;
-	}
+    interface Map<T> {
+        [key: string]: T;
+    }
+    class IntSet {
+        array: number[];
+        add(value: number): boolean;
+        contains(value: number): boolean;
+        remove(value: number): void;
+        clear(): void;
+    }
+    interface Disposable {
+        dispose(): void;
+    }
+    interface Restorable {
+        restore(): void;
+    }
+    class Color {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+        static WHITE: Color;
+        static RED: Color;
+        static GREEN: Color;
+        static BLUE: Color;
+        static MAGENTA: Color;
+        constructor(r?: number, g?: number, b?: number, a?: number);
+        set(r: number, g: number, b: number, a: number): this;
+        setFromColor(c: Color): this;
+        setFromString(hex: string): this;
+        add(r: number, g: number, b: number, a: number): this;
+        clamp(): this;
+    }
+    class MathUtils {
+        static PI: number;
+        static PI2: number;
+        static radiansToDegrees: number;
+        static radDeg: number;
+        static degreesToRadians: number;
+        static degRad: number;
+        static clamp(value: number, min: number, max: number): number;
+        static cosDeg(degrees: number): number;
+        static sinDeg(degrees: number): number;
+        static signum(value: number): number;
+        static toInt(x: number): number;
+        static cbrt(x: number): number;
+        static randomTriangular(min: number, max: number): number;
+        static randomTriangularWith(min: number, max: number, mode: number): number;
+    }
+    abstract class Interpolation {
+        protected abstract applyInternal(a: number): number;
+        apply(start: number, end: number, a: number): number;
+    }
+    class Pow extends Interpolation {
+        protected power: number;
+        constructor(power: number);
+        applyInternal(a: number): number;
+    }
+    class PowOut extends Pow {
+        constructor(power: number);
+        applyInternal(a: number): number;
+    }
+    class Utils {
+        static SUPPORTS_TYPED_ARRAYS: boolean;
+        static arrayCopy<T>(source: ArrayLike<T>, sourceStart: number, dest: ArrayLike<T>, destStart: number, numElements: number): void;
+        static setArraySize<T>(array: Array<T>, size: number, value?: any): Array<T>;
+        static ensureArrayCapacity<T>(array: Array<T>, size: number, value?: any): Array<T>;
+        static newArray<T>(size: number, defaultValue: T): Array<T>;
+        static newFloatArray(size: number): ArrayLike<number>;
+        static newShortArray(size: number): ArrayLike<number>;
+        static toFloatArray(array: Array<number>): number[] | Float32Array;
+        static toSinglePrecision(value: number): number;
+        static webkit602BugfixHelper(alpha: number, blend: MixBlend): void;
+    }
+    class DebugUtils {
+        static logBones(skeleton: Skeleton): void;
+    }
+    class Pool<T> {
+        private items;
+        private instantiator;
+        constructor(instantiator: () => T);
+        obtain(): T;
+        free(item: T): void;
+        freeAll(items: ArrayLike<T>): void;
+        clear(): void;
+    }
+    class Vector2 {
+        x: number;
+        y: number;
+        constructor(x?: number, y?: number);
+        set(x: number, y: number): Vector2;
+        length(): number;
+        normalize(): this;
+    }
+    class TimeKeeper {
+        maxDelta: number;
+        framesPerSecond: number;
+        delta: number;
+        totalTime: number;
+        private lastTime;
+        private frameCount;
+        private frameTime;
+        update(): void;
+    }
+    interface ArrayLike<T> {
+        length: number;
+        [n: number]: T;
+    }
+    class WindowedMean {
+        values: Array<number>;
+        addedValues: number;
+        lastValue: number;
+        mean: number;
+        dirty: boolean;
+        constructor(windowSize?: number);
+        hasEnoughData(): boolean;
+        addValue(value: number): void;
+        getMean(): number;
+    }
 }
 declare module spine {
-	interface VertexEffect {
-		begin(skeleton: Skeleton): void;
-		transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
-		end(): void;
-	}
+    interface VertexEffect {
+        begin(skeleton: Skeleton): void;
+        transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
+        end(): void;
+    }
 }
 interface Math {
-	fround(n: number): number;
+    fround(n: number): number;
 }
 declare module spine {
-	abstract class Attachment {
-		name: string;
-		constructor(name: string);
-	}
-	abstract class VertexAttachment extends Attachment {
-		private static nextID;
-		id: number;
-		bones: Array<number>;
-		vertices: ArrayLike<number>;
-		worldVerticesLength: number;
-		constructor(name: string);
-		computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
-		applyDeform(sourceAttachment: VertexAttachment): boolean;
-	}
+    abstract class Attachment {
+        name: string;
+        constructor(name: string);
+    }
+    abstract class VertexAttachment extends Attachment {
+        private static nextID;
+        id: number;
+        bones: Array<number>;
+        vertices: ArrayLike<number>;
+        worldVerticesLength: number;
+        constructor(name: string);
+        computeWorldVertices(slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
+        applyDeform(sourceAttachment: VertexAttachment): boolean;
+    }
 }
 declare module spine {
-	interface AttachmentLoader {
-		newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
-		newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
-		newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
-		newPathAttachment(skin: Skin, name: string): PathAttachment;
-		newPointAttachment(skin: Skin, name: string): PointAttachment;
-		newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
-	}
+    interface AttachmentLoader {
+        newRegionAttachment(skin: Skin, name: string, path: string): RegionAttachment;
+        newMeshAttachment(skin: Skin, name: string, path: string): MeshAttachment;
+        newBoundingBoxAttachment(skin: Skin, name: string): BoundingBoxAttachment;
+        newPathAttachment(skin: Skin, name: string): PathAttachment;
+        newPointAttachment(skin: Skin, name: string): PointAttachment;
+        newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
+    }
 }
 declare module spine {
-	enum AttachmentType {
-		Region = 0,
-		BoundingBox = 1,
-		Mesh = 2,
-		LinkedMesh = 3,
-		Path = 4,
-		Point = 5
-	}
+    enum AttachmentType {
+        Region = 0,
+        BoundingBox = 1,
+        Mesh = 2,
+        LinkedMesh = 3,
+        Path = 4,
+        Point = 5,
+    }
 }
 declare module spine {
-	class BoundingBoxAttachment extends VertexAttachment {
-		color: Color;
-		constructor(name: string);
-	}
+    class BoundingBoxAttachment extends VertexAttachment {
+        color: Color;
+        constructor(name: string);
+    }
 }
 declare module spine {
-	class ClippingAttachment extends VertexAttachment {
-		endSlot: SlotData;
-		color: Color;
-		constructor(name: string);
-	}
+    class ClippingAttachment extends VertexAttachment {
+        endSlot: SlotData;
+        color: Color;
+        constructor(name: string);
+    }
 }
 declare module spine {
-	class MeshAttachment extends VertexAttachment {
-		region: TextureRegion;
-		path: string;
-		regionUVs: ArrayLike<number>;
-		uvs: ArrayLike<number>;
-		triangles: Array<number>;
-		color: Color;
-		hullLength: number;
-		private parentMesh;
-		inheritDeform: boolean;
-		tempColor: Color;
-		constructor(name: string);
-		updateUVs(): void;
-		applyDeform(sourceAttachment: VertexAttachment): boolean;
-		getParentMesh(): MeshAttachment;
-		setParentMesh(parentMesh: MeshAttachment): void;
-	}
+    class MeshAttachment extends VertexAttachment {
+        region: TextureRegion;
+        path: string;
+        regionUVs: ArrayLike<number>;
+        uvs: ArrayLike<number>;
+        triangles: Array<number>;
+        color: Color;
+        hullLength: number;
+        private parentMesh;
+        inheritDeform: boolean;
+        tempColor: Color;
+        constructor(name: string);
+        updateUVs(): void;
+        applyDeform(sourceAttachment: VertexAttachment): boolean;
+        getParentMesh(): MeshAttachment;
+        setParentMesh(parentMesh: MeshAttachment): void;
+    }
 }
 declare module spine {
-	class PathAttachment extends VertexAttachment {
-		lengths: Array<number>;
-		closed: boolean;
-		constantSpeed: boolean;
-		color: Color;
-		constructor(name: string);
-	}
+    class PathAttachment extends VertexAttachment {
+        lengths: Array<number>;
+        closed: boolean;
+        constantSpeed: boolean;
+        color: Color;
+        constructor(name: string);
+    }
 }
 declare module spine {
-	class PointAttachment extends VertexAttachment {
-		x: number;
-		y: number;
-		rotation: number;
-		color: Color;
-		constructor(name: string);
-		computeWorldPosition(bone: Bone, point: Vector2): Vector2;
-		computeWorldRotation(bone: Bone): number;
-	}
+    class PointAttachment extends VertexAttachment {
+        x: number;
+        y: number;
+        rotation: number;
+        color: Color;
+        constructor(name: string);
+        computeWorldPosition(bone: Bone, point: Vector2): Vector2;
+        computeWorldRotation(bone: Bone): number;
+    }
 }
 declare module spine {
-	class RegionAttachment extends Attachment {
-		static OX1: number;
-		static OY1: number;
-		static OX2: number;
-		static OY2: number;
-		static OX3: number;
-		static OY3: number;
-		static OX4: number;
-		static OY4: number;
-		static X1: number;
-		static Y1: number;
-		static C1R: number;
-		static C1G: number;
-		static C1B: number;
-		static C1A: number;
-		static U1: number;
-		static V1: number;
-		static X2: number;
-		static Y2: number;
-		static C2R: number;
-		static C2G: number;
-		static C2B: number;
-		static C2A: number;
-		static U2: number;
-		static V2: number;
-		static X3: number;
-		static Y3: number;
-		static C3R: number;
-		static C3G: number;
-		static C3B: number;
-		static C3A: number;
-		static U3: number;
-		static V3: number;
-		static X4: number;
-		static Y4: number;
-		static C4R: number;
-		static C4G: number;
-		static C4B: number;
-		static C4A: number;
-		static U4: number;
-		static V4: number;
-		x: number;
-		y: number;
-		scaleX: number;
-		scaleY: number;
-		rotation: number;
-		width: number;
-		height: number;
-		color: Color;
-		path: string;
-		rendererObject: any;
-		region: TextureRegion;
-		offset: ArrayLike<number>;
-		uvs: ArrayLike<number>;
-		tempColor: Color;
-		constructor(name: string);
-		updateOffset(): void;
-		setRegion(region: TextureRegion): void;
-		computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
-	}
+    class RegionAttachment extends Attachment {
+        static OX1: number;
+        static OY1: number;
+        static OX2: number;
+        static OY2: number;
+        static OX3: number;
+        static OY3: number;
+        static OX4: number;
+        static OY4: number;
+        static X1: number;
+        static Y1: number;
+        static C1R: number;
+        static C1G: number;
+        static C1B: number;
+        static C1A: number;
+        static U1: number;
+        static V1: number;
+        static X2: number;
+        static Y2: number;
+        static C2R: number;
+        static C2G: number;
+        static C2B: number;
+        static C2A: number;
+        static U2: number;
+        static V2: number;
+        static X3: number;
+        static Y3: number;
+        static C3R: number;
+        static C3G: number;
+        static C3B: number;
+        static C3A: number;
+        static U3: number;
+        static V3: number;
+        static X4: number;
+        static Y4: number;
+        static C4R: number;
+        static C4G: number;
+        static C4B: number;
+        static C4A: number;
+        static U4: number;
+        static V4: number;
+        x: number;
+        y: number;
+        scaleX: number;
+        scaleY: number;
+        rotation: number;
+        width: number;
+        height: number;
+        color: Color;
+        path: string;
+        rendererObject: any;
+        region: TextureRegion;
+        offset: ArrayLike<number>;
+        uvs: ArrayLike<number>;
+        tempColor: Color;
+        constructor(name: string);
+        updateOffset(): void;
+        setRegion(region: TextureRegion): void;
+        computeWorldVertices(bone: Bone, worldVertices: ArrayLike<number>, offset: number, stride: number): void;
+    }
 }
 declare module spine {
-	class JitterEffect implements VertexEffect {
-		jitterX: number;
-		jitterY: number;
-		constructor(jitterX: number, jitterY: number);
-		begin(skeleton: Skeleton): void;
-		transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
-		end(): void;
-	}
+    class JitterEffect implements VertexEffect {
+        jitterX: number;
+        jitterY: number;
+        constructor(jitterX: number, jitterY: number);
+        begin(skeleton: Skeleton): void;
+        transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
+        end(): void;
+    }
 }
 declare module spine {
-	class SwirlEffect implements VertexEffect {
-		static interpolation: PowOut;
-		centerX: number;
-		centerY: number;
-		radius: number;
-		angle: number;
-		private worldX;
-		private worldY;
-		constructor(radius: number);
-		begin(skeleton: Skeleton): void;
-		transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
-		end(): void;
-	}
+    class SwirlEffect implements VertexEffect {
+        static interpolation: PowOut;
+        centerX: number;
+        centerY: number;
+        radius: number;
+        angle: number;
+        private worldX;
+        private worldY;
+        constructor(radius: number);
+        begin(skeleton: Skeleton): void;
+        transform(position: Vector2, uv: Vector2, light: Color, dark: Color): void;
+        end(): void;
+    }
 }
 declare module spine.webgl {
-	class AssetManager extends spine.AssetManager {
-		constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, pathPrefix?: string);
-	}
+    class AssetManager extends spine.AssetManager {
+        constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, pathPrefix?: string);
+    }
 }
 declare module spine.webgl {
-	class OrthoCamera {
-		position: Vector3;
-		direction: Vector3;
-		up: Vector3;
-		near: number;
-		far: number;
-		zoom: number;
-		viewportWidth: number;
-		viewportHeight: number;
-		projectionView: Matrix4;
-		inverseProjectionView: Matrix4;
-		projection: Matrix4;
-		view: Matrix4;
-		private tmp;
-		constructor(viewportWidth: number, viewportHeight: number);
-		update(): void;
-		screenToWorld(screenCoords: Vector3, screenWidth: number, screenHeight: number): Vector3;
-		setViewport(viewportWidth: number, viewportHeight: number): void;
-	}
+    class OrthoCamera {
+        position: Vector3;
+        direction: Vector3;
+        up: Vector3;
+        near: number;
+        far: number;
+        zoom: number;
+        viewportWidth: number;
+        viewportHeight: number;
+        projectionView: Matrix4;
+        inverseProjectionView: Matrix4;
+        projection: Matrix4;
+        view: Matrix4;
+        private tmp;
+        constructor(viewportWidth: number, viewportHeight: number);
+        update(): void;
+        screenToWorld(screenCoords: Vector3, screenWidth: number, screenHeight: number): Vector3;
+        setViewport(viewportWidth: number, viewportHeight: number): void;
+    }
 }
 declare module spine.webgl {
-	class GLTexture extends Texture implements Disposable, Restorable {
-		private context;
-		private texture;
-		private boundUnit;
-		private useMipMaps;
-		constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, image: HTMLImageElement, useMipMaps?: boolean);
-		setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
-		setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
-		update(useMipMaps: boolean): void;
-		restore(): void;
-		bind(unit?: number): void;
-		unbind(): void;
-		dispose(): void;
-	}
+    class GLTexture extends Texture implements Disposable, Restorable {
+        private context;
+        private texture;
+        private boundUnit;
+        private useMipMaps;
+        constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, image: HTMLImageElement, useMipMaps?: boolean);
+        setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
+        setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
+        update(useMipMaps: boolean): void;
+        restore(): void;
+        bind(unit?: number): void;
+        unbind(): void;
+        dispose(): void;
+    }
 }
 declare module spine.webgl {
-	class Input {
-		element: HTMLElement;
-		lastX: number;
-		lastY: number;
-		buttonDown: boolean;
-		currTouch: Touch;
-		touchesPool: Pool<Touch>;
-		private listeners;
-		constructor(element: HTMLElement);
-		private setupCallbacks;
-		addListener(listener: InputListener): void;
-		removeListener(listener: InputListener): void;
-	}
-	class Touch {
-		identifier: number;
-		x: number;
-		y: number;
-		constructor(identifier: number, x: number, y: number);
-	}
-	interface InputListener {
-		down(x: number, y: number): void;
-		up(x: number, y: number): void;
-		moved(x: number, y: number): void;
-		dragged(x: number, y: number): void;
-	}
+    class Input {
+        element: HTMLElement;
+        lastX: number;
+        lastY: number;
+        buttonDown: boolean;
+        currTouch: Touch;
+        touchesPool: Pool<Touch>;
+        private listeners;
+        constructor(element: HTMLElement);
+        private setupCallbacks(element);
+        addListener(listener: InputListener): void;
+        removeListener(listener: InputListener): void;
+    }
+    class Touch {
+        identifier: number;
+        x: number;
+        y: number;
+        constructor(identifier: number, x: number, y: number);
+    }
+    interface InputListener {
+        down(x: number, y: number): void;
+        up(x: number, y: number): void;
+        moved(x: number, y: number): void;
+        dragged(x: number, y: number): void;
+    }
 }
 declare module spine.webgl {
-	class LoadingScreen {
-		static FADE_SECONDS: number;
-		private static loaded;
-		private static spinnerImg;
-		private static logoImg;
-		private renderer;
-		private logo;
-		private spinner;
-		private angle;
-		private fadeOut;
-		private timeKeeper;
-		backgroundColor: Color;
-		private tempColor;
-		private firstDraw;
-		private static SPINNER_DATA;
-		private static SPINE_LOGO_DATA;
-		constructor(renderer: SceneRenderer);
-		draw(complete?: boolean): void;
-	}
+    class LoadingScreen {
+        static FADE_SECONDS: number;
+        private static loaded;
+        private static spinnerImg;
+        private static logoImg;
+        private renderer;
+        private logo;
+        private spinner;
+        private angle;
+        private fadeOut;
+        private timeKeeper;
+        backgroundColor: Color;
+        private tempColor;
+        private firstDraw;
+        private static SPINNER_DATA;
+        private static SPINE_LOGO_DATA;
+        constructor(renderer: SceneRenderer);
+        draw(complete?: boolean): void;
+    }
 }
 declare module spine.webgl {
-	const M00 = 0;
-	const M01 = 4;
-	const M02 = 8;
-	const M03 = 12;
-	const M10 = 1;
-	const M11 = 5;
-	const M12 = 9;
-	const M13 = 13;
-	const M20 = 2;
-	const M21 = 6;
-	const M22 = 10;
-	const M23 = 14;
-	const M30 = 3;
-	const M31 = 7;
-	const M32 = 11;
-	const M33 = 15;
-	class Matrix4 {
-		temp: Float32Array;
-		values: Float32Array;
-		private static xAxis;
-		private static yAxis;
-		private static zAxis;
-		private static tmpMatrix;
-		constructor();
-		set(values: ArrayLike<number>): Matrix4;
-		transpose(): Matrix4;
-		identity(): Matrix4;
-		invert(): Matrix4;
-		determinant(): number;
-		translate(x: number, y: number, z: number): Matrix4;
-		copy(): Matrix4;
-		projection(near: number, far: number, fovy: number, aspectRatio: number): Matrix4;
-		ortho2d(x: number, y: number, width: number, height: number): Matrix4;
-		ortho(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4;
-		multiply(matrix: Matrix4): Matrix4;
-		multiplyLeft(matrix: Matrix4): Matrix4;
-		lookAt(position: Vector3, direction: Vector3, up: Vector3): this;
-		static initTemps(): void;
-	}
+    const M00 = 0;
+    const M01 = 4;
+    const M02 = 8;
+    const M03 = 12;
+    const M10 = 1;
+    const M11 = 5;
+    const M12 = 9;
+    const M13 = 13;
+    const M20 = 2;
+    const M21 = 6;
+    const M22 = 10;
+    const M23 = 14;
+    const M30 = 3;
+    const M31 = 7;
+    const M32 = 11;
+    const M33 = 15;
+    class Matrix4 {
+        temp: Float32Array;
+        values: Float32Array;
+        private static xAxis;
+        private static yAxis;
+        private static zAxis;
+        private static tmpMatrix;
+        constructor();
+        set(values: ArrayLike<number>): Matrix4;
+        transpose(): Matrix4;
+        identity(): Matrix4;
+        invert(): Matrix4;
+        determinant(): number;
+        translate(x: number, y: number, z: number): Matrix4;
+        copy(): Matrix4;
+        projection(near: number, far: number, fovy: number, aspectRatio: number): Matrix4;
+        ortho2d(x: number, y: number, width: number, height: number): Matrix4;
+        ortho(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4;
+        multiply(matrix: Matrix4): Matrix4;
+        multiplyLeft(matrix: Matrix4): Matrix4;
+        lookAt(position: Vector3, direction: Vector3, up: Vector3): this;
+        static initTemps(): void;
+    }
 }
 declare module spine.webgl {
-	class Mesh implements Disposable, Restorable {
-		private attributes;
-		private context;
-		private vertices;
-		private verticesBuffer;
-		private verticesLength;
-		private dirtyVertices;
-		private indices;
-		private indicesBuffer;
-		private indicesLength;
-		private dirtyIndices;
-		private elementsPerVertex;
-		getAttributes(): VertexAttribute[];
-		maxVertices(): number;
-		numVertices(): number;
-		setVerticesLength(length: number): void;
-		getVertices(): Float32Array;
-		maxIndices(): number;
-		numIndices(): number;
-		setIndicesLength(length: number): void;
-		getIndices(): Uint16Array;
-		getVertexSizeInFloats(): number;
-		constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, attributes: VertexAttribute[], maxVertices: number, maxIndices: number);
-		setVertices(vertices: Array<number>): void;
-		setIndices(indices: Array<number>): void;
-		draw(shader: Shader, primitiveType: number): void;
-		drawWithOffset(shader: Shader, primitiveType: number, offset: number, count: number): void;
-		bind(shader: Shader): void;
-		unbind(shader: Shader): void;
-		private update;
-		restore(): void;
-		dispose(): void;
-	}
-	class VertexAttribute {
-		name: string;
-		type: VertexAttributeType;
-		numElements: number;
-		constructor(name: string, type: VertexAttributeType, numElements: number);
-	}
-	class Position2Attribute extends VertexAttribute {
-		constructor();
-	}
-	class Position3Attribute extends VertexAttribute {
-		constructor();
-	}
-	class TexCoordAttribute extends VertexAttribute {
-		constructor(unit?: number);
-	}
-	class ColorAttribute extends VertexAttribute {
-		constructor();
-	}
-	class Color2Attribute extends VertexAttribute {
-		constructor();
-	}
-	enum VertexAttributeType {
-		Float = 0
-	}
+    class Mesh implements Disposable, Restorable {
+        private attributes;
+        private context;
+        private vertices;
+        private verticesBuffer;
+        private verticesLength;
+        private dirtyVertices;
+        private indices;
+        private indicesBuffer;
+        private indicesLength;
+        private dirtyIndices;
+        private elementsPerVertex;
+        getAttributes(): VertexAttribute[];
+        maxVertices(): number;
+        numVertices(): number;
+        setVerticesLength(length: number): void;
+        getVertices(): Float32Array;
+        maxIndices(): number;
+        numIndices(): number;
+        setIndicesLength(length: number): void;
+        getIndices(): Uint16Array;
+        getVertexSizeInFloats(): number;
+        constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, attributes: VertexAttribute[], maxVertices: number, maxIndices: number);
+        setVertices(vertices: Array<number>): void;
+        setIndices(indices: Array<number>): void;
+        draw(shader: Shader, primitiveType: number): void;
+        drawWithOffset(shader: Shader, primitiveType: number, offset: number, count: number): void;
+        bind(shader: Shader): void;
+        unbind(shader: Shader): void;
+        private update();
+        restore(): void;
+        dispose(): void;
+    }
+    class VertexAttribute {
+        name: string;
+        type: VertexAttributeType;
+        numElements: number;
+        constructor(name: string, type: VertexAttributeType, numElements: number);
+    }
+    class Position2Attribute extends VertexAttribute {
+        constructor();
+    }
+    class Position3Attribute extends VertexAttribute {
+        constructor();
+    }
+    class TexCoordAttribute extends VertexAttribute {
+        constructor(unit?: number);
+    }
+    class ColorAttribute extends VertexAttribute {
+        constructor();
+    }
+    class Color2Attribute extends VertexAttribute {
+        constructor();
+    }
+    enum VertexAttributeType {
+        Float = 0,
+    }
 }
 declare module spine.webgl {
-	class PolygonBatcher implements Disposable {
-		private context;
-		private drawCalls;
-		private isDrawing;
-		private mesh;
-		private shader;
-		private lastTexture;
-		private verticesLength;
-		private indicesLength;
-		private srcBlend;
-		private dstBlend;
-		constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, twoColorTint?: boolean, maxVertices?: number);
-		begin(shader: Shader): void;
-		setBlendMode(srcBlend: number, dstBlend: number): void;
-		draw(texture: GLTexture, vertices: ArrayLike<number>, indices: Array<number>): void;
-		private flush;
-		end(): void;
-		getDrawCalls(): number;
-		dispose(): void;
-	}
+    class PolygonBatcher implements Disposable {
+        private context;
+        private drawCalls;
+        private isDrawing;
+        private mesh;
+        private shader;
+        private lastTexture;
+        private verticesLength;
+        private indicesLength;
+        private srcBlend;
+        private dstBlend;
+        constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, twoColorTint?: boolean, maxVertices?: number);
+        begin(shader: Shader): void;
+        setBlendMode(srcBlend: number, dstBlend: number): void;
+        draw(texture: GLTexture, vertices: ArrayLike<number>, indices: Array<number>): void;
+        private flush();
+        end(): void;
+        getDrawCalls(): number;
+        dispose(): void;
+    }
 }
 declare module spine.webgl {
-	class SceneRenderer implements Disposable {
-		context: ManagedWebGLRenderingContext;
-		canvas: HTMLCanvasElement;
-		camera: OrthoCamera;
-		batcher: PolygonBatcher;
-		private twoColorTint;
-		private batcherShader;
-		private shapes;
-		private shapesShader;
-		private activeRenderer;
-		skeletonRenderer: SkeletonRenderer;
-		skeletonDebugRenderer: SkeletonDebugRenderer;
-		private QUAD;
-		private QUAD_TRIANGLES;
-		private WHITE;
-		constructor(canvas: HTMLCanvasElement, context: ManagedWebGLRenderingContext | WebGLRenderingContext, twoColorTint?: boolean);
-		begin(): void;
-		drawSkeleton(skeleton: Skeleton, premultipliedAlpha?: boolean, slotRangeStart?: number, slotRangeEnd?: number): void;
-		drawSkeletonDebug(skeleton: Skeleton, premultipliedAlpha?: boolean, ignoredBones?: Array<string>): void;
-		drawTexture(texture: GLTexture, x: number, y: number, width: number, height: number, color?: Color): void;
-		drawTextureUV(texture: GLTexture, x: number, y: number, width: number, height: number, u: number, v: number, u2: number, v2: number, color?: Color): void;
-		drawTextureRotated(texture: GLTexture, x: number, y: number, width: number, height: number, pivotX: number, pivotY: number, angle: number, color?: Color, premultipliedAlpha?: boolean): void;
-		drawRegion(region: TextureAtlasRegion, x: number, y: number, width: number, height: number, color?: Color, premultipliedAlpha?: boolean): void;
-		line(x: number, y: number, x2: number, y2: number, color?: Color, color2?: Color): void;
-		triangle(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, color?: Color, color2?: Color, color3?: Color): void;
-		quad(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, color?: Color, color2?: Color, color3?: Color, color4?: Color): void;
-		rect(filled: boolean, x: number, y: number, width: number, height: number, color?: Color): void;
-		rectLine(filled: boolean, x1: number, y1: number, x2: number, y2: number, width: number, color?: Color): void;
-		polygon(polygonVertices: ArrayLike<number>, offset: number, count: number, color?: Color): void;
-		circle(filled: boolean, x: number, y: number, radius: number, color?: Color, segments?: number): void;
-		curve(x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, segments: number, color?: Color): void;
-		end(): void;
-		resize(resizeMode: ResizeMode): void;
-		private enableRenderer;
-		dispose(): void;
-	}
-	enum ResizeMode {
-		Stretch = 0,
-		Expand = 1,
-		Fit = 2
-	}
+    class SceneRenderer implements Disposable {
+        context: ManagedWebGLRenderingContext;
+        canvas: HTMLCanvasElement;
+        camera: OrthoCamera;
+        batcher: PolygonBatcher;
+        private twoColorTint;
+        private batcherShader;
+        private shapes;
+        private shapesShader;
+        private activeRenderer;
+        skeletonRenderer: SkeletonRenderer;
+        skeletonDebugRenderer: SkeletonDebugRenderer;
+        private QUAD;
+        private QUAD_TRIANGLES;
+        private WHITE;
+        constructor(canvas: HTMLCanvasElement, context: ManagedWebGLRenderingContext | WebGLRenderingContext, twoColorTint?: boolean);
+        begin(): void;
+        drawSkeleton(skeleton: Skeleton, premultipliedAlpha?: boolean, slotRangeStart?: number, slotRangeEnd?: number): void;
+        drawSkeletonDebug(skeleton: Skeleton, premultipliedAlpha?: boolean, ignoredBones?: Array<string>): void;
+        drawTexture(texture: GLTexture, x: number, y: number, width: number, height: number, color?: Color): void;
+        drawTextureUV(texture: GLTexture, x: number, y: number, width: number, height: number, u: number, v: number, u2: number, v2: number, color?: Color): void;
+        drawTextureRotated(texture: GLTexture, x: number, y: number, width: number, height: number, pivotX: number, pivotY: number, angle: number, color?: Color, premultipliedAlpha?: boolean): void;
+        drawRegion(region: TextureAtlasRegion, x: number, y: number, width: number, height: number, color?: Color, premultipliedAlpha?: boolean): void;
+        line(x: number, y: number, x2: number, y2: number, color?: Color, color2?: Color): void;
+        triangle(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, color?: Color, color2?: Color, color3?: Color): void;
+        quad(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, color?: Color, color2?: Color, color3?: Color, color4?: Color): void;
+        rect(filled: boolean, x: number, y: number, width: number, height: number, color?: Color): void;
+        rectLine(filled: boolean, x1: number, y1: number, x2: number, y2: number, width: number, color?: Color): void;
+        polygon(polygonVertices: ArrayLike<number>, offset: number, count: number, color?: Color): void;
+        circle(filled: boolean, x: number, y: number, radius: number, color?: Color, segments?: number): void;
+        curve(x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, segments: number, color?: Color): void;
+        end(): void;
+        resize(resizeMode: ResizeMode): void;
+        private enableRenderer(renderer);
+        dispose(): void;
+    }
+    enum ResizeMode {
+        Stretch = 0,
+        Expand = 1,
+        Fit = 2,
+    }
 }
 declare module spine.webgl {
-	class Shader implements Disposable, Restorable {
-		private vertexShader;
-		private fragmentShader;
-		static MVP_MATRIX: string;
-		static POSITION: string;
-		static COLOR: string;
-		static COLOR2: string;
-		static TEXCOORDS: string;
-		static SAMPLER: string;
-		private context;
-		private vs;
-		private vsSource;
-		private fs;
-		private fsSource;
-		private program;
-		private tmp2x2;
-		private tmp3x3;
-		private tmp4x4;
-		getProgram(): WebGLProgram;
-		getVertexShader(): string;
-		getFragmentShader(): string;
-		getVertexShaderSource(): string;
-		getFragmentSource(): string;
-		constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, vertexShader: string, fragmentShader: string);
-		private compile;
-		private compileShader;
-		private compileProgram;
-		restore(): void;
-		bind(): void;
-		unbind(): void;
-		setUniformi(uniform: string, value: number): void;
-		setUniformf(uniform: string, value: number): void;
-		setUniform2f(uniform: string, value: number, value2: number): void;
-		setUniform3f(uniform: string, value: number, value2: number, value3: number): void;
-		setUniform4f(uniform: string, value: number, value2: number, value3: number, value4: number): void;
-		setUniform2x2f(uniform: string, value: ArrayLike<number>): void;
-		setUniform3x3f(uniform: string, value: ArrayLike<number>): void;
-		setUniform4x4f(uniform: string, value: ArrayLike<number>): void;
-		getUniformLocation(uniform: string): WebGLUniformLocation;
-		getAttributeLocation(attribute: string): number;
-		dispose(): void;
-		static newColoredTextured(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader;
-		static newTwoColoredTextured(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader;
-		static newColored(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader;
-	}
+    class Shader implements Disposable, Restorable {
+        private vertexShader;
+        private fragmentShader;
+        static MVP_MATRIX: string;
+        static POSITION: string;
+        static COLOR: string;
+        static COLOR2: string;
+        static TEXCOORDS: string;
+        static SAMPLER: string;
+        private context;
+        private vs;
+        private vsSource;
+        private fs;
+        private fsSource;
+        private program;
+        private tmp2x2;
+        private tmp3x3;
+        private tmp4x4;
+        getProgram(): WebGLProgram;
+        getVertexShader(): string;
+        getFragmentShader(): string;
+        getVertexShaderSource(): string;
+        getFragmentSource(): string;
+        constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, vertexShader: string, fragmentShader: string);
+        private compile();
+        private compileShader(type, source);
+        private compileProgram(vs, fs);
+        restore(): void;
+        bind(): void;
+        unbind(): void;
+        setUniformi(uniform: string, value: number): void;
+        setUniformf(uniform: string, value: number): void;
+        setUniform2f(uniform: string, value: number, value2: number): void;
+        setUniform3f(uniform: string, value: number, value2: number, value3: number): void;
+        setUniform4f(uniform: string, value: number, value2: number, value3: number, value4: number): void;
+        setUniform2x2f(uniform: string, value: ArrayLike<number>): void;
+        setUniform3x3f(uniform: string, value: ArrayLike<number>): void;
+        setUniform4x4f(uniform: string, value: ArrayLike<number>): void;
+        getUniformLocation(uniform: string): WebGLUniformLocation;
+        getAttributeLocation(attribute: string): number;
+        dispose(): void;
+        static newColoredTextured(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader;
+        static newTwoColoredTextured(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader;
+        static newColored(context: ManagedWebGLRenderingContext | WebGLRenderingContext): Shader;
+    }
 }
 declare module spine.webgl {
-	class ShapeRenderer implements Disposable {
-		private context;
-		private isDrawing;
-		private mesh;
-		private shapeType;
-		private color;
-		private shader;
-		private vertexIndex;
-		private tmp;
-		private srcBlend;
-		private dstBlend;
-		constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, maxVertices?: number);
-		begin(shader: Shader): void;
-		setBlendMode(srcBlend: number, dstBlend: number): void;
-		setColor(color: Color): void;
-		setColorWith(r: number, g: number, b: number, a: number): void;
-		point(x: number, y: number, color?: Color): void;
-		line(x: number, y: number, x2: number, y2: number, color?: Color): void;
-		triangle(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, color?: Color, color2?: Color, color3?: Color): void;
-		quad(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, color?: Color, color2?: Color, color3?: Color, color4?: Color): void;
-		rect(filled: boolean, x: number, y: number, width: number, height: number, color?: Color): void;
-		rectLine(filled: boolean, x1: number, y1: number, x2: number, y2: number, width: number, color?: Color): void;
-		x(x: number, y: number, size: number): void;
-		polygon(polygonVertices: ArrayLike<number>, offset: number, count: number, color?: Color): void;
-		circle(filled: boolean, x: number, y: number, radius: number, color?: Color, segments?: number): void;
-		curve(x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, segments: number, color?: Color): void;
-		private vertex;
-		end(): void;
-		private flush;
-		private check;
-		dispose(): void;
-	}
-	enum ShapeType {
-		Point = 0,
-		Line = 1,
-		Filled = 4
-	}
+    class ShapeRenderer implements Disposable {
+        private context;
+        private isDrawing;
+        private mesh;
+        private shapeType;
+        private color;
+        private shader;
+        private vertexIndex;
+        private tmp;
+        private srcBlend;
+        private dstBlend;
+        constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, maxVertices?: number);
+        begin(shader: Shader): void;
+        setBlendMode(srcBlend: number, dstBlend: number): void;
+        setColor(color: Color): void;
+        setColorWith(r: number, g: number, b: number, a: number): void;
+        point(x: number, y: number, color?: Color): void;
+        line(x: number, y: number, x2: number, y2: number, color?: Color): void;
+        triangle(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, color?: Color, color2?: Color, color3?: Color): void;
+        quad(filled: boolean, x: number, y: number, x2: number, y2: number, x3: number, y3: number, x4: number, y4: number, color?: Color, color2?: Color, color3?: Color, color4?: Color): void;
+        rect(filled: boolean, x: number, y: number, width: number, height: number, color?: Color): void;
+        rectLine(filled: boolean, x1: number, y1: number, x2: number, y2: number, width: number, color?: Color): void;
+        x(x: number, y: number, size: number): void;
+        polygon(polygonVertices: ArrayLike<number>, offset: number, count: number, color?: Color): void;
+        circle(filled: boolean, x: number, y: number, radius: number, color?: Color, segments?: number): void;
+        curve(x1: number, y1: number, cx1: number, cy1: number, cx2: number, cy2: number, x2: number, y2: number, segments: number, color?: Color): void;
+        private vertex(x, y, color);
+        end(): void;
+        private flush();
+        private check(shapeType, numVertices);
+        dispose(): void;
+    }
+    enum ShapeType {
+        Point = 0,
+        Line = 1,
+        Filled = 4,
+    }
 }
 declare module spine.webgl {
-	class SkeletonDebugRenderer implements Disposable {
-		boneLineColor: Color;
-		boneOriginColor: Color;
-		attachmentLineColor: Color;
-		triangleLineColor: Color;
-		pathColor: Color;
-		clipColor: Color;
-		aabbColor: Color;
-		drawBones: boolean;
-		drawRegionAttachments: boolean;
-		drawBoundingBoxes: boolean;
-		drawMeshHull: boolean;
-		drawMeshTriangles: boolean;
-		drawPaths: boolean;
-		drawSkeletonXY: boolean;
-		drawClipping: boolean;
-		premultipliedAlpha: boolean;
-		scale: number;
-		boneWidth: number;
-		private context;
-		private bounds;
-		private temp;
-		private vertices;
-		private static LIGHT_GRAY;
-		private static GREEN;
-		constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext);
-		draw(shapes: ShapeRenderer, skeleton: Skeleton, ignoredBones?: Array<string>): void;
-		dispose(): void;
-	}
+    class SkeletonDebugRenderer implements Disposable {
+        boneLineColor: Color;
+        boneOriginColor: Color;
+        attachmentLineColor: Color;
+        triangleLineColor: Color;
+        pathColor: Color;
+        clipColor: Color;
+        aabbColor: Color;
+        drawBones: boolean;
+        drawRegionAttachments: boolean;
+        drawBoundingBoxes: boolean;
+        drawMeshHull: boolean;
+        drawMeshTriangles: boolean;
+        drawPaths: boolean;
+        drawSkeletonXY: boolean;
+        drawClipping: boolean;
+        premultipliedAlpha: boolean;
+        scale: number;
+        boneWidth: number;
+        private context;
+        private bounds;
+        private temp;
+        private vertices;
+        private static LIGHT_GRAY;
+        private static GREEN;
+        constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext);
+        draw(shapes: ShapeRenderer, skeleton: Skeleton, ignoredBones?: Array<string>): void;
+        dispose(): void;
+    }
 }
 declare module spine.webgl {
-	class SkeletonRenderer {
-		static QUAD_TRIANGLES: number[];
-		premultipliedAlpha: boolean;
-		vertexEffect: VertexEffect;
-		private tempColor;
-		private tempColor2;
-		private vertices;
-		private vertexSize;
-		private twoColorTint;
-		private renderable;
-		private clipper;
-		private temp;
-		private temp2;
-		private temp3;
-		private temp4;
-		constructor(context: ManagedWebGLRenderingContext, twoColorTint?: boolean);
-		draw(batcher: PolygonBatcher, skeleton: Skeleton, slotRangeStart?: number, slotRangeEnd?: number): void;
-	}
+    class SkeletonRenderer {
+        static QUAD_TRIANGLES: number[];
+        premultipliedAlpha: boolean;
+        vertexEffect: VertexEffect;
+        private tempColor;
+        private tempColor2;
+        private vertices;
+        private vertexSize;
+        private twoColorTint;
+        private renderable;
+        private clipper;
+        private temp;
+        private temp2;
+        private temp3;
+        private temp4;
+        constructor(context: ManagedWebGLRenderingContext, twoColorTint?: boolean);
+        draw(batcher: PolygonBatcher, skeleton: Skeleton, slotRangeStart?: number, slotRangeEnd?: number): void;
+    }
 }
 declare module spine.webgl {
-	class Vector3 {
-		x: number;
-		y: number;
-		z: number;
-		constructor(x?: number, y?: number, z?: number);
-		setFrom(v: Vector3): Vector3;
-		set(x: number, y: number, z: number): Vector3;
-		add(v: Vector3): Vector3;
-		sub(v: Vector3): Vector3;
-		scale(s: number): Vector3;
-		normalize(): Vector3;
-		cross(v: Vector3): Vector3;
-		multiply(matrix: Matrix4): Vector3;
-		project(matrix: Matrix4): Vector3;
-		dot(v: Vector3): number;
-		length(): number;
-		distance(v: Vector3): number;
-	}
+    class Vector3 {
+        x: number;
+        y: number;
+        z: number;
+        constructor(x?: number, y?: number, z?: number);
+        setFrom(v: Vector3): Vector3;
+        set(x: number, y: number, z: number): Vector3;
+        add(v: Vector3): Vector3;
+        sub(v: Vector3): Vector3;
+        scale(s: number): Vector3;
+        normalize(): Vector3;
+        cross(v: Vector3): Vector3;
+        multiply(matrix: Matrix4): Vector3;
+        project(matrix: Matrix4): Vector3;
+        dot(v: Vector3): number;
+        length(): number;
+        distance(v: Vector3): number;
+    }
 }
 declare module spine.webgl {
-	class ManagedWebGLRenderingContext {
-		canvas: HTMLCanvasElement;
-		gl: WebGLRenderingContext;
-		private restorables;
-		constructor(canvasOrContext: HTMLCanvasElement | WebGLRenderingContext, contextConfig?: any);
-		addRestorable(restorable: Restorable): void;
-		removeRestorable(restorable: Restorable): void;
-	}
-	class WebGLBlendModeConverter {
-		static ZERO: number;
-		static ONE: number;
-		static SRC_COLOR: number;
-		static ONE_MINUS_SRC_COLOR: number;
-		static SRC_ALPHA: number;
-		static ONE_MINUS_SRC_ALPHA: number;
-		static DST_ALPHA: number;
-		static ONE_MINUS_DST_ALPHA: number;
-		static DST_COLOR: number;
-		static getDestGLBlendMode(blendMode: BlendMode): number;
-		static getSourceGLBlendMode(blendMode: BlendMode, premultipliedAlpha?: boolean): number;
-	}
+    class ManagedWebGLRenderingContext {
+        canvas: HTMLCanvasElement;
+        gl: WebGLRenderingContext;
+        private restorables;
+        constructor(canvasOrContext: HTMLCanvasElement | WebGLRenderingContext, contextConfig?: any);
+        addRestorable(restorable: Restorable): void;
+        removeRestorable(restorable: Restorable): void;
+    }
+    class WebGLBlendModeConverter {
+        static ZERO: number;
+        static ONE: number;
+        static SRC_COLOR: number;
+        static ONE_MINUS_SRC_COLOR: number;
+        static SRC_ALPHA: number;
+        static ONE_MINUS_SRC_ALPHA: number;
+        static DST_ALPHA: number;
+        static ONE_MINUS_DST_ALPHA: number;
+        static DST_COLOR: number;
+        static getDestGLBlendMode(blendMode: BlendMode): number;
+        static getSourceGLBlendMode(blendMode: BlendMode, premultipliedAlpha?: boolean): number;
+    }
 }
 declare module spine {
-	interface SpinePlayerConfig {
-		jsonUrl: string;
-		atlasUrl: string;
-		animation: string;
-		animations: string[];
-		skin: string;
-		skins: string[];
-		controlBones: string[];
-		premultipliedAlpha: boolean;
-		showControls: boolean;
-		debug: {
-			bones: boolean;
-			regions: boolean;
-			meshes: boolean;
-			bounds: boolean;
-			paths: boolean;
-			clipping: boolean;
-			points: boolean;
-			hulls: boolean;
-		};
-		viewport: {
-			x: number;
-			y: number;
-			width: number;
-			height: number;
-		};
-		alpha: boolean;
-		backgroundColor: string;
-		backgroundImage: {
-			url: string;
-			x: number;
-			y: number;
-			width: number;
-			height: number;
-		};
-		success: (widget: SpineWidget) => void;
-		error: (widget: SpineWidget, msg: string) => void;
-	}
-	class SpinePlayer {
-		private config;
-		static HOVER_COLOR_INNER: Color;
-		static HOVER_COLOR_OUTER: Color;
-		static NON_HOVER_COLOR_INNER: Color;
-		static NON_HOVER_COLOR_OUTER: Color;
-		private sceneRenderer;
-		private dom;
-		private playerControls;
-		private canvas;
-		private timelineSlider;
-		private playButton;
-		private context;
-		private loadingScreen;
-		private assetManager;
-		private loaded;
-		private skeleton;
-		private animationState;
-		private time;
-		private paused;
-		private playTime;
-		private speed;
-		private selectedBones;
-		constructor(parent: HTMLElement, config: SpinePlayerConfig);
-		validateConfig(config: SpinePlayerConfig): SpinePlayerConfig;
-		showError(error: string): void;
-		render(): HTMLElement;
-		showSpeedDialog(): void;
-		showAnimationsDialog(): void;
-		showSkinsDialog(): void;
-		showSettingsDialog(): void;
-		drawFrame(requestNextFrame?: boolean): void;
-		scale(sourceWidth: number, sourceHeight: number, targetWidth: number, targetHeight: number): Vector2;
-		loadSkeleton(): void;
-		setupInput(): void;
-		private play;
-		private pause;
-	}
+    interface SpinePlayerConfig {
+        jsonUrl: string;
+        atlasUrl: string;
+        animation: string;
+        animations: string[];
+        skin: string;
+        skins: string[];
+        controlBones: string[];
+        premultipliedAlpha: boolean;
+        showControls: boolean;
+        debug: {
+            bones: boolean;
+            regions: boolean;
+            meshes: boolean;
+            bounds: boolean;
+            paths: boolean;
+            clipping: boolean;
+            points: boolean;
+            hulls: boolean;
+        };
+        viewport: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        alpha: boolean;
+        backgroundColor: string;
+        backgroundImage: {
+            url: string;
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        success: (widget: SpinePlayer) => void;
+        error: (widget: SpinePlayer, msg: string) => void;
+    }
+    class SpinePlayer {
+        private config;
+        static HOVER_COLOR_INNER: Color;
+        static HOVER_COLOR_OUTER: Color;
+        static NON_HOVER_COLOR_INNER: Color;
+        static NON_HOVER_COLOR_OUTER: Color;
+        private sceneRenderer;
+        private dom;
+        private playerControls;
+        private canvas;
+        private timelineSlider;
+        private playButton;
+        private skinButton;
+        private animationButton;
+        private context;
+        private loadingScreen;
+        private assetManager;
+        private loaded;
+        private skeleton;
+        private animationState;
+        private time;
+        private paused;
+        private playTime;
+        private speed;
+        private selectedBones;
+        constructor(parent: HTMLElement, config: SpinePlayerConfig);
+        validateConfig(config: SpinePlayerConfig): SpinePlayerConfig;
+        showError(error: string): void;
+        render(): HTMLElement;
+        showSpeedDialog(): void;
+        showAnimationsDialog(): void;
+        showSkinsDialog(): void;
+        showSettingsDialog(): void;
+        drawFrame(requestNextFrame?: boolean): void;
+        scale(sourceWidth: number, sourceHeight: number, targetWidth: number, targetHeight: number): Vector2;
+        loadSkeleton(): void;
+        setupInput(): void;
+        private play();
+        private pause();
+    }
 }
 declare module spine {
-	class SpineWidget {
-		skeleton: Skeleton;
-		state: AnimationState;
-		context: spine.webgl.ManagedWebGLRenderingContext;
-		canvas: HTMLCanvasElement;
-		debugRenderer: spine.webgl.SkeletonDebugRenderer;
-		private config;
-		private assetManager;
-		private shader;
-		private batcher;
-		private shapes;
-		private debugShader;
-		private mvp;
-		private skeletonRenderer;
-		private paused;
-		private lastFrameTime;
-		private backgroundColor;
-		private loaded;
-		private bounds;
-		constructor(element: HTMLElement | string, config: SpineWidgetConfig);
-		private validateConfig;
-		private load;
-		private render;
-		private resize;
-		pause(): void;
-		play(): void;
-		isPlaying(): boolean;
-		setAnimation(animationName: string, animationStateListener?: AnimationStateListener2): void;
-		static loadWidgets(): void;
-		static loadWidget(widget: HTMLElement): void;
-		static pageLoaded: boolean;
-		private static ready;
-		static setupDOMListener(): void;
-	}
-	class SpineWidgetConfig {
-		json: string;
-		jsonContent: any;
-		atlas: string;
-		atlasContent: string;
-		animation: string;
-		imagesPath: string;
-		atlasPages: string[];
-		atlasPagesContent: string[];
-		skin: string;
-		loop: boolean;
-		scale: number;
-		x: number;
-		y: number;
-		alpha: boolean;
-		fitToCanvas: boolean;
-		backgroundColor: string;
-		premultipliedAlpha: boolean;
-		debug: boolean;
-		success: (widget: SpineWidget) => void;
-		error: (widget: SpineWidget, msg: string) => void;
-	}
+    class SpineWidget {
+        skeleton: Skeleton;
+        state: AnimationState;
+        context: spine.webgl.ManagedWebGLRenderingContext;
+        canvas: HTMLCanvasElement;
+        debugRenderer: spine.webgl.SkeletonDebugRenderer;
+        private config;
+        private assetManager;
+        private shader;
+        private batcher;
+        private shapes;
+        private debugShader;
+        private mvp;
+        private skeletonRenderer;
+        private paused;
+        private lastFrameTime;
+        private backgroundColor;
+        private loaded;
+        private bounds;
+        constructor(element: HTMLElement | string, config: SpineWidgetConfig);
+        private validateConfig(config);
+        private load();
+        private render();
+        private resize();
+        pause(): void;
+        play(): void;
+        isPlaying(): boolean;
+        setAnimation(animationName: string, animationStateListener?: AnimationStateListener2): void;
+        static loadWidgets(): void;
+        static loadWidget(widget: HTMLElement): void;
+        static pageLoaded: boolean;
+        private static ready();
+        static setupDOMListener(): void;
+    }
+    class SpineWidgetConfig {
+        json: string;
+        jsonContent: any;
+        atlas: string;
+        atlasContent: string;
+        animation: string;
+        imagesPath: string;
+        atlasPages: string[];
+        atlasPagesContent: string[];
+        skin: string;
+        loop: boolean;
+        scale: number;
+        x: number;
+        y: number;
+        alpha: boolean;
+        fitToCanvas: boolean;
+        backgroundColor: string;
+        premultipliedAlpha: boolean;
+        debug: boolean;
+        success: (widget: SpineWidget) => void;
+        error: (widget: SpineWidget, msg: string) => void;
+    }
 }

spine-ts/widget/css/spine-widget.css → spine-ts/widget/css/spine-player.css

@@ -152,6 +152,8 @@
 	right: 2px;
     bottom: 42px;
 	border-radius: 4px;
+	max-height: 400%;
+	overflow: auto;
 }
 
 .spine-player-popup-title {
@@ -180,13 +182,17 @@
 	bottom: 0;
 	left: 0;
 	width: 100%;
+}
+
+.spine-player-controls.hidden {
+	pointer-events: none;
 	opacity: 0;
-	transition: opacity 0.2s;
+	transition: opacity 0.4s;
 }
 
-.spine-player:hover .spine-player-controls {
+.spine-player-controls.visible {
 	opacity: 1;
-	transition: opacity 0.2s;
+	transition: opacity 0.4s;
 }
 
 /** Player buttons **/
@@ -208,7 +214,7 @@
 	height: 32px;
 	background-size: 20px;
     background-repeat: no-repeat;
-    background-position: 6;
+    background-position: center;
 	cursor: pointer;
 }
 

spine-ts/widget/example/player-test.html

@@ -1,15 +1,21 @@
+<!doctype html>
 <html>
-<script src="../../build/spine-widget.js"></script>
-<link rel="stylesheet" href="../css/spine-player.css">
+<head>
+	<meta charset="utf-8">
+	<script src="../../build/spine-widget.js"></script>
+	<link rel="stylesheet" href="../css/spine-player.css">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+</head>
 
 <style>
 body {
 	background: gray;
+	margin: 0px;
 }
 </style>
 
 <body>
-	<div id="container" style="width: 100%; height: 100%;"></div>
+	<div id="container" style="width: 100%; height: 100vh;"></div>
 </body>
 <script>
 	new spine.SpinePlayer(document.getElementById("container"), {
@@ -17,7 +23,8 @@ body {
 		atlasUrl: "assets/spineboy.atlas",
 		animations: ["walk", "jump"],
 		controlBones: ["root"],
-		backgroundColor: "#cccccc"
+		backgroundColor: "#cccccc",
+		showControls: false,
 	});
 </script>
 </body>

spine-ts/widget/src/Player.ts

@@ -170,6 +170,8 @@
 		private value: HTMLElement;
 		public change: (percentage: number) => void;
 
+		constructor(public snaps = 0, public snapPercentage = 0.1) { }
+
 		render(): HTMLElement {
 			this.slider = createElement(/*html*/`
 				<div class="spine-player-slider">
@@ -188,7 +190,7 @@
 				up: (x, y) => {
 					dragging = false;
 					let percentage = x / this.slider.clientWidth;
-					percentage = Math.max(0, Math.min(percentage, 1));
+					percentage = percentage = Math.max(0, Math.min(percentage, 1));
 					this.setValue(x / this.slider.clientWidth);
 					if (this.change) this.change(percentage);
 				},
@@ -196,23 +198,34 @@
 					if (dragging) {
 						let percentage = x / this.slider.clientWidth;
 						percentage = Math.max(0, Math.min(percentage, 1));
-						this.setValue(x / this.slider.clientWidth);
+						percentage = this.setValue(x / this.slider.clientWidth);
 						if (this.change) this.change(percentage);
 					}
 				},
 				dragged: (x, y) => {
 					let percentage = x / this.slider.clientWidth;
 					percentage = Math.max(0, Math.min(percentage, 1));
-					this.setValue(x / this.slider.clientWidth);
+					percentage = this.setValue(x / this.slider.clientWidth);
 					if (this.change) this.change(percentage);
 				}
 			});
 			return this.slider;
 		}
 
-		setValue(percentage: number) {
+		setValue(percentage: number): number {
 			percentage = Math.max(0, Math.min(1, percentage));
+			if (this.snaps > 0) {
+				let modulo = percentage % (1 / this.snaps);
+				// floor
+				if (modulo < (1 / this.snaps) * this.snapPercentage) {
+					percentage = percentage - modulo;
+				} else if (modulo > (1 / this.snaps) - (1 / this.snaps) * this.snapPercentage) {
+					percentage = percentage - modulo + (1 / this.snaps);
+				}
+				percentage = Math.max(0, Math.min(1, percentage));
+			}
 			this.value.style.width = "" + (percentage * 100) + "%";
+			return percentage;
 		}
 	}
 
@@ -228,6 +241,8 @@
 		private canvas: HTMLCanvasElement;
 		private timelineSlider: Slider;
 		private playButton: HTMLElement;
+		private skinButton: HTMLElement;
+		private animationButton: HTMLElement;
 
 		private context: spine.webgl.ManagedWebGLRenderingContext;
 		private loadingScreen: spine.webgl.LoadingScreen;
@@ -303,7 +318,7 @@
 				<div class="spine-player">
 					<canvas class="spine-player-canvas"></canvas>
 					<div class="spine-player-error spine-player-hidden"></div>
-					<div class="spine-player-controls spine-player-popup-parent">
+					<div class="spine-player-controls spine-player-popup-parent hidden">
 						<div class="spine-player-timeline">
 						</div>
 						<div class="spine-player-buttons">
@@ -357,8 +372,8 @@
 			timeline.appendChild(this.timelineSlider.render());
 			this.playButton = findWithId(dom, "spine-player-button-play-pause")[0];
 			let speedButton = findWithId(dom, "spine-player-button-speed")[0];
-			let animationButton = findWithId(dom, "spine-player-button-animation")[0];
-			let skinButton = findWithId(dom, "spine-player-button-skin")[0];
+			this.animationButton = findWithId(dom, "spine-player-button-animation")[0];
+			this.skinButton = findWithId(dom, "spine-player-button-skin")[0];
 			let settingsButton = findWithId(dom, "spine-player-button-settings")[0];
 			let fullscreenButton = findWithId(dom, "spine-player-button-fullscreen")[0];
 
@@ -371,11 +386,11 @@
 				this.showSpeedDialog();
 			}
 
-			animationButton.onclick = () => {
+			this.animationButton.onclick = () => {
 				this.showAnimationsDialog();
 			}
 
-			skinButton.onclick = () => {
+			this.skinButton.onclick = () => {
 				this.showSkinsDialog();
 			}
 
@@ -404,8 +419,6 @@
 				this.drawFrame(false);
 			}
 
-			if (!config.showControls) findWithClass(dom, "spine-player-controls ")[0].classList.add("spine-player-hidden");
-
 			return dom;
 		}
 
@@ -424,7 +437,7 @@
 				</div>
 			`);
 			let sliderParent = findWithClass(popup.dom, "spine-player-speed-slider")[0];
-			let slider = new Slider();
+			let slider = new Slider(2);
 			sliderParent.appendChild(slider.render());
 			slider.setValue(this.speed / 2);
 			slider.change = (percentage) => {
@@ -532,14 +545,14 @@
 				rows.appendChild(row);
 			};
 
-			makeItem("Show bones", "bones");
-			makeItem("Show regions", "regions");
-			makeItem("Show meshes", "meshes");
-			makeItem("Show bounds", "bounds");
-			makeItem("Show paths", "paths");
-			makeItem("Show clipping", "clipping");
-			makeItem("Show points", "points");
-			makeItem("Show hulls", "hulls");
+			makeItem("Bones", "bones");
+			makeItem("Regions", "regions");
+			makeItem("Meshes", "meshes");
+			makeItem("Bounds", "bounds");
+			makeItem("Paths", "paths");
+			makeItem("Clipping", "clipping");
+			makeItem("Points", "points");
+			makeItem("Hulls", "hulls");
 
 			popup.show();
 		}
@@ -580,9 +593,10 @@
 
 					this.animationState.update(delta);
 					this.animationState.apply(this.skeleton);
-					this.skeleton.updateWorldTransform();
 				}
 
+				this.skeleton.updateWorldTransform();
+
 				let viewportSize = this.scale(this.config.viewport.width, this.config.viewport.height, this.canvas.width, this.canvas.height);
 
 				this.sceneRenderer.camera.zoom = this.config.viewport.width / viewportSize.x;
@@ -720,12 +734,6 @@
 			}
 
 			// Setup the animations after viewport, so default bounds don't get messed up.
-			if (!this.config.animation) {
-				if (skeletonData.animations.length > 0) {
-					this.config.animation = skeletonData.animations[0].name;
-				}
-			}
-
 			if (this.config.animations && this.config.animations.length > 0) {
 				this.config.animations.forEach(animation => {
 					if (!this.skeleton.data.findAnimation(animation)) {
@@ -733,6 +741,16 @@
 						return;
 					}
 				});
+
+				if (!this.config.animation) {
+					this.config.animation = this.config.animations[0];
+				}
+			}
+
+			if (!this.config.animation) {
+				if (skeletonData.animations.length > 0) {
+					this.config.animation = skeletonData.animations[0].name;
+				}
 			}
 
 			if(this.config.animation) {
@@ -755,6 +773,10 @@
 			// Setup the input processor and controllable bones
 			this.setupInput();
 
+			// Hide skin and animation if there's only the default skin / no animation
+			if (skeletonData.skins.length == 1) this.skinButton.classList.add("spine-player-hidden");
+			if (skeletonData.animations.length == 1) this.animationButton.classList.add("spine-player-hidden");
+
 			this.config.success(this);
 			this.loaded = true;
 		}
@@ -780,9 +802,11 @@
 							target = bone;
 						}
 					}
+					handleHover();
 				},
 				up: (x, y) => {
 					target = null;
+					handleHover();
 				},
 				dragged: (x, y) => {
 					if (target != null) {
@@ -796,6 +820,7 @@
 							target.y = coords.y - skeleton.y;
 						}
 					}
+					handleHover();
 				},
 				moved: (x, y) => {
 					for (var i = 0; i < controlBones.length; i++) {
@@ -808,8 +833,42 @@
 							selectedBones[i] = null;
 						}
 					}
+					handleHover();
 				}
 			});
+
+			// For the manual hover to work, we need to disable
+			// hidding the controls if the mouse/touch entered
+			// the clickable area of a child of the controls
+			let mouseOverChildren = false;
+			canvas.onmouseover = (ev) => {
+				mouseOverChildren = false;
+			}
+			canvas.onmouseout = (ev) => {
+				if (ev.relatedTarget == null) {
+					mouseOverChildren = false;
+				} else {
+					mouseOverChildren = isContained(this.dom, (ev.relatedTarget as any));
+				}
+			}
+
+			let cancelId = 0;
+			let handleHover = () => {
+				if (!this.config.showControls) return;
+				clearTimeout(cancelId);
+				this.playerControls.classList.remove("hidden");
+				this.playerControls.classList.add("visible");
+				let remove = () => {
+					let popup = findWithClass(this.dom, "spine-player-popup");
+					if (popup.length == 0 && !mouseOverChildren) {
+						this.playerControls.classList.remove("visible");
+						this.playerControls.classList.add("hidden");
+					} else {
+						cancelId = setTimeout(remove, 1000);
+					}
+				};
+				cancelId = setTimeout(remove, 1000);
+			}
 		}
 
 		private play () {