[ts] Clean up, build fixes.

spine-ts/build/spine-all.d.ts

@@ -7,8 +7,6 @@ declare module spine {
         constructor(name: string, timelines: Array<Timeline>, duration: number);
         hasTimeline(ids: string[]): boolean;
         apply(skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-		static search(frames: ArrayLike<number>, time: number): number;
-		static search2(values: ArrayLike<number>, time: number, step: number): number;
     }
     enum MixBlend {
         setup = 0,
@@ -20,36 +18,17 @@ declare module spine {
         mixIn = 0,
         mixOut = 1
     }
-	enum Property {
-		rotate = 0,
-		x = 1,
-		y = 2,
-		scaleX = 3,
-		scaleY = 4,
-		shearX = 5,
-		shearY = 6,
-		rgb = 7,
-		alpha = 8,
-		rgb2 = 9,
-		attachment = 10,
-		deform = 11,
-		event = 12,
-		drawOrder = 13,
-		ikConstraint = 14,
-		transformConstraint = 15,
-		pathConstraintPosition = 16,
-		pathConstraintSpacing = 17,
-		pathConstraintMix = 18
-	}
     abstract class Timeline {
         propertyIds: string[];
         frames: ArrayLike<number>;
         constructor(frameCount: number, propertyIds: string[]);
         getPropertyIds(): string[];
-		abstract getFrameEntries(): number;
+        getFrameEntries(): number;
         getFrameCount(): number;
         getDuration(): number;
         abstract apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+        static search(frames: ArrayLike<number>, time: number): number;
+        static search2(values: ArrayLike<number>, time: number, step: number): number;
     }
     interface BoneTimeline {
         boneIndex: number;
@@ -58,10 +37,6 @@ declare module spine {
         slotIndex: number;
     }
     abstract class CurveTimeline extends Timeline {
-		static LINEAR: number;
-		static STEPPED: number;
-		static BEZIER: number;
-		static BEZIER_SIZE: number;
         protected curves: ArrayLike<number>;
         constructor(frameCount: number, bezierCount: number, propertyIds: string[]);
         setLinear(frame: number): void;
@@ -197,7 +172,6 @@ declare module spine {
         slotIndex: number;
         attachmentNames: Array<string>;
         constructor(frameCount: number, slotIndex: number);
-		getFrameEntries(): number;
         getFrameCount(): number;
         setFrame(frame: number, time: number, attachmentName: string): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
@@ -208,7 +182,7 @@ declare module spine {
         attachment: VertexAttachment;
         vertices: Array<ArrayLike<number>>;
         constructor(frameCount: number, bezierCount: number, slotIndex: number, attachment: VertexAttachment);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, time: number, vertices: ArrayLike<number>): void;
         setBezier(bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: number): void;
         getCurvePercent(time: number, frame: number): number;
@@ -218,7 +192,7 @@ declare module spine {
         static propertyIds: string[];
         events: Array<Event>;
         constructor(frameCount: number);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, event: Event): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
@@ -226,7 +200,7 @@ declare module spine {
         static propertyIds: string[];
         drawOrders: Array<Array<number>>;
         constructor(frameCount: number);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, time: number, drawOrder: Array<number>): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
@@ -268,11 +242,11 @@ declare module spine {
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
     class PathConstraintMixTimeline extends CurveTimeline {
-		pathConstraintIndex: number;
         static ENTRIES: number;
         static ROTATE: number;
         static X: number;
         static Y: number;
+        pathConstraintIndex: number;
         constructor(frameCount: number, bezierCount: number, pathConstraintIndex: number);
         getFrameEntries(): number;
         setFrame(frame: number, time: number, mixRotate: number, mixX: number, mixY: number): void;
@@ -281,15 +255,7 @@ declare module spine {
 }
 declare module spine {
     class AnimationState {
-		private static _emptyAnimation;
         private static emptyAnimation;
-		static SUBSEQUENT: number;
-		static FIRST: number;
-		static HOLD_SUBSEQUENT: number;
-		static HOLD_FIRST: number;
-		static HOLD_MIX: number;
-		static SETUP: number;
-		static CURRENT: number;
         data: AnimationStateData;
         tracks: TrackEntry[];
         timeScale: number;
@@ -461,14 +427,6 @@ declare module spine {
         newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
     }
 }
-declare module spine {
-	enum BlendMode {
-		Normal = 0,
-		Additive = 1,
-		Multiply = 2,
-		Screen = 3
-	}
-}
 declare module spine {
     class Bone implements Updatable {
         data: BoneData;
@@ -735,35 +693,7 @@ declare module spine {
     }
 }
 declare module spine {
-	export class SkeletonBinary {
+    class SkeletonBinary {
-		static AttachmentTypeValues: number[];
-		static TransformModeValues: TransformMode[];
-		static PositionModeValues: PositionMode[];
-		static SpacingModeValues: SpacingMode[];
-		static RotateModeValues: RotateMode[];
-		static BlendModeValues: BlendMode[];
-		static BONE_ROTATE: number;
-		static BONE_TRANSLATE: number;
-		static BONE_TRANSLATEX: number;
-		static BONE_TRANSLATEY: number;
-		static BONE_SCALE: number;
-		static BONE_SCALEX: number;
-		static BONE_SCALEY: number;
-		static BONE_SHEAR: number;
-		static BONE_SHEARX: number;
-		static BONE_SHEARY: number;
-		static SLOT_ATTACHMENT: number;
-		static SLOT_RGBA: number;
-		static SLOT_RGB: number;
-		static SLOT_RGBA2: number;
-		static SLOT_RGB2: number;
-		static SLOT_ALPHA: number;
-		static PATH_POSITION: number;
-		static PATH_SPACING: number;
-		static PATH_MIX: number;
-		static CURVE_LINEAR: number;
-		static CURVE_STEPPED: number;
-		static CURVE_BEZIER: number;
         scale: number;
         attachmentLoader: AttachmentLoader;
         private linkedMeshes;
@@ -775,26 +705,7 @@ declare module spine {
         private readFloatArray;
         private readShortArray;
         private readAnimation;
-		static readTimeline(input: BinaryInput, timeline: CurveTimeline1, scale: number): Timeline;
-		static readTimeline2(input: BinaryInput, timeline: CurveTimeline2, scale: number): Timeline;
-		static setBezier(input: BinaryInput, timeline: CurveTimeline, bezier: number, frame: number, value: number, time1: number, time2: number, value1: number, value2: number, scale: number): void;
     }
-	class BinaryInput {
-		strings: string[];
-		private index;
-		private buffer;
-		constructor(data: Uint8Array, strings?: string[], index?: number, buffer?: DataView);
-		readByte(): number;
-		readUnsignedByte(): number;
-		readShort(): number;
-		readInt32(): number;
-		readInt(optimizePositive: boolean): number;
-		readStringRef(): string;
-		readString(): string;
-		readFloat(): number;
-		readBoolean(): boolean;
-	}
-	export {};
 }
 declare module spine {
     class SkeletonBounds {
@@ -882,16 +793,6 @@ declare module spine {
         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;
-		private readTimeline;
-		private readTimeline2;
-		private readCurve;
-		setBezier(timeline: CurveTimeline, frame: number, value: number, bezier: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: 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 {
@@ -948,6 +849,12 @@ declare module spine {
         blendMode: BlendMode;
         constructor(index: number, name: string, boneData: BoneData);
     }
+    enum BlendMode {
+        Normal = 0,
+        Additive = 1,
+        Multiply = 2,
+        Screen = 3
+    }
 }
 declare module spine {
     abstract class Texture {
@@ -957,8 +864,6 @@ declare module spine {
         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,
@@ -1135,6 +1040,7 @@ declare module spine {
         clamp(): this;
         static rgba8888ToColor(color: Color, value: number): void;
         static rgb888ToColor(color: Color, value: number): void;
+        static fromString(hex: string): Color;
     }
     class MathUtils {
         static PI: number;
@@ -1178,6 +1084,7 @@ declare module spine {
         static toSinglePrecision(value: number): number;
         static webkit602BugfixHelper(alpha: number, blend: MixBlend): void;
         static contains<T>(array: Array<T>, element: T, identity?: boolean): boolean;
+        static enumValue(type: any, name: string): any;
     }
     class DebugUtils {
         static logBones(skeleton: Skeleton): void;
@@ -1263,17 +1170,6 @@ declare module spine {
         newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
     }
 }
-declare module spine {
-	enum AttachmentType {
-		Region = 0,
-		BoundingBox = 1,
-		Mesh = 2,
-		LinkedMesh = 3,
-		Path = 4,
-		Point = 5,
-		Clipping = 6
-	}
-}
 declare module spine {
     class BoundingBoxAttachment extends VertexAttachment {
         color: Color;
@@ -1335,14 +1231,25 @@ declare module spine {
 }
 declare module spine {
     class RegionAttachment extends Attachment {
-		static OX1: number;
+        x: number;
-		static OY1: number;
+        y: number;
-		static OX2: number;
+        scaleX: number;
-		static OY2: number;
+        scaleY: number;
-		static OX3: number;
+        rotation: number;
-		static OY3: number;
+        width: number;
-		static OX4: number;
+        height: number;
-		static OY4: 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;
+        copy(): Attachment;
         static X1: number;
         static Y1: number;
         static C1R: number;
@@ -1375,25 +1282,6 @@ declare module spine {
         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;
-		copy(): Attachment;
     }
 }
 declare module spine {
@@ -1487,7 +1375,7 @@ declare module spine.webgl {
         static DISABLE_UNPACK_PREMULTIPLIED_ALPHA_WEBGL: boolean;
         constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, image: HTMLImageElement | ImageBitmap, useMipMaps?: boolean);
         setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
-		static validateMagFilter(magFilter: TextureFilter): TextureFilter.Nearest | TextureFilter.Linear | TextureFilter.Linear;
+        static validateMagFilter(magFilter: TextureFilter): TextureFilter.Nearest | TextureFilter.Linear;
         setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
         update(useMipMaps: boolean): void;
         restore(): void;

spine-ts/build/spine-canvas.d.ts

@@ -7,8 +7,6 @@ declare module spine {
         constructor(name: string, timelines: Array<Timeline>, duration: number);
         hasTimeline(ids: string[]): boolean;
         apply(skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-		static search(frames: ArrayLike<number>, time: number): number;
-		static search2(values: ArrayLike<number>, time: number, step: number): number;
     }
     enum MixBlend {
         setup = 0,
@@ -20,36 +18,17 @@ declare module spine {
         mixIn = 0,
         mixOut = 1
     }
-	enum Property {
-		rotate = 0,
-		x = 1,
-		y = 2,
-		scaleX = 3,
-		scaleY = 4,
-		shearX = 5,
-		shearY = 6,
-		rgb = 7,
-		alpha = 8,
-		rgb2 = 9,
-		attachment = 10,
-		deform = 11,
-		event = 12,
-		drawOrder = 13,
-		ikConstraint = 14,
-		transformConstraint = 15,
-		pathConstraintPosition = 16,
-		pathConstraintSpacing = 17,
-		pathConstraintMix = 18
-	}
     abstract class Timeline {
         propertyIds: string[];
         frames: ArrayLike<number>;
         constructor(frameCount: number, propertyIds: string[]);
         getPropertyIds(): string[];
-		abstract getFrameEntries(): number;
+        getFrameEntries(): number;
         getFrameCount(): number;
         getDuration(): number;
         abstract apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+        static search(frames: ArrayLike<number>, time: number): number;
+        static search2(values: ArrayLike<number>, time: number, step: number): number;
     }
     interface BoneTimeline {
         boneIndex: number;
@@ -58,10 +37,6 @@ declare module spine {
         slotIndex: number;
     }
     abstract class CurveTimeline extends Timeline {
-		static LINEAR: number;
-		static STEPPED: number;
-		static BEZIER: number;
-		static BEZIER_SIZE: number;
         protected curves: ArrayLike<number>;
         constructor(frameCount: number, bezierCount: number, propertyIds: string[]);
         setLinear(frame: number): void;
@@ -197,7 +172,6 @@ declare module spine {
         slotIndex: number;
         attachmentNames: Array<string>;
         constructor(frameCount: number, slotIndex: number);
-		getFrameEntries(): number;
         getFrameCount(): number;
         setFrame(frame: number, time: number, attachmentName: string): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
@@ -208,7 +182,7 @@ declare module spine {
         attachment: VertexAttachment;
         vertices: Array<ArrayLike<number>>;
         constructor(frameCount: number, bezierCount: number, slotIndex: number, attachment: VertexAttachment);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, time: number, vertices: ArrayLike<number>): void;
         setBezier(bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: number): void;
         getCurvePercent(time: number, frame: number): number;
@@ -218,7 +192,7 @@ declare module spine {
         static propertyIds: string[];
         events: Array<Event>;
         constructor(frameCount: number);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, event: Event): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
@@ -226,7 +200,7 @@ declare module spine {
         static propertyIds: string[];
         drawOrders: Array<Array<number>>;
         constructor(frameCount: number);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, time: number, drawOrder: Array<number>): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
@@ -268,11 +242,11 @@ declare module spine {
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
     class PathConstraintMixTimeline extends CurveTimeline {
-		pathConstraintIndex: number;
         static ENTRIES: number;
         static ROTATE: number;
         static X: number;
         static Y: number;
+        pathConstraintIndex: number;
         constructor(frameCount: number, bezierCount: number, pathConstraintIndex: number);
         getFrameEntries(): number;
         setFrame(frame: number, time: number, mixRotate: number, mixX: number, mixY: number): void;
@@ -281,15 +255,7 @@ declare module spine {
 }
 declare module spine {
     class AnimationState {
-		private static _emptyAnimation;
         private static emptyAnimation;
-		static SUBSEQUENT: number;
-		static FIRST: number;
-		static HOLD_SUBSEQUENT: number;
-		static HOLD_FIRST: number;
-		static HOLD_MIX: number;
-		static SETUP: number;
-		static CURRENT: number;
         data: AnimationStateData;
         tracks: TrackEntry[];
         timeScale: number;
@@ -461,14 +427,6 @@ declare module spine {
         newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
     }
 }
-declare module spine {
-	enum BlendMode {
-		Normal = 0,
-		Additive = 1,
-		Multiply = 2,
-		Screen = 3
-	}
-}
 declare module spine {
     class Bone implements Updatable {
         data: BoneData;
@@ -735,35 +693,7 @@ declare module spine {
     }
 }
 declare module spine {
-	export class SkeletonBinary {
+    class SkeletonBinary {
-		static AttachmentTypeValues: number[];
-		static TransformModeValues: TransformMode[];
-		static PositionModeValues: PositionMode[];
-		static SpacingModeValues: SpacingMode[];
-		static RotateModeValues: RotateMode[];
-		static BlendModeValues: BlendMode[];
-		static BONE_ROTATE: number;
-		static BONE_TRANSLATE: number;
-		static BONE_TRANSLATEX: number;
-		static BONE_TRANSLATEY: number;
-		static BONE_SCALE: number;
-		static BONE_SCALEX: number;
-		static BONE_SCALEY: number;
-		static BONE_SHEAR: number;
-		static BONE_SHEARX: number;
-		static BONE_SHEARY: number;
-		static SLOT_ATTACHMENT: number;
-		static SLOT_RGBA: number;
-		static SLOT_RGB: number;
-		static SLOT_RGBA2: number;
-		static SLOT_RGB2: number;
-		static SLOT_ALPHA: number;
-		static PATH_POSITION: number;
-		static PATH_SPACING: number;
-		static PATH_MIX: number;
-		static CURVE_LINEAR: number;
-		static CURVE_STEPPED: number;
-		static CURVE_BEZIER: number;
         scale: number;
         attachmentLoader: AttachmentLoader;
         private linkedMeshes;
@@ -775,26 +705,7 @@ declare module spine {
         private readFloatArray;
         private readShortArray;
         private readAnimation;
-		static readTimeline(input: BinaryInput, timeline: CurveTimeline1, scale: number): Timeline;
-		static readTimeline2(input: BinaryInput, timeline: CurveTimeline2, scale: number): Timeline;
-		static setBezier(input: BinaryInput, timeline: CurveTimeline, bezier: number, frame: number, value: number, time1: number, time2: number, value1: number, value2: number, scale: number): void;
     }
-	class BinaryInput {
-		strings: string[];
-		private index;
-		private buffer;
-		constructor(data: Uint8Array, strings?: string[], index?: number, buffer?: DataView);
-		readByte(): number;
-		readUnsignedByte(): number;
-		readShort(): number;
-		readInt32(): number;
-		readInt(optimizePositive: boolean): number;
-		readStringRef(): string;
-		readString(): string;
-		readFloat(): number;
-		readBoolean(): boolean;
-	}
-	export {};
 }
 declare module spine {
     class SkeletonBounds {
@@ -882,16 +793,6 @@ declare module spine {
         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;
-		private readTimeline;
-		private readTimeline2;
-		private readCurve;
-		setBezier(timeline: CurveTimeline, frame: number, value: number, bezier: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: 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 {
@@ -948,6 +849,12 @@ declare module spine {
         blendMode: BlendMode;
         constructor(index: number, name: string, boneData: BoneData);
     }
+    enum BlendMode {
+        Normal = 0,
+        Additive = 1,
+        Multiply = 2,
+        Screen = 3
+    }
 }
 declare module spine {
     abstract class Texture {
@@ -957,8 +864,6 @@ declare module spine {
         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,
@@ -1135,6 +1040,7 @@ declare module spine {
         clamp(): this;
         static rgba8888ToColor(color: Color, value: number): void;
         static rgb888ToColor(color: Color, value: number): void;
+        static fromString(hex: string): Color;
     }
     class MathUtils {
         static PI: number;
@@ -1178,6 +1084,7 @@ declare module spine {
         static toSinglePrecision(value: number): number;
         static webkit602BugfixHelper(alpha: number, blend: MixBlend): void;
         static contains<T>(array: Array<T>, element: T, identity?: boolean): boolean;
+        static enumValue(type: any, name: string): any;
     }
     class DebugUtils {
         static logBones(skeleton: Skeleton): void;
@@ -1263,17 +1170,6 @@ declare module spine {
         newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
     }
 }
-declare module spine {
-	enum AttachmentType {
-		Region = 0,
-		BoundingBox = 1,
-		Mesh = 2,
-		LinkedMesh = 3,
-		Path = 4,
-		Point = 5,
-		Clipping = 6
-	}
-}
 declare module spine {
     class BoundingBoxAttachment extends VertexAttachment {
         color: Color;
@@ -1335,14 +1231,25 @@ declare module spine {
 }
 declare module spine {
     class RegionAttachment extends Attachment {
-		static OX1: number;
+        x: number;
-		static OY1: number;
+        y: number;
-		static OX2: number;
+        scaleX: number;
-		static OY2: number;
+        scaleY: number;
-		static OX3: number;
+        rotation: number;
-		static OY3: number;
+        width: number;
-		static OX4: number;
+        height: number;
-		static OY4: 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;
+        copy(): Attachment;
         static X1: number;
         static Y1: number;
         static C1R: number;
@@ -1375,25 +1282,6 @@ declare module spine {
         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;
-		copy(): Attachment;
     }
 }
 declare module spine {

spine-ts/build/spine-core.d.ts

@@ -7,8 +7,6 @@ declare module spine {
         constructor(name: string, timelines: Array<Timeline>, duration: number);
         hasTimeline(ids: string[]): boolean;
         apply(skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-		static search(frames: ArrayLike<number>, time: number): number;
-		static search2(values: ArrayLike<number>, time: number, step: number): number;
     }
     enum MixBlend {
         setup = 0,
@@ -20,36 +18,17 @@ declare module spine {
         mixIn = 0,
         mixOut = 1
     }
-	enum Property {
-		rotate = 0,
-		x = 1,
-		y = 2,
-		scaleX = 3,
-		scaleY = 4,
-		shearX = 5,
-		shearY = 6,
-		rgb = 7,
-		alpha = 8,
-		rgb2 = 9,
-		attachment = 10,
-		deform = 11,
-		event = 12,
-		drawOrder = 13,
-		ikConstraint = 14,
-		transformConstraint = 15,
-		pathConstraintPosition = 16,
-		pathConstraintSpacing = 17,
-		pathConstraintMix = 18
-	}
     abstract class Timeline {
         propertyIds: string[];
         frames: ArrayLike<number>;
         constructor(frameCount: number, propertyIds: string[]);
         getPropertyIds(): string[];
-		abstract getFrameEntries(): number;
+        getFrameEntries(): number;
         getFrameCount(): number;
         getDuration(): number;
         abstract apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+        static search(frames: ArrayLike<number>, time: number): number;
+        static search2(values: ArrayLike<number>, time: number, step: number): number;
     }
     interface BoneTimeline {
         boneIndex: number;
@@ -58,10 +37,6 @@ declare module spine {
         slotIndex: number;
     }
     abstract class CurveTimeline extends Timeline {
-		static LINEAR: number;
-		static STEPPED: number;
-		static BEZIER: number;
-		static BEZIER_SIZE: number;
         protected curves: ArrayLike<number>;
         constructor(frameCount: number, bezierCount: number, propertyIds: string[]);
         setLinear(frame: number): void;
@@ -197,7 +172,6 @@ declare module spine {
         slotIndex: number;
         attachmentNames: Array<string>;
         constructor(frameCount: number, slotIndex: number);
-		getFrameEntries(): number;
         getFrameCount(): number;
         setFrame(frame: number, time: number, attachmentName: string): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
@@ -208,7 +182,7 @@ declare module spine {
         attachment: VertexAttachment;
         vertices: Array<ArrayLike<number>>;
         constructor(frameCount: number, bezierCount: number, slotIndex: number, attachment: VertexAttachment);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, time: number, vertices: ArrayLike<number>): void;
         setBezier(bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: number): void;
         getCurvePercent(time: number, frame: number): number;
@@ -218,7 +192,7 @@ declare module spine {
         static propertyIds: string[];
         events: Array<Event>;
         constructor(frameCount: number);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, event: Event): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
@@ -226,7 +200,7 @@ declare module spine {
         static propertyIds: string[];
         drawOrders: Array<Array<number>>;
         constructor(frameCount: number);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, time: number, drawOrder: Array<number>): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
@@ -268,11 +242,11 @@ declare module spine {
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
     class PathConstraintMixTimeline extends CurveTimeline {
-		pathConstraintIndex: number;
         static ENTRIES: number;
         static ROTATE: number;
         static X: number;
         static Y: number;
+        pathConstraintIndex: number;
         constructor(frameCount: number, bezierCount: number, pathConstraintIndex: number);
         getFrameEntries(): number;
         setFrame(frame: number, time: number, mixRotate: number, mixX: number, mixY: number): void;
@@ -281,15 +255,7 @@ declare module spine {
 }
 declare module spine {
     class AnimationState {
-		private static _emptyAnimation;
         private static emptyAnimation;
-		static SUBSEQUENT: number;
-		static FIRST: number;
-		static HOLD_SUBSEQUENT: number;
-		static HOLD_FIRST: number;
-		static HOLD_MIX: number;
-		static SETUP: number;
-		static CURRENT: number;
         data: AnimationStateData;
         tracks: TrackEntry[];
         timeScale: number;
@@ -461,14 +427,6 @@ declare module spine {
         newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
     }
 }
-declare module spine {
-	enum BlendMode {
-		Normal = 0,
-		Additive = 1,
-		Multiply = 2,
-		Screen = 3
-	}
-}
 declare module spine {
     class Bone implements Updatable {
         data: BoneData;
@@ -735,35 +693,7 @@ declare module spine {
     }
 }
 declare module spine {
-	export class SkeletonBinary {
+    class SkeletonBinary {
-		static AttachmentTypeValues: number[];
-		static TransformModeValues: TransformMode[];
-		static PositionModeValues: PositionMode[];
-		static SpacingModeValues: SpacingMode[];
-		static RotateModeValues: RotateMode[];
-		static BlendModeValues: BlendMode[];
-		static BONE_ROTATE: number;
-		static BONE_TRANSLATE: number;
-		static BONE_TRANSLATEX: number;
-		static BONE_TRANSLATEY: number;
-		static BONE_SCALE: number;
-		static BONE_SCALEX: number;
-		static BONE_SCALEY: number;
-		static BONE_SHEAR: number;
-		static BONE_SHEARX: number;
-		static BONE_SHEARY: number;
-		static SLOT_ATTACHMENT: number;
-		static SLOT_RGBA: number;
-		static SLOT_RGB: number;
-		static SLOT_RGBA2: number;
-		static SLOT_RGB2: number;
-		static SLOT_ALPHA: number;
-		static PATH_POSITION: number;
-		static PATH_SPACING: number;
-		static PATH_MIX: number;
-		static CURVE_LINEAR: number;
-		static CURVE_STEPPED: number;
-		static CURVE_BEZIER: number;
         scale: number;
         attachmentLoader: AttachmentLoader;
         private linkedMeshes;
@@ -775,26 +705,7 @@ declare module spine {
         private readFloatArray;
         private readShortArray;
         private readAnimation;
-		static readTimeline(input: BinaryInput, timeline: CurveTimeline1, scale: number): Timeline;
-		static readTimeline2(input: BinaryInput, timeline: CurveTimeline2, scale: number): Timeline;
-		static setBezier(input: BinaryInput, timeline: CurveTimeline, bezier: number, frame: number, value: number, time1: number, time2: number, value1: number, value2: number, scale: number): void;
     }
-	class BinaryInput {
-		strings: string[];
-		private index;
-		private buffer;
-		constructor(data: Uint8Array, strings?: string[], index?: number, buffer?: DataView);
-		readByte(): number;
-		readUnsignedByte(): number;
-		readShort(): number;
-		readInt32(): number;
-		readInt(optimizePositive: boolean): number;
-		readStringRef(): string;
-		readString(): string;
-		readFloat(): number;
-		readBoolean(): boolean;
-	}
-	export {};
 }
 declare module spine {
     class SkeletonBounds {
@@ -882,16 +793,6 @@ declare module spine {
         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;
-		private readTimeline;
-		private readTimeline2;
-		private readCurve;
-		setBezier(timeline: CurveTimeline, frame: number, value: number, bezier: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: 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 {
@@ -948,6 +849,12 @@ declare module spine {
         blendMode: BlendMode;
         constructor(index: number, name: string, boneData: BoneData);
     }
+    enum BlendMode {
+        Normal = 0,
+        Additive = 1,
+        Multiply = 2,
+        Screen = 3
+    }
 }
 declare module spine {
     abstract class Texture {
@@ -957,8 +864,6 @@ declare module spine {
         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,
@@ -1135,6 +1040,7 @@ declare module spine {
         clamp(): this;
         static rgba8888ToColor(color: Color, value: number): void;
         static rgb888ToColor(color: Color, value: number): void;
+        static fromString(hex: string): Color;
     }
     class MathUtils {
         static PI: number;
@@ -1178,6 +1084,7 @@ declare module spine {
         static toSinglePrecision(value: number): number;
         static webkit602BugfixHelper(alpha: number, blend: MixBlend): void;
         static contains<T>(array: Array<T>, element: T, identity?: boolean): boolean;
+        static enumValue(type: any, name: string): any;
     }
     class DebugUtils {
         static logBones(skeleton: Skeleton): void;
@@ -1263,17 +1170,6 @@ declare module spine {
         newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
     }
 }
-declare module spine {
-	enum AttachmentType {
-		Region = 0,
-		BoundingBox = 1,
-		Mesh = 2,
-		LinkedMesh = 3,
-		Path = 4,
-		Point = 5,
-		Clipping = 6
-	}
-}
 declare module spine {
     class BoundingBoxAttachment extends VertexAttachment {
         color: Color;
@@ -1335,14 +1231,25 @@ declare module spine {
 }
 declare module spine {
     class RegionAttachment extends Attachment {
-		static OX1: number;
+        x: number;
-		static OY1: number;
+        y: number;
-		static OX2: number;
+        scaleX: number;
-		static OY2: number;
+        scaleY: number;
-		static OX3: number;
+        rotation: number;
-		static OY3: number;
+        width: number;
-		static OX4: number;
+        height: number;
-		static OY4: 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;
+        copy(): Attachment;
         static X1: number;
         static Y1: number;
         static C1R: number;
@@ -1375,25 +1282,6 @@ declare module spine {
         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;
-		copy(): Attachment;
     }
 }
 declare module spine {

spine-ts/build/spine-player.d.ts

@@ -7,8 +7,6 @@ declare module spine {
         constructor(name: string, timelines: Array<Timeline>, duration: number);
         hasTimeline(ids: string[]): boolean;
         apply(skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-		static search(frames: ArrayLike<number>, time: number): number;
-		static search2(values: ArrayLike<number>, time: number, step: number): number;
     }
     enum MixBlend {
         setup = 0,
@@ -20,36 +18,17 @@ declare module spine {
         mixIn = 0,
         mixOut = 1
     }
-	enum Property {
-		rotate = 0,
-		x = 1,
-		y = 2,
-		scaleX = 3,
-		scaleY = 4,
-		shearX = 5,
-		shearY = 6,
-		rgb = 7,
-		alpha = 8,
-		rgb2 = 9,
-		attachment = 10,
-		deform = 11,
-		event = 12,
-		drawOrder = 13,
-		ikConstraint = 14,
-		transformConstraint = 15,
-		pathConstraintPosition = 16,
-		pathConstraintSpacing = 17,
-		pathConstraintMix = 18
-	}
     abstract class Timeline {
         propertyIds: string[];
         frames: ArrayLike<number>;
         constructor(frameCount: number, propertyIds: string[]);
         getPropertyIds(): string[];
-		abstract getFrameEntries(): number;
+        getFrameEntries(): number;
         getFrameCount(): number;
         getDuration(): number;
         abstract apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+        static search(frames: ArrayLike<number>, time: number): number;
+        static search2(values: ArrayLike<number>, time: number, step: number): number;
     }
     interface BoneTimeline {
         boneIndex: number;
@@ -58,10 +37,6 @@ declare module spine {
         slotIndex: number;
     }
     abstract class CurveTimeline extends Timeline {
-		static LINEAR: number;
-		static STEPPED: number;
-		static BEZIER: number;
-		static BEZIER_SIZE: number;
         protected curves: ArrayLike<number>;
         constructor(frameCount: number, bezierCount: number, propertyIds: string[]);
         setLinear(frame: number): void;
@@ -197,7 +172,6 @@ declare module spine {
         slotIndex: number;
         attachmentNames: Array<string>;
         constructor(frameCount: number, slotIndex: number);
-		getFrameEntries(): number;
         getFrameCount(): number;
         setFrame(frame: number, time: number, attachmentName: string): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
@@ -208,7 +182,7 @@ declare module spine {
         attachment: VertexAttachment;
         vertices: Array<ArrayLike<number>>;
         constructor(frameCount: number, bezierCount: number, slotIndex: number, attachment: VertexAttachment);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, time: number, vertices: ArrayLike<number>): void;
         setBezier(bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: number): void;
         getCurvePercent(time: number, frame: number): number;
@@ -218,7 +192,7 @@ declare module spine {
         static propertyIds: string[];
         events: Array<Event>;
         constructor(frameCount: number);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, event: Event): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
@@ -226,7 +200,7 @@ declare module spine {
         static propertyIds: string[];
         drawOrders: Array<Array<number>>;
         constructor(frameCount: number);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, time: number, drawOrder: Array<number>): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
@@ -268,11 +242,11 @@ declare module spine {
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
     class PathConstraintMixTimeline extends CurveTimeline {
-		pathConstraintIndex: number;
         static ENTRIES: number;
         static ROTATE: number;
         static X: number;
         static Y: number;
+        pathConstraintIndex: number;
         constructor(frameCount: number, bezierCount: number, pathConstraintIndex: number);
         getFrameEntries(): number;
         setFrame(frame: number, time: number, mixRotate: number, mixX: number, mixY: number): void;
@@ -281,15 +255,7 @@ declare module spine {
 }
 declare module spine {
     class AnimationState {
-		private static _emptyAnimation;
         private static emptyAnimation;
-		static SUBSEQUENT: number;
-		static FIRST: number;
-		static HOLD_SUBSEQUENT: number;
-		static HOLD_FIRST: number;
-		static HOLD_MIX: number;
-		static SETUP: number;
-		static CURRENT: number;
         data: AnimationStateData;
         tracks: TrackEntry[];
         timeScale: number;
@@ -461,14 +427,6 @@ declare module spine {
         newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
     }
 }
-declare module spine {
-	enum BlendMode {
-		Normal = 0,
-		Additive = 1,
-		Multiply = 2,
-		Screen = 3
-	}
-}
 declare module spine {
     class Bone implements Updatable {
         data: BoneData;
@@ -735,35 +693,7 @@ declare module spine {
     }
 }
 declare module spine {
-	export class SkeletonBinary {
+    class SkeletonBinary {
-		static AttachmentTypeValues: number[];
-		static TransformModeValues: TransformMode[];
-		static PositionModeValues: PositionMode[];
-		static SpacingModeValues: SpacingMode[];
-		static RotateModeValues: RotateMode[];
-		static BlendModeValues: BlendMode[];
-		static BONE_ROTATE: number;
-		static BONE_TRANSLATE: number;
-		static BONE_TRANSLATEX: number;
-		static BONE_TRANSLATEY: number;
-		static BONE_SCALE: number;
-		static BONE_SCALEX: number;
-		static BONE_SCALEY: number;
-		static BONE_SHEAR: number;
-		static BONE_SHEARX: number;
-		static BONE_SHEARY: number;
-		static SLOT_ATTACHMENT: number;
-		static SLOT_RGBA: number;
-		static SLOT_RGB: number;
-		static SLOT_RGBA2: number;
-		static SLOT_RGB2: number;
-		static SLOT_ALPHA: number;
-		static PATH_POSITION: number;
-		static PATH_SPACING: number;
-		static PATH_MIX: number;
-		static CURVE_LINEAR: number;
-		static CURVE_STEPPED: number;
-		static CURVE_BEZIER: number;
         scale: number;
         attachmentLoader: AttachmentLoader;
         private linkedMeshes;
@@ -775,26 +705,7 @@ declare module spine {
         private readFloatArray;
         private readShortArray;
         private readAnimation;
-		static readTimeline(input: BinaryInput, timeline: CurveTimeline1, scale: number): Timeline;
-		static readTimeline2(input: BinaryInput, timeline: CurveTimeline2, scale: number): Timeline;
-		static setBezier(input: BinaryInput, timeline: CurveTimeline, bezier: number, frame: number, value: number, time1: number, time2: number, value1: number, value2: number, scale: number): void;
     }
-	class BinaryInput {
-		strings: string[];
-		private index;
-		private buffer;
-		constructor(data: Uint8Array, strings?: string[], index?: number, buffer?: DataView);
-		readByte(): number;
-		readUnsignedByte(): number;
-		readShort(): number;
-		readInt32(): number;
-		readInt(optimizePositive: boolean): number;
-		readStringRef(): string;
-		readString(): string;
-		readFloat(): number;
-		readBoolean(): boolean;
-	}
-	export {};
 }
 declare module spine {
     class SkeletonBounds {
@@ -882,16 +793,6 @@ declare module spine {
         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;
-		private readTimeline;
-		private readTimeline2;
-		private readCurve;
-		setBezier(timeline: CurveTimeline, frame: number, value: number, bezier: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: 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 {
@@ -948,6 +849,12 @@ declare module spine {
         blendMode: BlendMode;
         constructor(index: number, name: string, boneData: BoneData);
     }
+    enum BlendMode {
+        Normal = 0,
+        Additive = 1,
+        Multiply = 2,
+        Screen = 3
+    }
 }
 declare module spine {
     abstract class Texture {
@@ -957,8 +864,6 @@ declare module spine {
         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,
@@ -1135,6 +1040,7 @@ declare module spine {
         clamp(): this;
         static rgba8888ToColor(color: Color, value: number): void;
         static rgb888ToColor(color: Color, value: number): void;
+        static fromString(hex: string): Color;
     }
     class MathUtils {
         static PI: number;
@@ -1178,6 +1084,7 @@ declare module spine {
         static toSinglePrecision(value: number): number;
         static webkit602BugfixHelper(alpha: number, blend: MixBlend): void;
         static contains<T>(array: Array<T>, element: T, identity?: boolean): boolean;
+        static enumValue(type: any, name: string): any;
     }
     class DebugUtils {
         static logBones(skeleton: Skeleton): void;
@@ -1263,17 +1170,6 @@ declare module spine {
         newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
     }
 }
-declare module spine {
-	enum AttachmentType {
-		Region = 0,
-		BoundingBox = 1,
-		Mesh = 2,
-		LinkedMesh = 3,
-		Path = 4,
-		Point = 5,
-		Clipping = 6
-	}
-}
 declare module spine {
     class BoundingBoxAttachment extends VertexAttachment {
         color: Color;
@@ -1335,14 +1231,25 @@ declare module spine {
 }
 declare module spine {
     class RegionAttachment extends Attachment {
-		static OX1: number;
+        x: number;
-		static OY1: number;
+        y: number;
-		static OX2: number;
+        scaleX: number;
-		static OY2: number;
+        scaleY: number;
-		static OX3: number;
+        rotation: number;
-		static OY3: number;
+        width: number;
-		static OX4: number;
+        height: number;
-		static OY4: 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;
+        copy(): Attachment;
         static X1: number;
         static Y1: number;
         static C1R: number;
@@ -1375,25 +1282,6 @@ declare module spine {
         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;
-		copy(): Attachment;
     }
 }
 declare module spine {
@@ -1456,7 +1344,7 @@ declare module spine.webgl {
         static DISABLE_UNPACK_PREMULTIPLIED_ALPHA_WEBGL: boolean;
         constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, image: HTMLImageElement | ImageBitmap, useMipMaps?: boolean);
         setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
-		static validateMagFilter(magFilter: TextureFilter): TextureFilter.Nearest | TextureFilter.Linear | TextureFilter.Linear;
+        static validateMagFilter(magFilter: TextureFilter): TextureFilter.Nearest | TextureFilter.Linear;
         setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
         update(useMipMaps: boolean): void;
         restore(): void;

spine-ts/build/spine-threejs.d.ts

@@ -7,8 +7,6 @@ declare module spine {
         constructor(name: string, timelines: Array<Timeline>, duration: number);
         hasTimeline(ids: string[]): boolean;
         apply(skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-		static search(frames: ArrayLike<number>, time: number): number;
-		static search2(values: ArrayLike<number>, time: number, step: number): number;
     }
     enum MixBlend {
         setup = 0,
@@ -20,36 +18,17 @@ declare module spine {
         mixIn = 0,
         mixOut = 1
     }
-	enum Property {
-		rotate = 0,
-		x = 1,
-		y = 2,
-		scaleX = 3,
-		scaleY = 4,
-		shearX = 5,
-		shearY = 6,
-		rgb = 7,
-		alpha = 8,
-		rgb2 = 9,
-		attachment = 10,
-		deform = 11,
-		event = 12,
-		drawOrder = 13,
-		ikConstraint = 14,
-		transformConstraint = 15,
-		pathConstraintPosition = 16,
-		pathConstraintSpacing = 17,
-		pathConstraintMix = 18
-	}
     abstract class Timeline {
         propertyIds: string[];
         frames: ArrayLike<number>;
         constructor(frameCount: number, propertyIds: string[]);
         getPropertyIds(): string[];
-		abstract getFrameEntries(): number;
+        getFrameEntries(): number;
         getFrameCount(): number;
         getDuration(): number;
         abstract apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+        static search(frames: ArrayLike<number>, time: number): number;
+        static search2(values: ArrayLike<number>, time: number, step: number): number;
     }
     interface BoneTimeline {
         boneIndex: number;
@@ -58,10 +37,6 @@ declare module spine {
         slotIndex: number;
     }
     abstract class CurveTimeline extends Timeline {
-		static LINEAR: number;
-		static STEPPED: number;
-		static BEZIER: number;
-		static BEZIER_SIZE: number;
         protected curves: ArrayLike<number>;
         constructor(frameCount: number, bezierCount: number, propertyIds: string[]);
         setLinear(frame: number): void;
@@ -197,7 +172,6 @@ declare module spine {
         slotIndex: number;
         attachmentNames: Array<string>;
         constructor(frameCount: number, slotIndex: number);
-		getFrameEntries(): number;
         getFrameCount(): number;
         setFrame(frame: number, time: number, attachmentName: string): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
@@ -208,7 +182,7 @@ declare module spine {
         attachment: VertexAttachment;
         vertices: Array<ArrayLike<number>>;
         constructor(frameCount: number, bezierCount: number, slotIndex: number, attachment: VertexAttachment);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, time: number, vertices: ArrayLike<number>): void;
         setBezier(bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: number): void;
         getCurvePercent(time: number, frame: number): number;
@@ -218,7 +192,7 @@ declare module spine {
         static propertyIds: string[];
         events: Array<Event>;
         constructor(frameCount: number);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, event: Event): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
@@ -226,7 +200,7 @@ declare module spine {
         static propertyIds: string[];
         drawOrders: Array<Array<number>>;
         constructor(frameCount: number);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, time: number, drawOrder: Array<number>): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
@@ -268,11 +242,11 @@ declare module spine {
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
     class PathConstraintMixTimeline extends CurveTimeline {
-		pathConstraintIndex: number;
         static ENTRIES: number;
         static ROTATE: number;
         static X: number;
         static Y: number;
+        pathConstraintIndex: number;
         constructor(frameCount: number, bezierCount: number, pathConstraintIndex: number);
         getFrameEntries(): number;
         setFrame(frame: number, time: number, mixRotate: number, mixX: number, mixY: number): void;
@@ -281,15 +255,7 @@ declare module spine {
 }
 declare module spine {
     class AnimationState {
-		private static _emptyAnimation;
         private static emptyAnimation;
-		static SUBSEQUENT: number;
-		static FIRST: number;
-		static HOLD_SUBSEQUENT: number;
-		static HOLD_FIRST: number;
-		static HOLD_MIX: number;
-		static SETUP: number;
-		static CURRENT: number;
         data: AnimationStateData;
         tracks: TrackEntry[];
         timeScale: number;
@@ -461,14 +427,6 @@ declare module spine {
         newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
     }
 }
-declare module spine {
-	enum BlendMode {
-		Normal = 0,
-		Additive = 1,
-		Multiply = 2,
-		Screen = 3
-	}
-}
 declare module spine {
     class Bone implements Updatable {
         data: BoneData;
@@ -735,35 +693,7 @@ declare module spine {
     }
 }
 declare module spine {
-	export class SkeletonBinary {
+    class SkeletonBinary {
-		static AttachmentTypeValues: number[];
-		static TransformModeValues: TransformMode[];
-		static PositionModeValues: PositionMode[];
-		static SpacingModeValues: SpacingMode[];
-		static RotateModeValues: RotateMode[];
-		static BlendModeValues: BlendMode[];
-		static BONE_ROTATE: number;
-		static BONE_TRANSLATE: number;
-		static BONE_TRANSLATEX: number;
-		static BONE_TRANSLATEY: number;
-		static BONE_SCALE: number;
-		static BONE_SCALEX: number;
-		static BONE_SCALEY: number;
-		static BONE_SHEAR: number;
-		static BONE_SHEARX: number;
-		static BONE_SHEARY: number;
-		static SLOT_ATTACHMENT: number;
-		static SLOT_RGBA: number;
-		static SLOT_RGB: number;
-		static SLOT_RGBA2: number;
-		static SLOT_RGB2: number;
-		static SLOT_ALPHA: number;
-		static PATH_POSITION: number;
-		static PATH_SPACING: number;
-		static PATH_MIX: number;
-		static CURVE_LINEAR: number;
-		static CURVE_STEPPED: number;
-		static CURVE_BEZIER: number;
         scale: number;
         attachmentLoader: AttachmentLoader;
         private linkedMeshes;
@@ -775,26 +705,7 @@ declare module spine {
         private readFloatArray;
         private readShortArray;
         private readAnimation;
-		static readTimeline(input: BinaryInput, timeline: CurveTimeline1, scale: number): Timeline;
-		static readTimeline2(input: BinaryInput, timeline: CurveTimeline2, scale: number): Timeline;
-		static setBezier(input: BinaryInput, timeline: CurveTimeline, bezier: number, frame: number, value: number, time1: number, time2: number, value1: number, value2: number, scale: number): void;
     }
-	class BinaryInput {
-		strings: string[];
-		private index;
-		private buffer;
-		constructor(data: Uint8Array, strings?: string[], index?: number, buffer?: DataView);
-		readByte(): number;
-		readUnsignedByte(): number;
-		readShort(): number;
-		readInt32(): number;
-		readInt(optimizePositive: boolean): number;
-		readStringRef(): string;
-		readString(): string;
-		readFloat(): number;
-		readBoolean(): boolean;
-	}
-	export {};
 }
 declare module spine {
     class SkeletonBounds {
@@ -882,16 +793,6 @@ declare module spine {
         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;
-		private readTimeline;
-		private readTimeline2;
-		private readCurve;
-		setBezier(timeline: CurveTimeline, frame: number, value: number, bezier: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: 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 {
@@ -948,6 +849,12 @@ declare module spine {
         blendMode: BlendMode;
         constructor(index: number, name: string, boneData: BoneData);
     }
+    enum BlendMode {
+        Normal = 0,
+        Additive = 1,
+        Multiply = 2,
+        Screen = 3
+    }
 }
 declare module spine {
     abstract class Texture {
@@ -957,8 +864,6 @@ declare module spine {
         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,
@@ -1135,6 +1040,7 @@ declare module spine {
         clamp(): this;
         static rgba8888ToColor(color: Color, value: number): void;
         static rgb888ToColor(color: Color, value: number): void;
+        static fromString(hex: string): Color;
     }
     class MathUtils {
         static PI: number;
@@ -1178,6 +1084,7 @@ declare module spine {
         static toSinglePrecision(value: number): number;
         static webkit602BugfixHelper(alpha: number, blend: MixBlend): void;
         static contains<T>(array: Array<T>, element: T, identity?: boolean): boolean;
+        static enumValue(type: any, name: string): any;
     }
     class DebugUtils {
         static logBones(skeleton: Skeleton): void;
@@ -1263,17 +1170,6 @@ declare module spine {
         newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
     }
 }
-declare module spine {
-	enum AttachmentType {
-		Region = 0,
-		BoundingBox = 1,
-		Mesh = 2,
-		LinkedMesh = 3,
-		Path = 4,
-		Point = 5,
-		Clipping = 6
-	}
-}
 declare module spine {
     class BoundingBoxAttachment extends VertexAttachment {
         color: Color;
@@ -1335,14 +1231,25 @@ declare module spine {
 }
 declare module spine {
     class RegionAttachment extends Attachment {
-		static OX1: number;
+        x: number;
-		static OY1: number;
+        y: number;
-		static OX2: number;
+        scaleX: number;
-		static OY2: number;
+        scaleY: number;
-		static OX3: number;
+        rotation: number;
-		static OY3: number;
+        width: number;
-		static OX4: number;
+        height: number;
-		static OY4: 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;
+        copy(): Attachment;
         static X1: number;
         static Y1: number;
         static C1R: number;
@@ -1375,25 +1282,6 @@ declare module spine {
         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;
-		copy(): Attachment;
     }
 }
 declare module spine {

spine-ts/build/spine-webgl.d.ts

@@ -7,8 +7,6 @@ declare module spine {
         constructor(name: string, timelines: Array<Timeline>, duration: number);
         hasTimeline(ids: string[]): boolean;
         apply(skeleton: Skeleton, lastTime: number, time: number, loop: boolean, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
-		static search(frames: ArrayLike<number>, time: number): number;
-		static search2(values: ArrayLike<number>, time: number, step: number): number;
     }
     enum MixBlend {
         setup = 0,
@@ -20,36 +18,17 @@ declare module spine {
         mixIn = 0,
         mixOut = 1
     }
-	enum Property {
-		rotate = 0,
-		x = 1,
-		y = 2,
-		scaleX = 3,
-		scaleY = 4,
-		shearX = 5,
-		shearY = 6,
-		rgb = 7,
-		alpha = 8,
-		rgb2 = 9,
-		attachment = 10,
-		deform = 11,
-		event = 12,
-		drawOrder = 13,
-		ikConstraint = 14,
-		transformConstraint = 15,
-		pathConstraintPosition = 16,
-		pathConstraintSpacing = 17,
-		pathConstraintMix = 18
-	}
     abstract class Timeline {
         propertyIds: string[];
         frames: ArrayLike<number>;
         constructor(frameCount: number, propertyIds: string[]);
         getPropertyIds(): string[];
-		abstract getFrameEntries(): number;
+        getFrameEntries(): number;
         getFrameCount(): number;
         getDuration(): number;
         abstract apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
+        static search(frames: ArrayLike<number>, time: number): number;
+        static search2(values: ArrayLike<number>, time: number, step: number): number;
     }
     interface BoneTimeline {
         boneIndex: number;
@@ -58,10 +37,6 @@ declare module spine {
         slotIndex: number;
     }
     abstract class CurveTimeline extends Timeline {
-		static LINEAR: number;
-		static STEPPED: number;
-		static BEZIER: number;
-		static BEZIER_SIZE: number;
         protected curves: ArrayLike<number>;
         constructor(frameCount: number, bezierCount: number, propertyIds: string[]);
         setLinear(frame: number): void;
@@ -197,7 +172,6 @@ declare module spine {
         slotIndex: number;
         attachmentNames: Array<string>;
         constructor(frameCount: number, slotIndex: number);
-		getFrameEntries(): number;
         getFrameCount(): number;
         setFrame(frame: number, time: number, attachmentName: string): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, events: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
@@ -208,7 +182,7 @@ declare module spine {
         attachment: VertexAttachment;
         vertices: Array<ArrayLike<number>>;
         constructor(frameCount: number, bezierCount: number, slotIndex: number, attachment: VertexAttachment);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, time: number, vertices: ArrayLike<number>): void;
         setBezier(bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: number): void;
         getCurvePercent(time: number, frame: number): number;
@@ -218,7 +192,7 @@ declare module spine {
         static propertyIds: string[];
         events: Array<Event>;
         constructor(frameCount: number);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, event: Event): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
@@ -226,7 +200,7 @@ declare module spine {
         static propertyIds: string[];
         drawOrders: Array<Array<number>>;
         constructor(frameCount: number);
-		getFrameEntries(): number;
+        getFrameCount(): number;
         setFrame(frame: number, time: number, drawOrder: Array<number>): void;
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
@@ -268,11 +242,11 @@ declare module spine {
         apply(skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection): void;
     }
     class PathConstraintMixTimeline extends CurveTimeline {
-		pathConstraintIndex: number;
         static ENTRIES: number;
         static ROTATE: number;
         static X: number;
         static Y: number;
+        pathConstraintIndex: number;
         constructor(frameCount: number, bezierCount: number, pathConstraintIndex: number);
         getFrameEntries(): number;
         setFrame(frame: number, time: number, mixRotate: number, mixX: number, mixY: number): void;
@@ -281,15 +255,7 @@ declare module spine {
 }
 declare module spine {
     class AnimationState {
-		private static _emptyAnimation;
         private static emptyAnimation;
-		static SUBSEQUENT: number;
-		static FIRST: number;
-		static HOLD_SUBSEQUENT: number;
-		static HOLD_FIRST: number;
-		static HOLD_MIX: number;
-		static SETUP: number;
-		static CURRENT: number;
         data: AnimationStateData;
         tracks: TrackEntry[];
         timeScale: number;
@@ -461,14 +427,6 @@ declare module spine {
         newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
     }
 }
-declare module spine {
-	enum BlendMode {
-		Normal = 0,
-		Additive = 1,
-		Multiply = 2,
-		Screen = 3
-	}
-}
 declare module spine {
     class Bone implements Updatable {
         data: BoneData;
@@ -735,35 +693,7 @@ declare module spine {
     }
 }
 declare module spine {
-	export class SkeletonBinary {
+    class SkeletonBinary {
-		static AttachmentTypeValues: number[];
-		static TransformModeValues: TransformMode[];
-		static PositionModeValues: PositionMode[];
-		static SpacingModeValues: SpacingMode[];
-		static RotateModeValues: RotateMode[];
-		static BlendModeValues: BlendMode[];
-		static BONE_ROTATE: number;
-		static BONE_TRANSLATE: number;
-		static BONE_TRANSLATEX: number;
-		static BONE_TRANSLATEY: number;
-		static BONE_SCALE: number;
-		static BONE_SCALEX: number;
-		static BONE_SCALEY: number;
-		static BONE_SHEAR: number;
-		static BONE_SHEARX: number;
-		static BONE_SHEARY: number;
-		static SLOT_ATTACHMENT: number;
-		static SLOT_RGBA: number;
-		static SLOT_RGB: number;
-		static SLOT_RGBA2: number;
-		static SLOT_RGB2: number;
-		static SLOT_ALPHA: number;
-		static PATH_POSITION: number;
-		static PATH_SPACING: number;
-		static PATH_MIX: number;
-		static CURVE_LINEAR: number;
-		static CURVE_STEPPED: number;
-		static CURVE_BEZIER: number;
         scale: number;
         attachmentLoader: AttachmentLoader;
         private linkedMeshes;
@@ -775,26 +705,7 @@ declare module spine {
         private readFloatArray;
         private readShortArray;
         private readAnimation;
-		static readTimeline(input: BinaryInput, timeline: CurveTimeline1, scale: number): Timeline;
-		static readTimeline2(input: BinaryInput, timeline: CurveTimeline2, scale: number): Timeline;
-		static setBezier(input: BinaryInput, timeline: CurveTimeline, bezier: number, frame: number, value: number, time1: number, time2: number, value1: number, value2: number, scale: number): void;
     }
-	class BinaryInput {
-		strings: string[];
-		private index;
-		private buffer;
-		constructor(data: Uint8Array, strings?: string[], index?: number, buffer?: DataView);
-		readByte(): number;
-		readUnsignedByte(): number;
-		readShort(): number;
-		readInt32(): number;
-		readInt(optimizePositive: boolean): number;
-		readStringRef(): string;
-		readString(): string;
-		readFloat(): number;
-		readBoolean(): boolean;
-	}
-	export {};
 }
 declare module spine {
     class SkeletonBounds {
@@ -882,16 +793,6 @@ declare module spine {
         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;
-		private readTimeline;
-		private readTimeline2;
-		private readCurve;
-		setBezier(timeline: CurveTimeline, frame: number, value: number, bezier: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number, cy2: number, time2: number, value2: 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 {
@@ -948,6 +849,12 @@ declare module spine {
         blendMode: BlendMode;
         constructor(index: number, name: string, boneData: BoneData);
     }
+    enum BlendMode {
+        Normal = 0,
+        Additive = 1,
+        Multiply = 2,
+        Screen = 3
+    }
 }
 declare module spine {
     abstract class Texture {
@@ -957,8 +864,6 @@ declare module spine {
         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,
@@ -1135,6 +1040,7 @@ declare module spine {
         clamp(): this;
         static rgba8888ToColor(color: Color, value: number): void;
         static rgb888ToColor(color: Color, value: number): void;
+        static fromString(hex: string): Color;
     }
     class MathUtils {
         static PI: number;
@@ -1178,6 +1084,7 @@ declare module spine {
         static toSinglePrecision(value: number): number;
         static webkit602BugfixHelper(alpha: number, blend: MixBlend): void;
         static contains<T>(array: Array<T>, element: T, identity?: boolean): boolean;
+        static enumValue(type: any, name: string): any;
     }
     class DebugUtils {
         static logBones(skeleton: Skeleton): void;
@@ -1263,17 +1170,6 @@ declare module spine {
         newClippingAttachment(skin: Skin, name: string): ClippingAttachment;
     }
 }
-declare module spine {
-	enum AttachmentType {
-		Region = 0,
-		BoundingBox = 1,
-		Mesh = 2,
-		LinkedMesh = 3,
-		Path = 4,
-		Point = 5,
-		Clipping = 6
-	}
-}
 declare module spine {
     class BoundingBoxAttachment extends VertexAttachment {
         color: Color;
@@ -1335,14 +1231,25 @@ declare module spine {
 }
 declare module spine {
     class RegionAttachment extends Attachment {
-		static OX1: number;
+        x: number;
-		static OY1: number;
+        y: number;
-		static OX2: number;
+        scaleX: number;
-		static OY2: number;
+        scaleY: number;
-		static OX3: number;
+        rotation: number;
-		static OY3: number;
+        width: number;
-		static OX4: number;
+        height: number;
-		static OY4: 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;
+        copy(): Attachment;
         static X1: number;
         static Y1: number;
         static C1R: number;
@@ -1375,25 +1282,6 @@ declare module spine {
         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;
-		copy(): Attachment;
     }
 }
 declare module spine {
@@ -1456,7 +1344,7 @@ declare module spine.webgl {
         static DISABLE_UNPACK_PREMULTIPLIED_ALPHA_WEBGL: boolean;
         constructor(context: ManagedWebGLRenderingContext | WebGLRenderingContext, image: HTMLImageElement | ImageBitmap, useMipMaps?: boolean);
         setFilters(minFilter: TextureFilter, magFilter: TextureFilter): void;
-		static validateMagFilter(magFilter: TextureFilter): TextureFilter.Nearest | TextureFilter.Linear | TextureFilter.Linear;
+        static validateMagFilter(magFilter: TextureFilter): TextureFilter.Nearest | TextureFilter.Linear;
         setWraps(uWrap: TextureWrap, vWrap: TextureWrap): void;
         update(useMipMaps: boolean): void;
         restore(): void;

spine-ts/core/src/Animation.ts

@@ -111,13 +111,31 @@ module spine {
 		mixIn, mixOut
 	}
 
-	export enum Property {
+	const Property = {
-		rotate, x, y, scaleX, scaleY, shearX, shearY, //
+		rotate: 0,
-		rgb, alpha, rgb2, //
+		x: 1,
-		attachment, deform, //
+		y: 2,
-		event, drawOrder, //
+		scaleX: 3,
-		ikConstraint, transformConstraint, //
+		scaleY: 4,
-		pathConstraintPosition, pathConstraintSpacing, pathConstraintMix
+		shearX: 5,
+		shearY: 6,
+
+		rgb: 7,
+		alpha: 8,
+		rgb2: 9,
+
+		attachment: 10,
+		deform: 11,
+
+		event: 12,
+		drawOrder: 13,
+
+		ikConstraint: 14,
+		transformConstraint: 15,
+
+		pathConstraintPosition: 16,
+		pathConstraintSpacing: 17,
+		pathConstraintMix: 18
 	}
 
 	/** The interface for all timelines. */
@@ -173,33 +191,33 @@ module spine {
 		slotIndex: number;
 	}
 
+	const LINEAR = 0; const STEPPED = 1; const BEZIER = 2;
+	const BEZIER_SIZE = 18;
+
 	/** The base class for timelines that use interpolation between key frame values. */
 	export abstract class CurveTimeline extends Timeline {
-		static LINEAR = 0; static STEPPED = 1; static BEZIER = 2;
-		static BEZIER_SIZE = 18;
-
 		protected curves: ArrayLike<number>; // type, x, y, ...
 
 		constructor (frameCount: number, bezierCount: number, propertyIds: string[]) {
 			super(frameCount, propertyIds);
-			this.curves = Utils.newFloatArray(frameCount + bezierCount * CurveTimeline.BEZIER_SIZE);
+			this.curves = Utils.newFloatArray(frameCount + bezierCount * BEZIER_SIZE);
-			this.curves[frameCount - 1] = CurveTimeline.STEPPED;
+			this.curves[frameCount - 1] = STEPPED;
 		}
 
 		/** Sets the specified key frame to linear interpolation. */
 		setLinear (frame: number) {
-			this.curves[frame] = CurveTimeline.LINEAR;
+			this.curves[frame] = LINEAR;
 		}
 
 		/** Sets the specified key frame to stepped interpolation. */
 		setStepped (frame: number) {
-			this.curves[frame] = CurveTimeline.STEPPED;
+			this.curves[frame] = STEPPED;
 		}
 
 		/** Shrinks the storage for Bezier curves, for use when <code>bezierCount</code> (specified in the constructor) was larger
 		 * than the actual number of Bezier curves. */
 		shrink (bezierCount: number) {
-			let size = this.getFrameCount() + bezierCount * CurveTimeline.BEZIER_SIZE;
+			let size = this.getFrameCount() + bezierCount * BEZIER_SIZE;
 			if (this.curves.length > size) {
 				let newCurves = Utils.newFloatArray(size);
 				Utils.arrayCopy(this.curves, 0, newCurves, 0, size);
@@ -224,14 +242,14 @@ module spine {
 		setBezier (bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number,
 			cy2: number, time2: number, value2: number) {
 			let curves = this.curves;
-			let i = this.getFrameCount() + bezier * CurveTimeline.BEZIER_SIZE;
+			let i = this.getFrameCount() + bezier * BEZIER_SIZE;
-			if (value == 0) curves[frame] = CurveTimeline.BEZIER + i;
+			if (value == 0) curves[frame] = BEZIER + i;
 			let tmpx = (time1 - cx1 * 2 + cx2) * 0.03, tmpy = (value1 - cy1 * 2 + cy2) * 0.03;
 			let dddx = ((cx1 - cx2) * 3 - time1 + time2) * 0.006, dddy = ((cy1 - cy2) * 3 - value1 + value2) * 0.006;
 			let ddx = tmpx * 2 + dddx, ddy = tmpy * 2 + dddy;
 			let dx = (cx1 - time1) * 0.3 + tmpx + dddx * 0.16666667, dy = (cy1 - value1) * 0.3 + tmpy + dddy * 0.16666667;
 			let x = time1 + dx, y = value1 + dy;
-			for (let n = i + CurveTimeline.BEZIER_SIZE; i < n; i += 2) {
+			for (let n = i + BEZIER_SIZE; i < n; i += 2) {
 				curves[i] = x;
 				curves[i + 1] = y;
 				dx += ddx;
@@ -250,10 +268,10 @@ module spine {
 		getBezierValue (time: number, frameIndex: number, valueOffset: number, i: number) {
 			let curves = this.curves;
 			if (curves[i] > time) {
-				let x = frames[frameIndex], y = frames[frameIndex + valueOffset];
+				let x = this.frames[frameIndex], y = this.frames[frameIndex + valueOffset];
 				return y + (time - x) / (curves[i] - x) * (curves[i + 1] - y);
 			}
-			let n = i + CurveTimeline.BEZIER_SIZE;
+			let n = i + BEZIER_SIZE;
 			for (i += 2; i < n; i += 2) {
 				if (curves[i] >= time) {
 					let x = curves[i - 2], y = curves[i - 1];
@@ -262,7 +280,7 @@ module spine {
 			}
 			frameIndex += this.getFrameEntries();
 			let x = curves[n - 2], y = curves[n - 1];
-			return y + (time - x) / (frames[frameIndex] - x) * (frames[frameIndex + valueOffset] - y);
+			return y + (time - x) / (this.frames[frameIndex] - x) * (this.frames[frameIndex + valueOffset] - y);
 		}
 	}
 
@@ -300,21 +318,20 @@ module spine {
 
 			let curveType = this.curves[i >> 1];
 			switch (curveType) {
-			case CurveTimeline.LINEAR:
+			case LINEAR:
 				let before = frames[i], value = frames[i + CurveTimeline1.VALUE];
 				return value + (time - before) / (frames[i + CurveTimeline1.ENTRIES] - before) * (frames[i + CurveTimeline1.ENTRIES + CurveTimeline1.VALUE] - value);
-			case CurveTimeline.STEPPED:
+			case STEPPED:
 				return frames[i + CurveTimeline1.VALUE];
 			}
-			return this.getBezierValue(time, i, CurveTimeline1.VALUE, curveType - CurveTimeline.BEZIER);
+			return this.getBezierValue(time, i, CurveTimeline1.VALUE, curveType - BEZIER);
 		}
 	}
 
 	/** The base class for a {@link CurveTimeline} which sets two properties. */
 	export abstract class CurveTimeline2 extends CurveTimeline {
 		static ENTRIES = 3;
-		static VALUE1 = 1;
+		static VALUE1 = 1; static VALUE2 = 2;
-		static VALUE2 = 2;
 
 		/** @param bezierCount The maximum number of Bezier curves. See {@link #shrink(int)}.
 		 * @param propertyIds Unique identifiers for the properties the timeline modifies. */
@@ -412,7 +429,7 @@ module spine {
 			let i = Timeline.search2(frames, time, CurveTimeline2.ENTRIES);
 			let curveType = this.curves[i / CurveTimeline2.ENTRIES];
 			switch (curveType) {
-			case CurveTimeline.LINEAR:
+			case LINEAR:
 				let before = frames[i];
 				x = frames[i + CurveTimeline2.VALUE1];
 				y = frames[i + CurveTimeline2.VALUE2];
@@ -420,13 +437,13 @@ module spine {
 				x += (frames[i + CurveTimeline2.ENTRIES + CurveTimeline2.VALUE1] - x) * t;
 				y += (frames[i + CurveTimeline2.ENTRIES + CurveTimeline2.VALUE2] - y) * t;
 				break;
-			case CurveTimeline.STEPPED:
+			case STEPPED:
 				x = frames[i + CurveTimeline2.VALUE1];
 				y = frames[i + CurveTimeline2.VALUE2];
 				break;
 			default:
-				x = this.getBezierValue(time, i, CurveTimeline2.VALUE1, curveType - CurveTimeline.BEZIER);
+				x = this.getBezierValue(time, i, CurveTimeline2.VALUE1, curveType - BEZIER);
-				y = this.getBezierValue(time, i, CurveTimeline2.VALUE2, curveType + CurveTimeline.BEZIER_SIZE - CurveTimeline.BEZIER);
+				y = this.getBezierValue(time, i, CurveTimeline2.VALUE2, curveType + BEZIER_SIZE - BEZIER);
 			}
 
 			switch (blend) {
@@ -564,7 +581,7 @@ module spine {
 			let i = Timeline.search2(frames, time, CurveTimeline2.ENTRIES);
 			let curveType = this.curves[i / CurveTimeline2.ENTRIES];
 			switch (curveType) {
-			case CurveTimeline.LINEAR:
+			case LINEAR:
 				let before = frames[i];
 				x = frames[i + CurveTimeline2.VALUE1];
 				y = frames[i + CurveTimeline2.VALUE2];
@@ -572,13 +589,13 @@ module spine {
 				x += (frames[i + CurveTimeline2.ENTRIES + CurveTimeline2.VALUE1] - x) * t;
 				y += (frames[i + CurveTimeline2.ENTRIES + CurveTimeline2.VALUE2] - y) * t;
 				break;
-			case CurveTimeline.STEPPED:
+			case STEPPED:
 				x = frames[i + CurveTimeline2.VALUE1];
 				y = frames[i + CurveTimeline2.VALUE2];
 				break;
 			default:
-				x = this.getBezierValue(time, i, CurveTimeline2.VALUE1, curveType - CurveTimeline.BEZIER);
+				x = this.getBezierValue(time, i, CurveTimeline2.VALUE1, curveType - BEZIER);
-				y = this.getBezierValue(time, i, CurveTimeline2.VALUE2, curveType + CurveTimeline.BEZIER_SIZE - CurveTimeline.BEZIER);
+				y = this.getBezierValue(time, i, CurveTimeline2.VALUE2, curveType + BEZIER_SIZE - BEZIER);
 			}
 			x *= bone.data.scaleX;
 			y *= bone.data.scaleY;
@@ -816,7 +833,7 @@ module spine {
 			let i = Timeline.search2(frames, time, CurveTimeline2.ENTRIES);
 			let curveType = this.curves[i / CurveTimeline2.ENTRIES];
 			switch (curveType) {
-			case CurveTimeline.LINEAR:
+			case LINEAR:
 				let before = frames[i];
 				x = frames[i + CurveTimeline2.VALUE1];
 				y = frames[i + CurveTimeline2.VALUE2];
@@ -824,13 +841,13 @@ module spine {
 				x += (frames[i + CurveTimeline2.ENTRIES + CurveTimeline2.VALUE1] - x) * t;
 				y += (frames[i + CurveTimeline2.ENTRIES + CurveTimeline2.VALUE2] - y) * t;
 				break;
-			case CurveTimeline.STEPPED:
+			case STEPPED:
 				x = frames[i + CurveTimeline2.VALUE1];
 				y = frames[i + CurveTimeline2.VALUE2];
 				break;
 			default:
-				x = this.getBezierValue(time, i, CurveTimeline2.VALUE1, curveType - CurveTimeline.BEZIER);
+				x = this.getBezierValue(time, i, CurveTimeline2.VALUE1, curveType - BEZIER);
-				y = this.getBezierValue(time, i, CurveTimeline2.VALUE2, curveType + CurveTimeline.BEZIER_SIZE - CurveTimeline.BEZIER);
+				y = this.getBezierValue(time, i, CurveTimeline2.VALUE2, curveType + BEZIER_SIZE - BEZIER);
 			}
 
 			switch (blend) {
@@ -937,7 +954,6 @@ module spine {
 	/** Changes a slot's {@link Slot#color}. */
 	export class RGBATimeline extends CurveTimeline implements SlotTimeline {
 		static ENTRIES = 5;
-
 		static R = 1; static G = 2; static B = 3; static A = 4;
 
 		slotIndex = 0;
@@ -987,7 +1003,7 @@ module spine {
 			let i = Timeline.search2(frames, time, RGBATimeline.ENTRIES);
 			let curveType = this.curves[i / RGBATimeline.ENTRIES];
 			switch (curveType) {
-			case CurveTimeline.LINEAR:
+			case LINEAR:
 				let before = frames[i];
 				r = frames[i + RGBATimeline.R];
 				g = frames[i + RGBATimeline.G];
@@ -999,17 +1015,17 @@ module spine {
 				b += (frames[i + RGBATimeline.ENTRIES + RGBATimeline.B] - b) * t;
 				a += (frames[i + RGBATimeline.ENTRIES + RGBATimeline.A] - a) * t;
 				break;
-			case CurveTimeline.STEPPED:
+			case STEPPED:
 				r = frames[i + RGBATimeline.R];
 				g = frames[i + RGBATimeline.G];
 				b = frames[i + RGBATimeline.B];
 				a = frames[i + RGBATimeline.A];
 				break;
 			default:
-				r = this.getBezierValue(time, i, RGBATimeline.R, curveType - CurveTimeline.BEZIER);
+				r = this.getBezierValue(time, i, RGBATimeline.R, curveType - BEZIER);
-				g = this.getBezierValue(time, i, RGBATimeline.G, curveType + CurveTimeline.BEZIER_SIZE - CurveTimeline.BEZIER);
+				g = this.getBezierValue(time, i, RGBATimeline.G, curveType + BEZIER_SIZE - BEZIER);
-				b = this.getBezierValue(time, i, RGBATimeline.B, curveType + CurveTimeline.BEZIER_SIZE * 2 - CurveTimeline.BEZIER);
+				b = this.getBezierValue(time, i, RGBATimeline.B, curveType + BEZIER_SIZE * 2 - BEZIER);
-				a = this.getBezierValue(time, i, RGBATimeline.A, curveType + CurveTimeline.BEZIER_SIZE * 3 - CurveTimeline.BEZIER);
+				a = this.getBezierValue(time, i, RGBATimeline.A, curveType + BEZIER_SIZE * 3 - BEZIER);
 			}
 			if (alpha == 1)
 				color.set(r, g, b, a);
@@ -1023,7 +1039,6 @@ module spine {
 	/** Changes a slot's {@link Slot#color}. */
 	export class RGBTimeline extends CurveTimeline implements SlotTimeline {
 		static ENTRIES = 4;
-
 		static R = 1; static G = 2; static B = 3;
 
 		slotIndex = 0;
@@ -1074,7 +1089,7 @@ module spine {
 			let i = Timeline.search2(frames, time, RGBTimeline.ENTRIES);
 			let curveType = this.curves[i >> 2];
 			switch (curveType) {
-			case CurveTimeline.LINEAR:
+			case LINEAR:
 				let before = frames[i];
 				r = frames[i + RGBTimeline.R];
 				g = frames[i + RGBTimeline.G];
@@ -1084,15 +1099,15 @@ module spine {
 				g += (frames[i + RGBTimeline.ENTRIES + RGBTimeline.G] - g) * t;
 				b += (frames[i + RGBTimeline.ENTRIES + RGBTimeline.B] - b) * t;
 				break;
-			case CurveTimeline.STEPPED:
+			case STEPPED:
 				r = frames[i + RGBTimeline.R];
 				g = frames[i + RGBTimeline.G];
 				b = frames[i + RGBTimeline.B];
 				break;
 			default:
-				r = this.getBezierValue(time, i, RGBTimeline.R, curveType - CurveTimeline.BEZIER);
+				r = this.getBezierValue(time, i, RGBTimeline.R, curveType - BEZIER);
-				g = this.getBezierValue(time, i, RGBTimeline.G, curveType + CurveTimeline.BEZIER_SIZE - CurveTimeline.BEZIER);
+				g = this.getBezierValue(time, i, RGBTimeline.G, curveType + BEZIER_SIZE - BEZIER);
-				b = this.getBezierValue(time, i, RGBTimeline.B, curveType + CurveTimeline.BEZIER_SIZE * 2 - CurveTimeline.BEZIER);
+				b = this.getBezierValue(time, i, RGBTimeline.B, curveType + BEZIER_SIZE * 2 - BEZIER);
 			}
 			if (alpha == 1) {
 				color.r = r;
@@ -1153,7 +1168,6 @@ module spine {
 	/** Changes a slot's {@link Slot#color} and {@link Slot#darkColor} for two color tinting. */
 	export class RGBA2Timeline extends CurveTimeline implements SlotTimeline{
 		static ENTRIES = 8;
-
 		static R = 1; static G = 2; static B = 3; static A = 4; static R2 = 5; static G2 = 6; static B2 = 7;
 
 		slotIndex = 0;
@@ -1213,7 +1227,7 @@ module spine {
 			let i = Timeline.search2(frames, time, RGBA2Timeline.ENTRIES);
 			let curveType = this.curves[i >> 3];
 			switch (curveType) {
-			case CurveTimeline.LINEAR:
+			case LINEAR:
 				let before = frames[i];
 				r = frames[i + RGBA2Timeline.R];
 				g = frames[i + RGBA2Timeline.G];
@@ -1231,7 +1245,7 @@ module spine {
 				g2 += (frames[i + RGBA2Timeline.ENTRIES + RGBA2Timeline.G2] - g2) * t;
 				b2 += (frames[i + RGBA2Timeline.ENTRIES + RGBA2Timeline.B2] - b2) * t;
 				break;
-			case CurveTimeline.STEPPED:
+			case STEPPED:
 				r = frames[i + RGBA2Timeline.R];
 				g = frames[i + RGBA2Timeline.G];
 				b = frames[i + RGBA2Timeline.B];
@@ -1241,13 +1255,13 @@ module spine {
 				b2 = frames[i + RGBA2Timeline.B2];
 				break;
 			default:
-				r = this.getBezierValue(time, i, RGBA2Timeline.R, curveType - CurveTimeline.BEZIER);
+				r = this.getBezierValue(time, i, RGBA2Timeline.R, curveType - BEZIER);
-				g = this.getBezierValue(time, i, RGBA2Timeline.G, curveType + CurveTimeline.BEZIER_SIZE - CurveTimeline.BEZIER);
+				g = this.getBezierValue(time, i, RGBA2Timeline.G, curveType + BEZIER_SIZE - BEZIER);
-				b = this.getBezierValue(time, i, RGBA2Timeline.B, curveType + CurveTimeline.BEZIER_SIZE * 2 - CurveTimeline.BEZIER);
+				b = this.getBezierValue(time, i, RGBA2Timeline.B, curveType + BEZIER_SIZE * 2 - BEZIER);
-				a = this.getBezierValue(time, i, RGBA2Timeline.A, curveType + CurveTimeline.BEZIER_SIZE * 3 - CurveTimeline.BEZIER);
+				a = this.getBezierValue(time, i, RGBA2Timeline.A, curveType + BEZIER_SIZE * 3 - BEZIER);
-				r2 = this.getBezierValue(time, i, RGBA2Timeline.R2, curveType + CurveTimeline.BEZIER_SIZE * 4 - CurveTimeline.BEZIER);
+				r2 = this.getBezierValue(time, i, RGBA2Timeline.R2, curveType + BEZIER_SIZE * 4 - BEZIER);
-				g2 = this.getBezierValue(time, i, RGBA2Timeline.G2, curveType + CurveTimeline.BEZIER_SIZE * 5 - CurveTimeline.BEZIER);
+				g2 = this.getBezierValue(time, i, RGBA2Timeline.G2, curveType + BEZIER_SIZE * 5 - BEZIER);
-				b2 = this.getBezierValue(time, i, RGBA2Timeline.B2, curveType + CurveTimeline.BEZIER_SIZE * 6 - CurveTimeline.BEZIER);
+				b2 = this.getBezierValue(time, i, RGBA2Timeline.B2, curveType + BEZIER_SIZE * 6 - BEZIER);
 			}
 
 			if (alpha == 1) {
@@ -1271,7 +1285,6 @@ module spine {
 	/** Changes a slot's {@link Slot#color} and {@link Slot#darkColor} for two color tinting. */
 	export class RGB2Timeline extends CurveTimeline implements SlotTimeline{
 		static ENTRIES = 7;
-
 		static R = 1; static G = 2; static B = 3; static R2 = 4; static G2 = 5; static B2 = 6;
 
 		slotIndex = 0;
@@ -1332,7 +1345,7 @@ module spine {
 			let i = Timeline.search2(frames, time, RGB2Timeline.ENTRIES);
 			let curveType = this.curves[i / RGB2Timeline.ENTRIES];
 			switch (curveType) {
-			case CurveTimeline.LINEAR:
+			case LINEAR:
 				let before = frames[i];
 				r = frames[i + RGB2Timeline.R];
 				g = frames[i + RGB2Timeline.G];
@@ -1348,7 +1361,7 @@ module spine {
 				g2 += (frames[i + RGB2Timeline.ENTRIES + RGB2Timeline.G2] - g2) * t;
 				b2 += (frames[i + RGB2Timeline.ENTRIES + RGB2Timeline.B2] - b2) * t;
 				break;
-			case CurveTimeline.STEPPED:
+			case STEPPED:
 				r = frames[i + RGB2Timeline.R];
 				g = frames[i + RGB2Timeline.G];
 				b = frames[i + RGB2Timeline.B];
@@ -1357,12 +1370,12 @@ module spine {
 				b2 = frames[i + RGB2Timeline.B2];
 				break;
 			default:
-				r = this.getBezierValue(time, i, RGB2Timeline.R, curveType - CurveTimeline.BEZIER);
+				r = this.getBezierValue(time, i, RGB2Timeline.R, curveType - BEZIER);
-				g = this.getBezierValue(time, i, RGB2Timeline.G, curveType + CurveTimeline.BEZIER_SIZE - CurveTimeline.BEZIER);
+				g = this.getBezierValue(time, i, RGB2Timeline.G, curveType + BEZIER_SIZE - BEZIER);
-				b = this.getBezierValue(time, i, RGB2Timeline.B, curveType + CurveTimeline.BEZIER_SIZE * 2 - CurveTimeline.BEZIER);
+				b = this.getBezierValue(time, i, RGB2Timeline.B, curveType + BEZIER_SIZE * 2 - BEZIER);
-				r2 = this.getBezierValue(time, i, RGB2Timeline.R2, curveType + CurveTimeline.BEZIER_SIZE * 3 - CurveTimeline.BEZIER);
+				r2 = this.getBezierValue(time, i, RGB2Timeline.R2, curveType + BEZIER_SIZE * 3 - BEZIER);
-				g2 = this.getBezierValue(time, i, RGB2Timeline.G2, curveType + CurveTimeline.BEZIER_SIZE * 4 - CurveTimeline.BEZIER);
+				g2 = this.getBezierValue(time, i, RGB2Timeline.G2, curveType + BEZIER_SIZE * 4 - BEZIER);
-				b2 = this.getBezierValue(time, i, RGB2Timeline.B2, curveType + CurveTimeline.BEZIER_SIZE * 5 - CurveTimeline.BEZIER);
+				b2 = this.getBezierValue(time, i, RGB2Timeline.B2, curveType + BEZIER_SIZE * 5 - BEZIER);
 			}
 
 			if (alpha == 1) {
@@ -1474,14 +1487,14 @@ module spine {
 		setBezier (bezier: number, frame: number, value: number, time1: number, value1: number, cx1: number, cy1: number, cx2: number,
 			cy2: number, time2: number, value2: number) {
 			let curves = this.curves;
-			let i = this.getFrameCount() + bezier * CurveTimeline.BEZIER_SIZE;
+			let i = this.getFrameCount() + bezier * BEZIER_SIZE;
-			if (value == 0) curves[frame] = CurveTimeline.BEZIER + i;
+			if (value == 0) curves[frame] = BEZIER + i;
 			let tmpx = (time1 - cx1 * 2 + cx2) * 0.03, tmpy = cy2 * 0.03 - cy1 * 0.06;
 			let dddx = ((cx1 - cx2) * 3 - time1 + time2) * 0.006, dddy = (cy1 - cy2 + 0.33333333) * 0.018;
 			let ddx = tmpx * 2 + dddx, ddy = tmpy * 2 + dddy;
 			let dx = (cx1 - time1) * 0.3 + tmpx + dddx * 0.16666667, dy = cy1 * 0.3 + tmpy + dddy * 0.16666667;
 			let x = time1 + dx, y = dy;
-			for (let n = i + CurveTimeline.BEZIER_SIZE; i < n; i += 2) {
+			for (let n = i + BEZIER_SIZE; i < n; i += 2) {
 				curves[i] = x;
 				curves[i + 1] = y;
 				dx += ddx;
@@ -1497,18 +1510,18 @@ module spine {
 			let curves = this.curves;
 			let i = curves[frame];
 			switch (i) {
-			case CurveTimeline.LINEAR:
+			case LINEAR:
-				let x = frames[frame];
+				let x = this.frames[frame];
-				return (time - x) / (frames[frame + this.getFrameEntries()] - x);
+				return (time - x) / (this.frames[frame + this.getFrameEntries()] - x);
-			case CurveTimeline.STEPPED:
+			case STEPPED:
 				return 0;
 			}
-			i -= CurveTimeline.BEZIER;
+			i -= BEZIER;
 			if (curves[i] > time) {
-				let x = frames[frame];
+				let x = this.frames[frame];
 				return curves[i + 1] * (time - x) / (curves[i] - x);
 			}
-			let n = i + CurveTimeline.BEZIER_SIZE;
+			let n = i + BEZIER_SIZE;
 			for (i += 2; i < n; i += 2) {
 				if (curves[i] >= time) {
 					let x = curves[i - 2], y = curves[i - 1];
@@ -1516,7 +1529,7 @@ module spine {
 				}
 			}
 			let x = curves[n - 2], y = curves[n - 1];
-			return y + (1 - y) * (time - x) / (frames[frame + this.getFrameEntries()] - x);
+			return y + (1 - y) * (time - x) / (this.frames[frame + this.getFrameEntries()] - x);
 		}
 
 		apply (skeleton: Skeleton, lastTime: number, time: number, firedEvents: Array<Event>, alpha: number, blend: MixBlend, direction: MixDirection) {
@@ -1777,12 +1790,12 @@ module spine {
 				return;
 			}
 
-			if (time < frames[0]) {
+			if (time < this.frames[0]) {
 				if (blend == MixBlend.setup || blend == MixBlend.first) Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
 				return;
 			}
 
-			let drawOrderToSetupIndex = this.drawOrders[Timeline.search(frames, time)];
+			let drawOrderToSetupIndex = this.drawOrders[Timeline.search(this.frames, time)];
 			if (drawOrderToSetupIndex == null)
 				Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
 			else {
@@ -1798,7 +1811,6 @@ module spine {
 	 * {@link IkConstraint#bendDirection}, {@link IkConstraint#stretch}, and {@link IkConstraint#compress}. */
 	export class IkConstraintTimeline extends CurveTimeline {
 		static ENTRIES = 6;
-
 		static MIX = 1; static SOFTNESS = 2; static BEND_DIRECTION = 3; static COMPRESS = 4; static STRETCH = 5;
 
 		/** The index of the IK constraint slot in {@link Skeleton#ikConstraints} that will be changed. */
@@ -1854,7 +1866,7 @@ module spine {
 			let i = Timeline.search2(frames, time, IkConstraintTimeline.ENTRIES)
 			let curveType = this.curves[i / IkConstraintTimeline.ENTRIES];
 			switch (curveType) {
-			case CurveTimeline.LINEAR:
+			case LINEAR:
 				let before = frames[i];
 				mix = frames[i + IkConstraintTimeline.MIX];
 				softness = frames[i + IkConstraintTimeline.SOFTNESS];
@@ -1862,13 +1874,13 @@ module spine {
 				mix += (frames[i + IkConstraintTimeline.ENTRIES + IkConstraintTimeline.MIX] - mix) * t;
 				softness += (frames[i + IkConstraintTimeline.ENTRIES + IkConstraintTimeline.SOFTNESS] - softness) * t;
 				break;
-			case CurveTimeline.STEPPED:
+			case STEPPED:
 				mix = frames[i + IkConstraintTimeline.MIX];
 				softness = frames[i + IkConstraintTimeline.SOFTNESS];
 				break;
 			default:
-				mix = this.getBezierValue(time, i, IkConstraintTimeline.MIX, curveType - CurveTimeline.BEZIER);
+				mix = this.getBezierValue(time, i, IkConstraintTimeline.MIX, curveType - BEZIER);
-				softness = this.getBezierValue(time, i, IkConstraintTimeline.SOFTNESS, curveType + CurveTimeline.BEZIER_SIZE - CurveTimeline.BEZIER);
+				softness = this.getBezierValue(time, i, IkConstraintTimeline.SOFTNESS, curveType + BEZIER_SIZE - BEZIER);
 			}
 
 			if (blend == MixBlend.setup) {
@@ -1900,7 +1912,6 @@ module spine {
 	 * {@link TransformConstraint#scaleMix}, and {@link TransformConstraint#shearMix}. */
 	export class TransformConstraintTimeline extends CurveTimeline {
 		static ENTRIES = 7;
-
 		static ROTATE = 1; static X = 2; static Y = 3; static SCALEX = 4; static SCALEY = 5; static SHEARY = 6;
 
 		/** The index of the transform constraint slot in {@link Skeleton#transformConstraints} that will be changed. */
@@ -1958,18 +1969,17 @@ module spine {
 				return;
 			}
 
-			let rotate, x, y, scaleX, scaleY, shearY;
+			let X = TransformConstraintTimeline.X, Y = TransformConstraintTimeline.Y;
-			let i = Timeline.search2(frames, time, TransformConstraintTimeline.ENTRIES);
+			let SCALEX = TransformConstraintTimeline.SCALEX, SCALEY = TransformConstraintTimeline.SCALEY;
-			let curveType = this.curves[i / TransformConstraintTimeline.ENTRIES];
-			let ROTATE = TransformConstraintTimeline.ROTATE;
-			let X = TransformConstraintTimeline.X;
-			let Y = TransformConstraintTimeline.Y;
-			let SCALEX = TransformConstraintTimeline.SCALEX;
-			let SCALEY = TransformConstraintTimeline.SCALEY;
 			let SHEARY = TransformConstraintTimeline.SHEARY;
 			let ENTRIES = TransformConstraintTimeline.ENTRIES;
+
+			let rotate, x, y, scaleX, scaleY, shearY;
+			let i = Timeline.search2(frames, time, ENTRIES);
+			let curveType = this.curves[i / ENTRIES];
+			let ROTATE = TransformConstraintTimeline.ROTATE;
 			switch (curveType) {
-			case CurveTimeline.LINEAR:
+			case LINEAR:
 				let before = frames[i];
 				rotate = frames[i + ROTATE];
 				x = frames[i + X];
@@ -1985,7 +1995,7 @@ module spine {
 				scaleY += (frames[i + ENTRIES + SCALEY] - scaleY) * t;
 				shearY += (frames[i + ENTRIES + SHEARY] - shearY) * t;
 				break;
-			case CurveTimeline.STEPPED:
+			case STEPPED:
 				rotate = frames[i + ROTATE];
 				x = frames[i + X];
 				y = frames[i + Y];
@@ -1994,12 +2004,12 @@ module spine {
 				shearY = frames[i + SHEARY];
 				break;
 			default:
-				rotate = this.getBezierValue(time, i, ROTATE, curveType - CurveTimeline.BEZIER);
+				rotate = this.getBezierValue(time, i, ROTATE, curveType - BEZIER);
-				x = this.getBezierValue(time, i, X, curveType + CurveTimeline.BEZIER_SIZE - CurveTimeline.BEZIER);
+				x = this.getBezierValue(time, i, X, curveType + BEZIER_SIZE - BEZIER);
-				y = this.getBezierValue(time, i, Y, curveType + CurveTimeline.BEZIER_SIZE * 2 - CurveTimeline.BEZIER);
+				y = this.getBezierValue(time, i, Y, curveType + BEZIER_SIZE * 2 - BEZIER);
-				scaleX = this.getBezierValue(time, i, SCALEX, curveType + CurveTimeline.BEZIER_SIZE * 3 - CurveTimeline.BEZIER);
+				scaleX = this.getBezierValue(time, i, SCALEX, curveType + BEZIER_SIZE * 3 - BEZIER);
-				scaleY = this.getBezierValue(time, i, SCALEY, curveType + CurveTimeline.BEZIER_SIZE * 4 - CurveTimeline.BEZIER);
+				scaleY = this.getBezierValue(time, i, SCALEY, curveType + BEZIER_SIZE * 4 - BEZIER);
-				shearY = this.getBezierValue(time, i, SHEARY, curveType + CurveTimeline.BEZIER_SIZE * 5 - CurveTimeline.BEZIER);
+				shearY = this.getBezierValue(time, i, SHEARY, curveType + BEZIER_SIZE * 5 - BEZIER);
 			}
 
 			if (blend == MixBlend.setup) {
@@ -2148,7 +2158,7 @@ module spine {
 			let i = Timeline.search2(frames, time, PathConstraintMixTimeline.ENTRIES);
 			let curveType = this.curves[i >> 2];
 			switch (curveType) {
-			case CurveTimeline.LINEAR:
+			case LINEAR:
 				let before = frames[i];
 				rotate = frames[i + PathConstraintMixTimeline.ROTATE];
 				x = frames[i + PathConstraintMixTimeline.X];
@@ -2158,15 +2168,15 @@ module spine {
 				x += (frames[i + PathConstraintMixTimeline.ENTRIES + PathConstraintMixTimeline.X] - x) * t;
 				y += (frames[i + PathConstraintMixTimeline.ENTRIES + PathConstraintMixTimeline.Y] - y) * t;
 				break;
-			case CurveTimeline.STEPPED:
+			case STEPPED:
 				rotate = frames[i + PathConstraintMixTimeline.ROTATE];
 				x = frames[i + PathConstraintMixTimeline.X];
 				y = frames[i + PathConstraintMixTimeline.Y];
 				break;
 			default:
-				rotate = this.getBezierValue(time, i, PathConstraintMixTimeline.ROTATE, curveType - CurveTimeline.BEZIER);
+				rotate = this.getBezierValue(time, i, PathConstraintMixTimeline.ROTATE, curveType - BEZIER);
-				x = this.getBezierValue(time, i, PathConstraintMixTimeline.X, curveType + CurveTimeline.BEZIER_SIZE - CurveTimeline.BEZIER);
+				x = this.getBezierValue(time, i, PathConstraintMixTimeline.X, curveType + BEZIER_SIZE - BEZIER);
-				y = this.getBezierValue(time, i, PathConstraintMixTimeline.Y, curveType + CurveTimeline.BEZIER_SIZE * 2 - CurveTimeline.BEZIER);
+				y = this.getBezierValue(time, i, PathConstraintMixTimeline.Y, curveType + BEZIER_SIZE * 2 - BEZIER);
 			}
 
 			if (blend == MixBlend.setup) {

spine-ts/core/src/AnimationState.ts

@@ -34,51 +34,11 @@ module spine {
 	 *
 	 * See [Applying Animations](http://esotericsoftware.com/spine-applying-animations/) in the Spine Runtimes Guide. */
 	export class AnimationState {
-		private static _emptyAnimation: Animation = null;
-
 		private static emptyAnimation(): Animation {
-			if (AnimationState._emptyAnimation == null) AnimationState._emptyAnimation = new Animation("<empty>", [], 0);
+			if (_emptyAnimation == null) _emptyAnimation = new Animation("<empty>", [], 0);
-			return AnimationState._emptyAnimation;
+			return _emptyAnimation;
 		}
 
-		/** 1. A previously applied timeline has set this property.
-		 *
-	 	 * Result: Mix from the current pose to the timeline pose. */
-		static SUBSEQUENT = 0;
-		/** 1. This is the first timeline to set this property.
-		 * 2. The next track entry applied after this one does not have a timeline to set this property.
-		 *
-		 * Result: Mix from the setup pose to the timeline pose. */
-		static FIRST = 1;
-		/** 1) A previously applied timeline has set this property.<br>
-	 	 * 2) The next track entry to be applied does have a timeline to set this property.<br>
-	 	 * 3) The next track entry after that one does not have a timeline to set this property.<br>
-	 	 * Result: Mix from the current pose to the timeline pose, but do not mix out. This avoids "dipping" when crossfading
-	 	 * animations that key the same property. A subsequent timeline will set this property using a mix. */
-		static HOLD_SUBSEQUENT = 2;
-		/** 1) This is the first timeline to set this property.<br>
-		 * 2) The next track entry to be applied does have a timeline to set this property.<br>
-		 * 3) The next track entry after that one does not have a timeline to set this property.<br>
-		 * Result: Mix from the setup pose to the timeline pose, but do not mix out. This avoids "dipping" when crossfading animations
-		 * that key the same property. A subsequent timeline will set this property using a mix. */
-		static HOLD_FIRST = 3;
-		/** 1. This is the first timeline to set this property.
-		 * 2. The next track entry to be applied does have a timeline to set this property.
-		 * 3. The next track entry after that one does have a timeline to set this property.
-		 * 4. timelineHoldMix stores the first subsequent track entry that does not have a timeline to set this property.
-		 *
-		 * Result: The same as HOLD except the mix percentage from the timelineHoldMix track entry is used. This handles when more than
-		 * 2 track entries in a row have a timeline that sets the same property.
-		 *
-		 * Eg, A -> B -> C -> D where A, B, and C have a timeline setting same property, but D does not. When A is applied, to avoid
-		 * "dipping" A is not mixed out, however D (the first entry that doesn't set the property) mixing in is used to mix out A
-		 * (which affects B and C). Without using D to mix out, A would be applied fully until mixing completes, then snap into
-		 * place. */
-		static HOLD_MIX = 4;
-
-		static SETUP = 1;
-		static CURRENT = 2;
-
 		/** The AnimationStateData to look up mix durations. */
 		data: AnimationStateData;
 
@@ -243,7 +203,7 @@ module spine {
 
 					for (let ii = 0; ii < timelineCount; ii++) {
 						let timeline = timelines[ii];
-						let timelineBlend = timelineMode[ii] == AnimationState.SUBSEQUENT ? blend : MixBlend.setup;
+						let timelineBlend = timelineMode[ii] == SUBSEQUENT ? blend : MixBlend.setup;
 						if (timeline instanceof RotateTimeline) {
 							this.applyRotateTimeline(timeline, skeleton, applyTime, mix, timelineBlend, timelinesRotation, ii << 1, firstFrame);
 						} else if (timeline instanceof AttachmentTimeline) {
@@ -264,7 +224,7 @@ module spine {
 			// Set slots attachments to the setup pose, if needed. This occurs if an animation that is mixing out sets attachments so
 			// subsequent timelines see any deform, but the subsequent timelines don't set an attachment (eg they are also mixing out or
 			// the time is before the first key).
-			var setupState = this.unkeyedState + AnimationState.SETUP;
+			var setupState = this.unkeyedState + SETUP;
 			var slots = skeleton.slots;
 			for (var i = 0, n = skeleton.slots.length; i < n; i++) {
 				var slot = slots[i];
@@ -322,20 +282,20 @@ module spine {
 					let timelineBlend: MixBlend;
 					let alpha = 0;
 					switch (timelineMode[i]) {
-					case AnimationState.SUBSEQUENT:
+					case SUBSEQUENT:
 						if (!drawOrder && timeline instanceof DrawOrderTimeline) continue;
 						timelineBlend = blend;
 						alpha = alphaMix;
 						break;
-					case AnimationState.FIRST:
+					case FIRST:
 						timelineBlend = MixBlend.setup;
 						alpha = alphaMix;
 						break;
-					case AnimationState.HOLD_SUBSEQUENT:
+					case HOLD_SUBSEQUENT:
 						timelineBlend = blend;
 						alpha = alphaHold;
 						break;
-					case AnimationState.HOLD_FIRST:
+					case HOLD_FIRST:
 						timelineBlend = MixBlend.setup;
 						alpha = alphaHold;
 						break;
@@ -381,12 +341,12 @@ module spine {
 				this.setAttachment(skeleton, slot, timeline.attachmentNames[Timeline.search(frames, time)], attachments);
 
 			// If an attachment wasn't set (ie before the first frame or attachments is false), set the setup attachment later.
-			if (slot.attachmentState <= this.unkeyedState) slot.attachmentState = this.unkeyedState + AnimationState.SETUP;
+			if (slot.attachmentState <= this.unkeyedState) slot.attachmentState = this.unkeyedState + SETUP;
 		}
 
 		setAttachment (skeleton: Skeleton, slot: Slot, attachmentName: string, attachments: boolean) {
 			slot.setAttachment(attachmentName == null ? null : skeleton.getAttachment(slot.data.index, attachmentName));
-			if (attachments) slot.attachmentState = this.unkeyedState + AnimationState.CURRENT;
+			if (attachments) slot.attachmentState = this.unkeyedState + CURRENT;
 		}
 
 		applyRotateTimeline (timeline: Timeline, skeleton: Skeleton, time: number, alpha: number, blend: MixBlend,
@@ -755,7 +715,7 @@ module spine {
 
 			if (to != null && to.holdPrevious) {
 				for (let i = 0; i < timelinesCount; i++)
-					timelineMode[i] = propertyIDs.addAll(timelines[i].getPropertyIds()) ? AnimationState.HOLD_FIRST : AnimationState.HOLD_SUBSEQUENT;
+					timelineMode[i] = propertyIDs.addAll(timelines[i].getPropertyIds()) ? HOLD_FIRST : HOLD_SUBSEQUENT;
 				return;
 			}
 
@@ -764,21 +724,21 @@ module spine {
 				let timeline = timelines[i];
 				let ids = timeline.getPropertyIds();
 				if (!propertyIDs.addAll(ids))
-					timelineMode[i] = AnimationState.SUBSEQUENT;
+					timelineMode[i] = SUBSEQUENT;
 				else if (to == null || timeline instanceof AttachmentTimeline || timeline instanceof DrawOrderTimeline
 					|| timeline instanceof EventTimeline || !to.animation.hasTimeline(ids)) {
-					timelineMode[i] = AnimationState.FIRST;
+					timelineMode[i] = FIRST;
 				} else {
 					for (let next = to.mixingTo; next != null; next = next.mixingTo) {
 						if (next.animation.hasTimeline(ids)) continue;
 						if (entry.mixDuration > 0) {
-							timelineMode[i] = AnimationState.HOLD_MIX;
+							timelineMode[i] = HOLD_MIX;
 							timelineHoldMix[i] = next;
 							continue outer;
 						}
 						break;
 					}
-					timelineMode[i] = AnimationState.HOLD_FIRST;
+					timelineMode[i] = HOLD_FIRST;
 				}
 			}
 		}
@@ -1176,4 +1136,44 @@ module spine {
 		event (entry: TrackEntry, event: Event) {
 		}
 	}
+
+	/** 1. A previously applied timeline has set this property.
+	 *
+	 * Result: Mix from the current pose to the timeline pose. */
+	const SUBSEQUENT = 0;
+	/** 1. This is the first timeline to set this property.
+	 * 2. The next track entry applied after this one does not have a timeline to set this property.
+	 *
+	 * Result: Mix from the setup pose to the timeline pose. */
+	const FIRST = 1;
+	/** 1) A previously applied timeline has set this property.<br>
+	 * 2) The next track entry to be applied does have a timeline to set this property.<br>
+	 * 3) The next track entry after that one does not have a timeline to set this property.<br>
+	 * Result: Mix from the current pose to the timeline pose, but do not mix out. This avoids "dipping" when crossfading
+	 * animations that key the same property. A subsequent timeline will set this property using a mix. */
+	const HOLD_SUBSEQUENT = 2;
+	/** 1) This is the first timeline to set this property.<br>
+	 * 2) The next track entry to be applied does have a timeline to set this property.<br>
+	 * 3) The next track entry after that one does not have a timeline to set this property.<br>
+	 * Result: Mix from the setup pose to the timeline pose, but do not mix out. This avoids "dipping" when crossfading animations
+	 * that key the same property. A subsequent timeline will set this property using a mix. */
+	const HOLD_FIRST = 3;
+	/** 1. This is the first timeline to set this property.
+	 * 2. The next track entry to be applied does have a timeline to set this property.
+	 * 3. The next track entry after that one does have a timeline to set this property.
+	 * 4. timelineHoldMix stores the first subsequent track entry that does not have a timeline to set this property.
+	 *
+	 * Result: The same as HOLD except the mix percentage from the timelineHoldMix track entry is used. This handles when more than
+	 * 2 track entries in a row have a timeline that sets the same property.
+	 *
+	 * Eg, A -> B -> C -> D where A, B, and C have a timeline setting same property, but D does not. When A is applied, to avoid
+	 * "dipping" A is not mixed out, however D (the first entry that doesn't set the property) mixing in is used to mix out A
+	 * (which affects B and C). Without using D to mix out, A would be applied fully until mixing completes, then snap into
+	 * place. */
+	const HOLD_MIX = 4;
+
+	const SETUP = 1;
+	const CURRENT = 2;
+
+	let _emptyAnimation: Animation = null;
 }

spine-ts/core/src/BlendMode.ts

@@ -1,39 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-module spine {
-
-	/** Determines how images are blended with existing pixels when drawn. */
-	export enum BlendMode {
-		Normal,
-		Additive,
-		Multiply,
-		Screen
-	}
-}

spine-ts/core/src/BoneData.ts

@@ -86,7 +86,5 @@ module spine {
 	}
 
 	/** Determines how a bone inherits world transforms from parent bones. */
-	export enum TransformMode {
+	export enum TransformMode { Normal, OnlyTranslation, NoRotationOrReflection, NoScale, NoScaleOrReflection }
-		Normal, OnlyTranslation, NoRotationOrReflection, NoScale, NoScaleOrReflection
-	}
 }

spine-ts/core/src/PathConstraintData.ts

@@ -70,21 +70,15 @@ module spine {
 	/** Controls how the first bone is positioned along the path.
 	 *
 	 * See [position](http://esotericsoftware.com/spine-path-constraints#Position) in the Spine User Guide. */
-	export enum PositionMode {
+	export enum PositionMode { Fixed, Percent }
-		Fixed, Percent
-	}
 
 	/** Controls how bones after the first bone are positioned along the path.
 	 *
 	 * See [spacing](http://esotericsoftware.com/spine-path-constraints#Spacing) in the Spine User Guide. */
-	export enum SpacingMode {
+	export enum SpacingMode { Length, Fixed, Percent, Proportional }
-		Length, Fixed, Percent, Proportional
-	}
 
 	/** Controls how bones are rotated, translated, and scaled to match the path.
 	 *
 	 * See [rotate mix](http://esotericsoftware.com/spine-path-constraints#Rotate-mix) in the Spine User Guide. */
-	export enum RotateMode {
+	export enum RotateMode { Tangent, Chain, ChainScale }
-		Tangent, Chain, ChainScale
-	}
 }

spine-ts/core/src/SkeletonBinary.ts

@@ -34,39 +34,6 @@ module spine {
 	 * [JSON and binary data](http://esotericsoftware.com/spine-loading-skeleton-data#JSON-and-binary-data) in the Spine
 	 * Runtimes Guide. */
 	export class SkeletonBinary {
-		static AttachmentTypeValues = [ 0 /*AttachmentType.Region*/, 1/*AttachmentType.BoundingBox*/, 2/*AttachmentType.Mesh*/, 3/*AttachmentType.LinkedMesh*/, 4/*AttachmentType.Path*/, 5/*AttachmentType.Point*/, 6/*AttachmentType.Clipping*/ ];
-		static TransformModeValues = [TransformMode.Normal, TransformMode.OnlyTranslation, TransformMode.NoRotationOrReflection, TransformMode.NoScale, TransformMode.NoScaleOrReflection];
-		static PositionModeValues = [ PositionMode.Fixed, PositionMode.Percent ];
-		static SpacingModeValues = [ SpacingMode.Length, SpacingMode.Fixed, SpacingMode.Percent];
-		static RotateModeValues = [ RotateMode.Tangent, RotateMode.Chain, RotateMode.ChainScale ];
-		static BlendModeValues = [ BlendMode.Normal, BlendMode.Additive, BlendMode.Multiply, BlendMode.Screen];
-
-		static BONE_ROTATE = 0;
-		static BONE_TRANSLATE = 1;
-		static BONE_TRANSLATEX = 2;
-		static BONE_TRANSLATEY = 3;
-		static BONE_SCALE = 4;
-		static BONE_SCALEX = 5;
-		static BONE_SCALEY = 6;
-		static BONE_SHEAR = 7;
-		static BONE_SHEARX = 8;
-		static BONE_SHEARY = 9;
-
-		static SLOT_ATTACHMENT = 0;
-		static SLOT_RGBA = 1;
-		static SLOT_RGB = 2;
-		static SLOT_RGBA2 = 3;
-		static SLOT_RGB2 = 4;
-		static SLOT_ALPHA = 5;
-
-		static PATH_POSITION = 0;
-		static PATH_SPACING = 1;
-		static PATH_MIX = 2;
-
-		static CURVE_LINEAR = 0;
-		static CURVE_STEPPED = 1;
-		static CURVE_BEZIER = 2;
-
 		/** Scales bone positions, image sizes, and translations as they are loaded. This allows different size images to be used at
 		 * runtime than were used in Spine.
 		 *
@@ -125,7 +92,7 @@ module spine {
 				data.shearX = input.readFloat();
 				data.shearY = input.readFloat();
 				data.length = input.readFloat() * scale;
-				data.transformMode = SkeletonBinary.TransformModeValues[input.readInt(true)];
+				data.transformMode = input.readInt(true);
 				data.skinRequired = input.readBoolean();
 				if (nonessential) Color.rgba8888ToColor(data.color, input.readInt32());
 				skeletonData.bones.push(data);
@@ -143,7 +110,7 @@ module spine {
 				if (darkColor != -1) Color.rgb888ToColor(data.darkColor = new Color(), darkColor);
 
 				data.attachmentName = input.readStringRef();
-				data.blendMode = SkeletonBinary.BlendModeValues[input.readInt(true)];
+				data.blendMode = input.readInt(true);
 				skeletonData.slots.push(data);
 			}
 
@@ -203,9 +170,9 @@ module spine {
 				for (let ii = 0; ii < nn; ii++)
 					data.bones.push(skeletonData.bones[input.readInt(true)]);
 				data.target = skeletonData.slots[input.readInt(true)];
-				data.positionMode = SkeletonBinary.PositionModeValues[input.readInt(true)];
+				data.positionMode = input.readInt(true);
-				data.spacingMode = SkeletonBinary.SpacingModeValues[input.readInt(true)];
+				data.spacingMode = input.readInt(true);
-				data.rotateMode = SkeletonBinary.RotateModeValues[input.readInt(true)];
+				data.rotateMode = input.readInt(true);
 				data.offsetRotation = input.readFloat();
 				data.position = input.readFloat();
 				if (data.positionMode == PositionMode.Fixed) data.position *= scale;
@@ -309,8 +276,7 @@ module spine {
 			let name = input.readStringRef();
 			if (name == null) name = attachmentName;
 
-			let typeIndex = input.readByte();
+			switch (input.readByte()) {
-			switch (SkeletonBinary.AttachmentTypeValues[typeIndex]) {
 			case AttachmentType.Region: {
 				let path = input.readStringRef();
 				let rotation = input.readFloat();
@@ -523,14 +489,14 @@ module spine {
 					let frameCount = input.readInt(true);
 					let frameLast = frameCount - 1;
 					switch (timelineType) {
-						case SkeletonBinary.SLOT_ATTACHMENT: {
+						case SLOT_ATTACHMENT: {
 							let timeline = new AttachmentTimeline(frameCount, slotIndex);
 							for (let frame = 0; frame < frameCount; frame++)
 								timeline.setFrame(frame, input.readFloat(), input.readStringRef());
 							timelines.push(timeline);
 							break;
 						}
-						case SkeletonBinary.SLOT_RGBA: {
+						case SLOT_RGBA: {
 							let bezierCount = input.readInt(true);
 							let timeline = new RGBATimeline(frameCount, bezierCount, slotIndex);
 
@@ -551,14 +517,14 @@ module spine {
 								let a2 = input.readUnsignedByte() / 255.0;
 
 								switch (input.readByte()) {
-									case SkeletonBinary.CURVE_STEPPED:
+									case CURVE_STEPPED:
 										timeline.setStepped(frame);
 										break;
-									case SkeletonBinary.CURVE_BEZIER:
+									case CURVE_BEZIER:
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 0, time, time2, r, r2, 1);
+										setBezier(input, timeline, bezier++, frame, 0, time, time2, r, r2, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 1, time, time2, g, g2, 1);
+										setBezier(input, timeline, bezier++, frame, 1, time, time2, g, g2, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 2, time, time2, b, b2, 1);
+										setBezier(input, timeline, bezier++, frame, 2, time, time2, b, b2, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 3, time, time2, a, a2, 1);
+										setBezier(input, timeline, bezier++, frame, 3, time, time2, a, a2, 1);
 								}
 								time = time2;
 								r = r2;
@@ -569,7 +535,7 @@ module spine {
 							timelines.push(timeline);
 							break;
 						}
-						case SkeletonBinary.SLOT_RGB: {
+						case SLOT_RGB: {
 							let bezierCount = input.readInt(true);
 							let timeline = new RGBTimeline(frameCount, bezierCount, slotIndex);
 
@@ -588,13 +554,13 @@ module spine {
 								let b2 = input.readUnsignedByte() / 255.0;
 
 								switch (input.readByte()) {
-									case SkeletonBinary.CURVE_STEPPED:
+									case CURVE_STEPPED:
 										timeline.setStepped(frame);
 										break;
-									case SkeletonBinary.CURVE_BEZIER:
+									case CURVE_BEZIER:
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 0, time, time2, r, r2, 1);
+										setBezier(input, timeline, bezier++, frame, 0, time, time2, r, r2, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 1, time, time2, g, g2, 1);
+										setBezier(input, timeline, bezier++, frame, 1, time, time2, g, g2, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 2, time, time2, b, b2, 1);
+										setBezier(input, timeline, bezier++, frame, 2, time, time2, b, b2, 1);
 								}
 								time = time2;
 								r = r2;
@@ -604,7 +570,7 @@ module spine {
 							timelines.push(timeline);
 							break;
 						}
-						case SkeletonBinary.SLOT_RGBA2: {
+						case SLOT_RGBA2: {
 							let bezierCount = input.readInt(true);
 							let timeline = new RGBA2Timeline(frameCount, bezierCount, slotIndex);
 
@@ -630,17 +596,17 @@ module spine {
 								let nb2 = input.readUnsignedByte() / 255.0;
 
 								switch (input.readByte()) {
-									case SkeletonBinary.CURVE_STEPPED:
+									case CURVE_STEPPED:
 										timeline.setStepped(frame);
 										break;
-									case SkeletonBinary.CURVE_BEZIER:
+									case CURVE_BEZIER:
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 0, time, time2, r, nr, 1);
+										setBezier(input, timeline, bezier++, frame, 0, time, time2, r, nr, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 1, time, time2, g, ng, 1);
+										setBezier(input, timeline, bezier++, frame, 1, time, time2, g, ng, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 2, time, time2, b, nb, 1);
+										setBezier(input, timeline, bezier++, frame, 2, time, time2, b, nb, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 3, time, time2, a, na, 1);
+										setBezier(input, timeline, bezier++, frame, 3, time, time2, a, na, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 4, time, time2, r2, nr2, 1);
+										setBezier(input, timeline, bezier++, frame, 4, time, time2, r2, nr2, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 5, time, time2, g2, ng2, 1);
+										setBezier(input, timeline, bezier++, frame, 5, time, time2, g2, ng2, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 6, time, time2, b2, nb2, 1);
+										setBezier(input, timeline, bezier++, frame, 6, time, time2, b2, nb2, 1);
 								}
 								time = time2;
 								r = nr;
@@ -654,7 +620,7 @@ module spine {
 							timelines.push(timeline);
 							break;
 						}
-						case SkeletonBinary.SLOT_RGB2: {
+						case SLOT_RGB2: {
 							let bezierCount = input.readInt(true);
 							let timeline = new RGB2Timeline(frameCount, bezierCount, slotIndex);
 
@@ -678,16 +644,16 @@ module spine {
 								let nb2 = input.readUnsignedByte() / 255.0;
 
 								switch (input.readByte()) {
-									case SkeletonBinary.CURVE_STEPPED:
+									case CURVE_STEPPED:
 										timeline.setStepped(frame);
 										break;
-									case SkeletonBinary.CURVE_BEZIER:
+									case CURVE_BEZIER:
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 0, time, time2, r, nr, 1);
+										setBezier(input, timeline, bezier++, frame, 0, time, time2, r, nr, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 1, time, time2, g, ng, 1);
+										setBezier(input, timeline, bezier++, frame, 1, time, time2, g, ng, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 2, time, time2, b, nb, 1);
+										setBezier(input, timeline, bezier++, frame, 2, time, time2, b, nb, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 3, time, time2, r2, nr2, 1);
+										setBezier(input, timeline, bezier++, frame, 3, time, time2, r2, nr2, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 4, time, time2, g2, ng2, 1);
+										setBezier(input, timeline, bezier++, frame, 4, time, time2, g2, ng2, 1);
-										SkeletonBinary.setBezier(input, timeline, bezier++, frame, 5, time, time2, b2, nb2, 1);
+										setBezier(input, timeline, bezier++, frame, 5, time, time2, b2, nb2, 1);
 								}
 								time = time2;
 								r = nr;
@@ -700,7 +666,7 @@ module spine {
 							timelines.push(timeline);
 							break;
 						}
-						case SkeletonBinary.SLOT_ALPHA: {
+						case SLOT_ALPHA: {
 							let timeline = new AlphaTimeline(frameCount, input.readInt(true), slotIndex);
 							let time = input.readFloat(), a = input.readUnsignedByte() / 255;
 							for (let frame = 0, bezier = 0;; frame++) {
@@ -709,11 +675,11 @@ module spine {
 								let time2 = input.readFloat();
 								let a2 = input.readUnsignedByte() / 255;
 								switch (input.readByte()) {
-								case SkeletonBinary.CURVE_STEPPED:
+								case CURVE_STEPPED:
 									timeline.setStepped(frame);
 									break;
-								case SkeletonBinary.CURVE_BEZIER:
+								case CURVE_BEZIER:
-									SkeletonBinary.setBezier(input, timeline, bezier++, frame, 0, time, time2, a, a2, 1);
+									setBezier(input, timeline, bezier++, frame, 0, time, time2, a, a2, 1);
 								}
 								time = time2;
 								a = a2;
@@ -731,35 +697,35 @@ module spine {
 				for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) {
 					let type = input.readByte(), frameCount = input.readInt(true), bezierCount = input.readInt(true);
 					switch (type) {
-					case SkeletonBinary.BONE_ROTATE:
+					case BONE_ROTATE:
-						timelines.push(SkeletonBinary.readTimeline(input, new RotateTimeline(frameCount, bezierCount, boneIndex), 1));
+						timelines.push(readTimeline1(input, new RotateTimeline(frameCount, bezierCount, boneIndex), 1));
 						break;
-					case SkeletonBinary.BONE_TRANSLATE:
+					case BONE_TRANSLATE:
-						timelines.push(SkeletonBinary.readTimeline2(input, new TranslateTimeline(frameCount, bezierCount, boneIndex), scale));
+						timelines.push(readTimeline2(input, new TranslateTimeline(frameCount, bezierCount, boneIndex), scale));
 						break;
-					case SkeletonBinary.BONE_TRANSLATEX:
+					case BONE_TRANSLATEX:
-						timelines.push(SkeletonBinary.readTimeline(input, new TranslateXTimeline(frameCount, bezierCount, boneIndex), scale));
+						timelines.push(readTimeline1(input, new TranslateXTimeline(frameCount, bezierCount, boneIndex), scale));
 						break;
-					case SkeletonBinary.BONE_TRANSLATEY:
+					case BONE_TRANSLATEY:
-						timelines.push(SkeletonBinary.readTimeline(input, new TranslateYTimeline(frameCount, bezierCount, boneIndex), scale));
+						timelines.push(readTimeline1(input, new TranslateYTimeline(frameCount, bezierCount, boneIndex), scale));
 						break;
-					case SkeletonBinary.BONE_SCALE:
+					case BONE_SCALE:
-						timelines.push(SkeletonBinary.readTimeline2(input, new ScaleTimeline(frameCount, bezierCount, boneIndex), 1));
+						timelines.push(readTimeline2(input, new ScaleTimeline(frameCount, bezierCount, boneIndex), 1));
 						break;
-					case SkeletonBinary.BONE_SCALEX:
+					case BONE_SCALEX:
-						timelines.push(SkeletonBinary.readTimeline(input, new ScaleXTimeline(frameCount, bezierCount, boneIndex), 1));
+						timelines.push(readTimeline1(input, new ScaleXTimeline(frameCount, bezierCount, boneIndex), 1));
 						break;
-					case SkeletonBinary.BONE_SCALEY:
+					case BONE_SCALEY:
-						timelines.push(SkeletonBinary.readTimeline(input, new ScaleYTimeline(frameCount, bezierCount, boneIndex), 1));
+						timelines.push(readTimeline1(input, new ScaleYTimeline(frameCount, bezierCount, boneIndex), 1));
 						break;
-					case SkeletonBinary.BONE_SHEAR:
+					case BONE_SHEAR:
-						timelines.push(SkeletonBinary.readTimeline2(input, new ShearTimeline(frameCount, bezierCount, boneIndex), 1));
+						timelines.push(readTimeline2(input, new ShearTimeline(frameCount, bezierCount, boneIndex), 1));
 						break;
-					case SkeletonBinary.BONE_SHEARX:
+					case BONE_SHEARX:
-						timelines.push(SkeletonBinary.readTimeline(input, new ShearXTimeline(frameCount, bezierCount, boneIndex), 1));
+						timelines.push(readTimeline1(input, new ShearXTimeline(frameCount, bezierCount, boneIndex), 1));
 						break;
-					case SkeletonBinary.BONE_SHEARY:
+					case BONE_SHEARY:
-						timelines.push(SkeletonBinary.readTimeline(input, new ShearYTimeline(frameCount, bezierCount, boneIndex), 1));
+						timelines.push(readTimeline1(input, new ShearYTimeline(frameCount, bezierCount, boneIndex), 1));
 					}
 				}
 			}
@@ -774,12 +740,12 @@ module spine {
 					if (frame == frameLast) break;
 					let time2 = input.readFloat(), mix2 = input.readFloat(), softness2 = input.readFloat() * scale;
 					switch (input.readByte()) {
-					case SkeletonBinary.CURVE_STEPPED:
+					case CURVE_STEPPED:
 						timeline.setStepped(frame);
 						break;
-					case SkeletonBinary.CURVE_BEZIER:
+					case CURVE_BEZIER:
-						SkeletonBinary.setBezier(input, timeline, bezier++, frame, 0, time, time2, mix, mix2, 1);
+						setBezier(input, timeline, bezier++, frame, 0, time, time2, mix, mix2, 1);
-						SkeletonBinary.setBezier(input, timeline, bezier++, frame, 1, time, time2, softness, softness2, scale);
+						setBezier(input, timeline, bezier++, frame, 1, time, time2, softness, softness2, scale);
 					}
 					time = time2;
 					mix = mix2;
@@ -800,16 +766,16 @@ module spine {
 					let time2 = input.readFloat(), mixRotate2 = input.readFloat(), mixX2 = input.readFloat(), mixY2 = input.readFloat(),
 						mixScaleX2 = input.readFloat(), mixScaleY2 = input.readFloat(), mixShearY2 = input.readFloat();
 					switch (input.readByte()) {
-					case SkeletonBinary.CURVE_STEPPED:
+					case CURVE_STEPPED:
 						timeline.setStepped(frame);
 						break;
-					case SkeletonBinary.CURVE_BEZIER:
+					case CURVE_BEZIER:
-						SkeletonBinary.setBezier(input, timeline, bezier++, frame, 0, time, time2, mixRotate, mixRotate2, 1);
+						setBezier(input, timeline, bezier++, frame, 0, time, time2, mixRotate, mixRotate2, 1);
-						SkeletonBinary.setBezier(input, timeline, bezier++, frame, 1, time, time2, mixX, mixX2, 1);
+						setBezier(input, timeline, bezier++, frame, 1, time, time2, mixX, mixX2, 1);
-						SkeletonBinary.setBezier(input, timeline, bezier++, frame, 2, time, time2, mixY, mixY2, 1);
+						setBezier(input, timeline, bezier++, frame, 2, time, time2, mixY, mixY2, 1);
-						SkeletonBinary.setBezier(input, timeline, bezier++, frame, 3, time, time2, mixScaleX, mixScaleX2, 1);
+						setBezier(input, timeline, bezier++, frame, 3, time, time2, mixScaleX, mixScaleX2, 1);
-						SkeletonBinary.setBezier(input, timeline, bezier++, frame, 4, time, time2, mixScaleY, mixScaleY2, 1);
+						setBezier(input, timeline, bezier++, frame, 4, time, time2, mixScaleY, mixScaleY2, 1);
-						SkeletonBinary.setBezier(input, timeline, bezier++, frame, 5, time, time2, mixShearY, mixShearY2, 1);
+						setBezier(input, timeline, bezier++, frame, 5, time, time2, mixShearY, mixShearY2, 1);
 					}
 					time = time2;
 					mixRotate = mixRotate2;
@@ -828,17 +794,17 @@ module spine {
 				let data = skeletonData.pathConstraints[index];
 				for (let ii = 0, nn = input.readInt(true); ii < nn; ii++) {
 					switch (input.readByte()) {
-					case SkeletonBinary.PATH_POSITION:
+					case PATH_POSITION:
 						timelines
-							.push(SkeletonBinary.readTimeline(input, new PathConstraintPositionTimeline(input.readInt(true), input.readInt(true), index),
+							.push(readTimeline1(input, new PathConstraintPositionTimeline(input.readInt(true), input.readInt(true), index),
 								data.positionMode == PositionMode.Fixed ? scale : 1));
 						break;
-					case SkeletonBinary.PATH_SPACING:
+					case PATH_SPACING:
 						timelines
-							.push(SkeletonBinary.readTimeline(input, new PathConstraintSpacingTimeline(input.readInt(true), input.readInt(true), index),
+							.push(readTimeline1(input, new PathConstraintSpacingTimeline(input.readInt(true), input.readInt(true), index),
 								data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed ? scale : 1));
 						break;
-					case SkeletonBinary.PATH_MIX:
+					case PATH_MIX:
 						let timeline = new PathConstraintMixTimeline(input.readInt(true), input.readInt(true), index);
 						let time = input.readFloat(), mixRotate = input.readFloat(), mixX = input.readFloat(), mixY = input.readFloat();
 						for (let frame = 0, bezier = 0, frameLast = timeline.getFrameCount() - 1;; frame++) {
@@ -847,13 +813,13 @@ module spine {
 							let time2 = input.readFloat(), mixRotate2 = input.readFloat(), mixX2 = input.readFloat(),
 								mixY2 = input.readFloat();
 							switch (input.readByte()) {
-							case SkeletonBinary.CURVE_STEPPED:
+							case CURVE_STEPPED:
 								timeline.setStepped(frame);
 								break;
-							case SkeletonBinary.CURVE_BEZIER:
+							case CURVE_BEZIER:
-								SkeletonBinary.setBezier(input, timeline, bezier++, frame, 0, time, time2, mixRotate, mixRotate2, 1);
+								setBezier(input, timeline, bezier++, frame, 0, time, time2, mixRotate, mixRotate2, 1);
-								SkeletonBinary.setBezier(input, timeline, bezier++, frame, 1, time, time2, mixX, mixX2, 1);
+								setBezier(input, timeline, bezier++, frame, 1, time, time2, mixX, mixX2, 1);
-								SkeletonBinary.setBezier(input, timeline, bezier++, frame, 2, time, time2, mixY, mixY2, 1);
+								setBezier(input, timeline, bezier++, frame, 2, time, time2, mixY, mixY2, 1);
 							}
 							time = time2;
 							mixRotate = mixRotate2;
@@ -910,11 +876,11 @@ module spine {
 							if (frame == frameLast) break;
 							let time2 = input.readFloat();
 							switch(input.readByte()) {
-								case SkeletonBinary.CURVE_STEPPED:
+								case CURVE_STEPPED:
 									timeline.setStepped(frame);
 									break;
-								case SkeletonBinary.CURVE_BEZIER:
+								case CURVE_BEZIER:
-									SkeletonBinary.setBezier(input, timeline, bezier++, frame, 0, time, time2, 0, 1, 1);
+									setBezier(input, timeline, bezier++, frame, 0, time, time2, 0, 1, 1);
 							}
 							time = time2;
 						}
@@ -980,56 +946,10 @@ module spine {
 				duration = Math.max(duration, timelines[i].getDuration());
 			return new Animation(name, timelines, duration);
 		}
-
-		static readTimeline (input: BinaryInput, timeline: CurveTimeline1, scale: number): CurveTimeline1 {
-			let time = input.readFloat(), value = input.readFloat() * scale;
-			for (let frame = 0, bezier = 0, frameLast = timeline.getFrameCount() - 1;; frame++) {
-				timeline.setFrame(frame, time, value);
-				if (frame == frameLast) break;
-				let time2 = input.readFloat(), value2 = input.readFloat() * scale;
-				switch (input.readByte()) {
-				case SkeletonBinary.CURVE_STEPPED:
-					timeline.setStepped(frame);
-					break;
-				case SkeletonBinary.CURVE_BEZIER:
-					SkeletonBinary.setBezier(input, timeline, bezier++, frame, 0, time, time2, value, value2, 1);
-				}
-				time = time2;
-				value = value2;
-			}
-			return timeline;
-		}
-
-		static readTimeline2 (input: BinaryInput, timeline: CurveTimeline2, scale: number): CurveTimeline2 {
-			let time = input.readFloat(), value1 = input.readFloat() * scale, value2 = input.readFloat() * scale;
-			for (let frame = 0, bezier = 0, frameLast = timeline.getFrameCount() - 1;; frame++) {
-				timeline.setFrame(frame, time, value1, value2);
-				if (frame == frameLast) break;
-				let time2 = input.readFloat(), nvalue1 = input.readFloat() * scale, nvalue2 = input.readFloat() * scale;
-				switch (input.readByte()) {
-				case SkeletonBinary.CURVE_STEPPED:
-					timeline.setStepped(frame);
-					break;
-				case SkeletonBinary.CURVE_BEZIER:
-					SkeletonBinary.setBezier(input, timeline, bezier++, frame, 0, time, time2, value1, nvalue1, scale);
-					SkeletonBinary.setBezier(input, timeline, bezier++, frame, 1, time, time2, value2, nvalue2, scale);
-				}
-				time = time2;
-				value1 = nvalue1;
-				value2 = nvalue2;
-			}
-			return timeline;
-		}
-
-		static setBezier (input: BinaryInput, timeline: CurveTimeline, bezier: number, frame: number, value: number,
-			time1: number, time2: number, value1: number, value2: number, scale: number) {
-			timeline.setBezier(bezier, frame, value, time1, value1, input.readFloat(), input.readFloat() * scale, input.readFloat(), input.readFloat() * scale, time2, value2);
-		}
 	}
 
 	class BinaryInput {
 		constructor(data: Uint8Array, public strings = new Array<string>(), private index: number = 0, private buffer = new DataView(data.buffer)) { 
-
 		}
 
 		readByte(): number {
@@ -1139,4 +1059,77 @@ module spine {
 	class Vertices {
 		constructor(public bones: Array<number> = null, public vertices: Array<number> | Float32Array = null) { }
 	}
+
+	enum AttachmentType { Region, BoundingBox, Mesh, LinkedMesh, Path, Point, Clipping }
+
+	function readTimeline1 (input: BinaryInput, timeline: CurveTimeline1, scale: number): CurveTimeline1 {
+		let time = input.readFloat(), value = input.readFloat() * scale;
+		for (let frame = 0, bezier = 0, frameLast = timeline.getFrameCount() - 1;; frame++) {
+			timeline.setFrame(frame, time, value);
+			if (frame == frameLast) break;
+			let time2 = input.readFloat(), value2 = input.readFloat() * scale;
+			switch (input.readByte()) {
+			case CURVE_STEPPED:
+				timeline.setStepped(frame);
+				break;
+			case CURVE_BEZIER:
+				setBezier(input, timeline, bezier++, frame, 0, time, time2, value, value2, 1);
+			}
+			time = time2;
+			value = value2;
+		}
+		return timeline;
+	}
+
+	function readTimeline2 (input: BinaryInput, timeline: CurveTimeline2, scale: number): CurveTimeline2 {
+		let time = input.readFloat(), value1 = input.readFloat() * scale, value2 = input.readFloat() * scale;
+		for (let frame = 0, bezier = 0, frameLast = timeline.getFrameCount() - 1;; frame++) {
+			timeline.setFrame(frame, time, value1, value2);
+			if (frame == frameLast) break;
+			let time2 = input.readFloat(), nvalue1 = input.readFloat() * scale, nvalue2 = input.readFloat() * scale;
+			switch (input.readByte()) {
+			case CURVE_STEPPED:
+				timeline.setStepped(frame);
+				break;
+			case CURVE_BEZIER:
+				setBezier(input, timeline, bezier++, frame, 0, time, time2, value1, nvalue1, scale);
+				setBezier(input, timeline, bezier++, frame, 1, time, time2, value2, nvalue2, scale);
+			}
+			time = time2;
+			value1 = nvalue1;
+			value2 = nvalue2;
+		}
+		return timeline;
+	}
+
+	function setBezier (input: BinaryInput, timeline: CurveTimeline, bezier: number, frame: number, value: number,
+		time1: number, time2: number, value1: number, value2: number, scale: number) {
+		timeline.setBezier(bezier, frame, value, time1, value1, input.readFloat(), input.readFloat() * scale, input.readFloat(), input.readFloat() * scale, time2, value2);
+	}
+
+	const  BONE_ROTATE = 0;
+	const  BONE_TRANSLATE = 1;
+	const  BONE_TRANSLATEX = 2;
+	const  BONE_TRANSLATEY = 3;
+	const  BONE_SCALE = 4;
+	const  BONE_SCALEX = 5;
+	const  BONE_SCALEY = 6;
+	const  BONE_SHEAR = 7;
+	const  BONE_SHEARX = 8;
+	const  BONE_SHEARY = 9;
+
+	const  SLOT_ATTACHMENT = 0;
+	const  SLOT_RGBA = 1;
+	const  SLOT_RGB = 2;
+	const  SLOT_RGBA2 = 3;
+	const  SLOT_RGB2 = 4;
+	const  SLOT_ALPHA = 5;
+
+	const  PATH_POSITION = 0;
+	const  PATH_SPACING = 1;
+	const  PATH_MIX = 2;
+
+	const  CURVE_LINEAR = 0;
+	const  CURVE_STEPPED = 1;
+	const  CURVE_BEZIER = 2;
 }

spine-ts/core/src/SkeletonJson.ts

@@ -86,7 +86,7 @@ module spine {
 					data.scaleY = getValue(boneMap, "scaleY", 1);
 					data.shearX = getValue(boneMap, "shearX", 0);
 					data.shearY = getValue(boneMap, "shearY", 0);
-					data.transformMode = SkeletonJson.transformModeFromString(getValue(boneMap, "transform", "normal"));
+					data.transformMode = Utils.enumValue(TransformMode, getValue(boneMap, "transform", "Normal"));
 					data.skinRequired = getValue(boneMap, "skin", false);
 
 					let color = getValue(boneMap, "color", null);
@@ -110,13 +110,10 @@ module spine {
 					if (color != null) data.color.setFromString(color);
 
 					let dark: string = getValue(slotMap, "dark", null);
-					if (dark != null) {
+					if (dark != null) data.darkColor = Color.fromString(dark);
-						data.darkColor = new Color(1, 1, 1, 1);
-						data.darkColor.setFromString(dark);
-					}
 
 					data.attachmentName = getValue(slotMap, "attachment", null);
-					data.blendMode = SkeletonJson.blendModeFromString(getValue(slotMap, "blend", "normal"));
+					data.blendMode = Utils.enumValue(BlendMode, getValue(slotMap, "blend", "normal"));
 					skeletonData.slots.push(data);
 				}
 			}
@@ -209,9 +206,9 @@ module spine {
 					data.target = skeletonData.findSlot(targetName);
 					if (data.target == null) throw new Error("Path target slot not found: " + targetName);
 
-					data.positionMode = SkeletonJson.positionModeFromString(getValue(constraintMap, "positionMode", "percent"));
+					data.positionMode = Utils.enumValue(PositionMode, getValue(constraintMap, "positionMode", "Percent"));
-					data.spacingMode = SkeletonJson.spacingModeFromString(getValue(constraintMap, "spacingMode", "length"));
+					data.spacingMode = Utils.enumValue(SpacingMode, getValue(constraintMap, "spacingMode", "Length"));
-					data.rotateMode = SkeletonJson.rotateModeFromString(getValue(constraintMap, "rotateMode", "tangent"));
+					data.rotateMode = Utils.enumValue(RotateMode, getValue(constraintMap, "rotateMode", "Tangent"));
 					data.offsetRotation = getValue(constraintMap, "rotation", 0);
 					data.position = getValue(constraintMap, "position", 0);
 					if (data.positionMode == PositionMode.Fixed) data.position *= scale;
@@ -484,14 +481,14 @@ module spine {
 							let timeline = new RGBATimeline(timelineMap.length, timelineMap.length << 2, slotIndex);
 							let keyMap = timelineMap[0];
 							let time = getValue(keyMap, "time", 0);
-							let color = new Color().setFromString(keyMap.color);
+							let color = Color.fromString(keyMap.color);
 
 							for (let frame = 0, bezier = 0;; frame++) {
 								timeline.setFrame(frame, time, color.r, color.g, color.b, color.a);
 								if (timelineMap.length == frame + 1) break;
 								let nextMap = timelineMap[frame + 1];
 								let time2 = getValue(nextMap, "time", 0);
-								let newColor = new Color().setFromString(nextMap.color);
+								let newColor = Color.fromString(nextMap.color);
 								let curve = keyMap.curve;
 								if (curve) {
 									bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, color.r, newColor.r, 1);
@@ -510,14 +507,14 @@ module spine {
 							let timeline = new RGBTimeline(timelineMap.length, timelineMap.length * 3, slotIndex);
 							let keyMap = timelineMap[0];
 							let time = getValue(keyMap, "time", 0);
-							let color = new Color().setFromString(keyMap.color);
+							let color = Color.fromString(keyMap.color);
 
 							for (let frame = 0, bezier = 0;; frame++) {
 								timeline.setFrame(frame, time, color.r, color.g, color.b);
 								if (timelineMap.length == frame + 1) break;
 								let nextMap = timelineMap[frame + 1];
 								let time2 = getValue(nextMap, "time", 0);
-								let newColor = new Color().setFromString(nextMap.color);
+								let newColor = Color.fromString(nextMap.color);
 								let curve = keyMap.curve;
 								if (curve) {
 									bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, color.r, newColor.r, 1);
@@ -532,22 +529,22 @@ module spine {
 							timelines.push(timeline);
 
 						} else if (timelineName == "alpha") {
-							timelines.push(readTimeline(timelineMap, new AlphaTimeline(timelineMap.length, timelineMap.length, slotIndex), 0, 1));
+							timelines.push(readTimeline1(timelineMap, new AlphaTimeline(timelineMap.length, timelineMap.length, slotIndex), 0, 1));
 						} else if (timelineName == "rgba2") {
 							let timeline = new RGBA2Timeline(timelineMap.length, timelineMap.length * 7, slotIndex);
 
 							let keyMap = timelineMap[0];
 							let time = getValue(keyMap, "time", 0);
-							let color = new Color().setFromString(keyMap.light);
+							let color = Color.fromString(keyMap.light);
-							let color2 = new Color().setFromString(keyMap.dark);
+							let color2 = Color.fromString(keyMap.dark);
 
 							for (let frame = 0, bezier = 0;; frame++) {
 								timeline.setFrame(frame, time, color.r, color.g, color.b, color.a, color2.r, color2.g, color2.b);
 								if (timelineMap.length == frame + 1) break;
 								let nextMap = timelineMap[frame + 1];
 								let time2 = getValue(nextMap, "time", 0);
-								let newColor = new Color().setFromString(nextMap.light);
+								let newColor = Color.fromString(nextMap.light);
-								let newColor2 = new Color().setFromString(nextMap.dark);
+								let newColor2 = Color.fromString(nextMap.dark);
 								let curve = keyMap.curve;
 								if (curve) {
 									bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, color.r, newColor.r, 1);
@@ -571,16 +568,16 @@ module spine {
 
 							let keyMap = timelineMap[0];
 							let time = getValue(keyMap, "time", 0);
-							let color = new Color().setFromString(keyMap.light);
+							let color = Color.fromString(keyMap.light);
-							let color2 = new Color().setFromString(keyMap.dark);
+							let color2 = Color.fromString(keyMap.dark);
 
 							for (let frame = 0, bezier = 0;; frame++) {
 								timeline.setFrame(frame, time, color.r, color.g, color.b, color2.r, color2.g, color2.b);
 								if (timelineMap.length == frame + 1) break;
 								let nextMap = timelineMap[frame + 1];
 								let time2 = getValue(nextMap, "time", 0);
-								let newColor = new Color().setFromString(nextMap.light);
+								let newColor = Color.fromString(nextMap.light);
-								let newColor2 = new Color().setFromString(nextMap.dark);
+								let newColor2 = Color.fromString(nextMap.dark);
 								let curve = keyMap.curve;
 								if (curve) {
 									bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, color.r, newColor.r, 1);
@@ -615,34 +612,34 @@ module spine {
 						if (timelineMap.length == 0) continue;
 
 						if (timelineName === "rotate") {
-							timelines.push(readTimeline(timelineMap, new RotateTimeline(timelineMap.length, timelineMap.length, boneIndex), 0, 1));
+							timelines.push(readTimeline1(timelineMap, new RotateTimeline(timelineMap.length, timelineMap.length, boneIndex), 0, 1));
 						} else if (timelineName === "translate") {
 							let timeline = new TranslateTimeline(timelineMap.length, timelineMap.length << 1, boneIndex);
 							timelines.push(readTimeline2(timelineMap, timeline, "x", "y", 0, scale));
 						} else if (timelineName === "translatex") {
 							let timeline = new TranslateXTimeline(timelineMap.length, timelineMap.length, boneIndex);
-							timelines.push(readTimeline(timelineMap, timeline, 0, scale));
+							timelines.push(readTimeline1(timelineMap, timeline, 0, scale));
 						} else if (timelineName === "translatey") {
 							let timeline = new TranslateYTimeline(timelineMap.length, timelineMap.length, boneIndex);
-							timelines.push(readTimeline(timelineMap, timeline, 0, scale));
+							timelines.push(readTimeline1(timelineMap, timeline, 0, scale));
 						} else if (timelineName === "scale") {
 							let timeline = new ScaleTimeline(timelineMap.length, timelineMap.length << 1, boneIndex);
 							timelines.push(readTimeline2(timelineMap, timeline, "x", "y", 1, 1));
 						} else if (timelineName === "scalex") {
 							let timeline = new ScaleXTimeline(timelineMap.length, timelineMap.length, boneIndex);
-							timelines.push(readTimeline(timelineMap, timeline, 1, 1));
+							timelines.push(readTimeline1(timelineMap, timeline, 1, 1));
 						} else if (timelineName === "scaley") {
 							let timeline = new ScaleYTimeline(timelineMap.length, timelineMap.length, boneIndex);
-							timelines.push(readTimeline(timelineMap, timeline, 1, 1));
+							timelines.push(readTimeline1(timelineMap, timeline, 1, 1));
 						} else if (timelineName === "shear") {
 							let timeline = new ShearTimeline(timelineMap.length, timelineMap.length << 1, boneIndex);
 							timelines.push(readTimeline2(timelineMap, timeline, "x", "y", 0, 1));
 						} else if (timelineName === "shearx") {
 							let timeline = new ShearXTimeline(timelineMap.length, timelineMap.length, boneIndex);
-							timelines.push(readTimeline(timelineMap, timeline, 0, 1));
+							timelines.push(readTimeline1(timelineMap, timeline, 0, 1));
 						} else if (timelineName === "sheary") {
 							let timeline = new ShearYTimeline(timelineMap.length, timelineMap.length, boneIndex);
-							timelines.push(readTimeline(timelineMap, timeline, 0, 1));
+							timelines.push(readTimeline1(timelineMap, timeline, 0, 1));
 						} else
 							throw new Error("Invalid timeline type for a bone: " + timelineName + " (" + boneName + ")");
 					}
@@ -755,10 +752,10 @@ module spine {
 
 						if (timelineName === "position") {
 							let timeline = new PathConstraintPositionTimeline(timelineMap.length, timelineMap.length, index);
-							timelines.push(readTimeline(timelineMap, timeline, 0, data.positionMode == PositionMode.Fixed ? scale : 1));
+							timelines.push(readTimeline1(timelineMap, timeline, 0, data.positionMode == PositionMode.Fixed ? scale : 1));
 						} else if (timelineName === "spacing") {
 							let timeline = new PathConstraintSpacingTimeline(timelineMap.length, timelineMap.length, index);
-							timelines.push(readTimeline(timelineMap, timeline, 0, data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed ? scale : 1));
+							timelines.push(readTimeline1(timelineMap, timeline, 0, data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed ? scale : 1));
 						} else if (timelineName === "mix") {
 							let timeline = new PathConstraintMixTimeline(timelineMap.size, timelineMap.size * 3, index);
 							let time = getValue(keyMap, "time", 0);
@@ -913,8 +910,24 @@ module spine {
 
 			skeletonData.animations.push(new Animation(name, timelines, duration));
 		}
+	}
 
-		static private readTimeline (keys: any[], timeline: CurveTimeline1, defaultValue: number, scale: number) {
+	class LinkedMesh {
+		parent: string; skin: string;
+		slotIndex: number;
+		mesh: MeshAttachment;
+		inheritDeform: boolean;
+
+		constructor (mesh: MeshAttachment, skin: string, slotIndex: number, parent: string, inheritDeform: boolean) {
+			this.mesh = mesh;
+			this.skin = skin;
+			this.slotIndex = slotIndex;
+			this.parent = parent;
+			this.inheritDeform = inheritDeform;
+		}
+	}
+
+	function readTimeline1 (keys: any[], timeline: CurveTimeline1, defaultValue: number, scale: number) {
 		let keyMap = keys[0];
 		let time = getValue(keyMap, "time", 0);
 		let value = getValue(keyMap, "value", defaultValue) * scale;
@@ -934,7 +947,7 @@ module spine {
 		return timeline;
 	}
 
-		static private readTimeline2 (keys: any[], timeline: CurveTimeline2, name1: string, name2: string, defaultValue: number, scale: number) {
+	function readTimeline2 (keys: any[], timeline: CurveTimeline2, name1: string, name2: string, defaultValue: number, scale: number) {
 		let keyMap = keys[0];
 		let time = getValue(keyMap, "time", 0);
 		let value1 = getValue(keyMap, name1, defaultValue) * scale;
@@ -961,7 +974,7 @@ module spine {
 		return timeline;
 	}
 
-		static private readCurve (curve: any, timeline: CurveTimeline, bezier: number, frame: number, value: number, time1: number, time2: number,
+	function readCurve (curve: any, timeline: CurveTimeline, bezier: number, frame: number, value: number, time1: number, time2: number,
 		value1: number, value2: number, scale: number) {
 		if (curve == "stepped") {
 			if (value != 0) timeline.setStepped(frame);
@@ -976,66 +989,7 @@ module spine {
 		return bezier;
 	}
 
-		static private getValue (map: any, property: string, defaultValue: any) {
+	function getValue (map: any, property: string, defaultValue: any) {
 		return map[property] !== undefined ? map[property] : defaultValue;
 	}
-
-		static private blendModeFromString (str: string) {
-			str = str.toLowerCase();
-			if (str == "normal") return BlendMode.Normal;
-			if (str == "additive") return BlendMode.Additive;
-			if (str == "multiply") return BlendMode.Multiply;
-			if (str == "screen") return BlendMode.Screen;
-			throw new Error(`Unknown blend mode: ${str}`);
-		}
-
-		static private positionModeFromString (str: string) {
-			str = str.toLowerCase();
-			if (str == "fixed") return PositionMode.Fixed;
-			if (str == "percent") return PositionMode.Percent;
-			throw new Error(`Unknown position mode: ${str}`);
-		}
-
-		static private spacingModeFromString (str: string) {
-			str = str.toLowerCase();
-			if (str == "length") return SpacingMode.Length;
-			if (str == "fixed") return SpacingMode.Fixed;
-			if (str == "percent") return SpacingMode.Percent;
-			if (str == "proportional") return SpacingMode.Proportional;
-			throw new Error(`Unknown spacing mode: ${str}`);
-		}
-
-		static private rotateModeFromString (str: string) {
-			str = str.toLowerCase();
-			if (str == "tangent") return RotateMode.Tangent;
-			if (str == "chain") return RotateMode.Chain;
-			if (str == "chainscale") return RotateMode.ChainScale;
-			throw new Error(`Unknown rotate mode: ${str}`);
-		}
-
-		static private transformModeFromString(str: string) {
-			str = str.toLowerCase();
-			if (str == "normal") return TransformMode.Normal;
-			if (str == "onlytranslation") return TransformMode.OnlyTranslation;
-			if (str == "norotationorreflection") return TransformMode.NoRotationOrReflection;
-			if (str == "noscale") return TransformMode.NoScale;
-			if (str == "noscaleorreflection") return TransformMode.NoScaleOrReflection;
-			throw new Error(`Unknown transform mode: ${str}`);
-		}
-	}
-
-	class LinkedMesh {
-		parent: string; skin: string;
-		slotIndex: number;
-		mesh: MeshAttachment;
-		inheritDeform: boolean;
-
-		constructor (mesh: MeshAttachment, skin: string, slotIndex: number, parent: string, inheritDeform: boolean) {
-			this.mesh = mesh;
-			this.skin = skin;
-			this.slotIndex = slotIndex;
-			this.parent = parent;
-			this.inheritDeform = inheritDeform;
-		}
-	}
 }

spine-ts/core/src/SlotData.ts

@@ -31,7 +31,6 @@ module spine {
 
 	/** Stores the setup pose for a {@link Slot}. */
 	export class SlotData {
-
 		/** The index of the slot in {@link Skeleton#getSlots()}. */
 		index: number;
 
@@ -64,4 +63,7 @@ module spine {
 			this.boneData = boneData;
 		}
 	}
+
+	/** Determines how images are blended with existing pixels when drawn. */
+	export enum BlendMode { Normal, Additive, Multiply, Screen }
 }

spine-ts/core/src/Texture.ts

@@ -42,28 +42,6 @@ module spine {
 		abstract setFilters (minFilter: TextureFilter, magFilter: TextureFilter): void;
 		abstract setWraps (uWrap: TextureWrap, vWrap: TextureWrap): void;
 		abstract dispose (): void;
-
-		public static filterFromString (text: string): TextureFilter {
-			switch (text.toLowerCase()) {
-				case "nearest": return TextureFilter.Nearest;
-				case "linear": return TextureFilter.Linear;
-				case "mipmap": return TextureFilter.MipMap;
-				case "mipmapnearestnearest": return TextureFilter.MipMapNearestNearest;
-				case "mipmaplinearnearest": return TextureFilter.MipMapLinearNearest;
-				case "mipmapnearestlinear": return TextureFilter.MipMapNearestLinear;
-				case "mipmaplinearlinear": return TextureFilter.MipMapLinearLinear;
-				default: throw new Error(`Unknown texture filter ${text}`);
-			}
-		}
-
-		public static wrapFromString (text: string): TextureWrap {
-			switch (text.toLowerCase()) {
-				case "mirroredtepeat": return TextureWrap.MirroredRepeat;
-				case "clamptoedge": return TextureWrap.ClampToEdge;
-				case "repeat": return TextureWrap.Repeat;
-				default: throw new Error(`Unknown texture wrap ${text}`);
-			}
-		}
 	}
 
 	export enum TextureFilter {

spine-ts/core/src/TextureAtlas.ts

@@ -54,8 +54,8 @@ module spine {
 				// page.format = Format[tuple[0]]; we don't need format in WebGL
 			};
 			pageFields["filter"] = () => {
-				page.minFilter = Texture.filterFromString(entry[1]);
+				page.minFilter = Utils.enumValue(TextureFilter, entry[1]);
-				page.magFilter = Texture.filterFromString(entry[2]);
+				page.magFilter = Utils.enumValue(TextureFilter, entry[2]);
 			};
 			pageFields["repeat"] = () => {
 				if (entry[1].indexOf('x') != -1) page.uWrap = TextureWrap.Repeat;
@@ -153,7 +153,7 @@ module spine {
 						else {
 							if (names == null) {
 								names = [];
-								values = []
+								values = [];
 							}
 							names.push(entry[0]);
 							let entryValues: number[] = [];

spine-ts/core/src/Utils.ts

@@ -165,6 +165,10 @@ module spine {
 			color.g = ((value & 0x0000ff00) >>> 8) / 255;
 			color.b = ((value & 0x000000ff)) / 255;
 		}
+
+		static fromString (hex : string) : Color {
+			return new Color().setFromString(hex);
+		}
 	}
 
 	export class MathUtils {
@@ -318,6 +322,10 @@ module spine {
 				if (array[i] == element) return true;
 			return false;
 		}
+
+		static enumValue (type: any, name: string) {
+			return type[name[0].toUpperCase() + name.slice(1)];
+		}
 	}
 
 	export class DebugUtils {

spine-ts/core/src/attachments/AttachmentType.ts

@@ -1,34 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-module spine {
-	export enum AttachmentType {
-		Region, BoundingBox, Mesh, LinkedMesh, Path, Point, Clipping
-	}
-}

spine-ts/core/src/attachments/RegionAttachment.ts

@@ -33,51 +33,6 @@ module spine {
 	 *
 	 * See [Region attachments](http://esotericsoftware.com/spine-regions) in the Spine User Guide. */
 	export class RegionAttachment extends Attachment {
-		static OX1 = 0;
-		static OY1 = 1;
-		static OX2 = 2;
-		static OY2 = 3;
-		static OX3 = 4;
-		static OY3 = 5;
-		static OX4 = 6;
-		static OY4 = 7;
-
-		static X1 = 0;
-		static Y1 = 1;
-		static C1R = 2;
-		static C1G = 3;
-		static C1B = 4;
-		static C1A = 5;
-		static U1 = 6;
-		static V1 = 7;
-
-		static X2 = 8;
-		static Y2 = 9;
-		static C2R = 10;
-		static C2G = 11;
-		static C2B = 12;
-		static C2A = 13;
-		static U2 = 14;
-		static V2 = 15;
-
-		static X3 = 16;
-		static Y3 = 17;
-		static C3R = 18;
-		static C3G = 19;
-		static C3B = 20;
-		static C3A = 21;
-		static U3 = 22;
-		static V3 = 23;
-
-		static X4 = 24;
-		static Y4 = 25;
-		static C4R = 26;
-		static C4G = 27;
-		static C4B = 28;
-		static C4A = 29;
-		static U4 = 30;
-		static V4 = 31;
-
 		/** The local x translation. */
 		x = 0;
 
@@ -142,14 +97,14 @@ module spine {
 			let localY2Cos = localY2 * cos + this.y;
 			let localY2Sin = localY2 * sin;
 			let offset = this.offset;
-			offset[RegionAttachment.OX1] = localXCos - localYSin;
+			offset[0] = localXCos - localYSin;
-			offset[RegionAttachment.OY1] = localYCos + localXSin;
+			offset[1] = localYCos + localXSin;
-			offset[RegionAttachment.OX2] = localXCos - localY2Sin;
+			offset[2] = localXCos - localY2Sin;
-			offset[RegionAttachment.OY2] = localY2Cos + localXSin;
+			offset[3] = localY2Cos + localXSin;
-			offset[RegionAttachment.OX3] = localX2Cos - localY2Sin;
+			offset[4] = localX2Cos - localY2Sin;
-			offset[RegionAttachment.OY3] = localY2Cos + localX2Sin;
+			offset[5] = localY2Cos + localX2Sin;
-			offset[RegionAttachment.OX4] = localX2Cos - localYSin;
+			offset[6] = localX2Cos - localYSin;
-			offset[RegionAttachment.OY4] = localYCos + localX2Sin;
+			offset[7] = localYCos + localX2Sin;
 		}
 
 		setRegion (region: TextureRegion) : void {
@@ -189,26 +144,26 @@ module spine {
 			let a = bone.a, b = bone.b, c = bone.c, d = bone.d;
 			let offsetX = 0, offsetY = 0;
 
-			offsetX = vertexOffset[RegionAttachment.OX1];
+			offsetX = vertexOffset[0];
-			offsetY = vertexOffset[RegionAttachment.OY1];
+			offsetY = vertexOffset[1];
 			worldVertices[offset] = offsetX * a + offsetY * b + x; // br
 			worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
 			offset += stride;
 
-			offsetX = vertexOffset[RegionAttachment.OX2];
+			offsetX = vertexOffset[2];
-			offsetY = vertexOffset[RegionAttachment.OY2];
+			offsetY = vertexOffset[3];
 			worldVertices[offset] = offsetX * a + offsetY * b + x; // bl
 			worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
 			offset += stride;
 
-			offsetX = vertexOffset[RegionAttachment.OX3];
+			offsetX = vertexOffset[4];
-			offsetY = vertexOffset[RegionAttachment.OY3];
+			offsetY = vertexOffset[5];
 			worldVertices[offset] = offsetX * a + offsetY * b + x; // ul
 			worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
 			offset += stride;
 
-			offsetX = vertexOffset[RegionAttachment.OX4];
+			offsetX = vertexOffset[6];
-			offsetY = vertexOffset[RegionAttachment.OY4];
+			offsetY = vertexOffset[7];
 			worldVertices[offset] = offsetX * a + offsetY * b + x; // ur
 			worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
 		}
@@ -230,5 +185,41 @@ module spine {
 			copy.color.setFromColor(this.color);
 			return copy;
 		}
+
+		static X1 = 0;
+		static Y1 = 1;
+		static C1R = 2;
+		static C1G = 3;
+		static C1B = 4;
+		static C1A = 5;
+		static U1 = 6;
+		static V1 = 7;
+
+		static X2 = 8;
+		static Y2 = 9;
+		static C2R = 10;
+		static C2G = 11;
+		static C2B = 12;
+		static C2A = 13;
+		static U2 = 14;
+		static V2 = 15;
+
+		static X3 = 16;
+		static Y3 = 17;
+		static C3R = 18;
+		static C3G = 19;
+		static C3B = 20;
+		static C3A = 21;
+		static U3 = 22;
+		static V3 = 23;
+
+		static X4 = 24;
+		static Y4 = 25;
+		static C4R = 26;
+		static C4G = 27;
+		static C4B = 28;
+		static C4A = 29;
+		static U4 = 30;
+		static V4 = 31;
 	}
 }

spine-ts/webgl/example/index.html

@@ -33,6 +33,7 @@ var shapes;
 var lastFrameTime;
 var skeletons = {};
 var activeSkeleton = "spineboy";
+var pow2 = new spine.Pow(2);
 var swirlEffect = new spine.SwirlEffect(0);
 var jitterEffect = new spine.JitterEffect(20, 20);
 var swirlTime = 0;
@@ -83,42 +84,46 @@ function init () {
 	assetManager.loadTextureAtlas("assets/stretchyman-pma.atlas");
 	assetManager.loadBinary("assets/coin-pro.skel");
 	assetManager.loadTextureAtlas("assets/coin-pma.atlas");
+	assetManager.loadBinary("assets/mix-and-match-pro.skel");
+	assetManager.loadText("assets/mix-and-match-pro.json");
+	assetManager.loadTextureAtlas("assets/mix-and-match-pma.atlas");
 	requestAnimationFrame(load);
 }
 
 function load () {
 	// Wait until the AssetManager has loaded all resources, then load the skeletons.
 	if (assetManager.isLoadingComplete()) {
-		skeletons["raptor"] = loadSkeleton("raptor-pro", "walk", true);
+		skeletons["coin"] = loadSkeleton("coin-pro.skel", "animation", true);
-		skeletons["spineboy"] = loadSkeleton("spineboy-pro", "run", true);
+		skeletons["goblins"] = loadSkeleton("goblins-pro.skel", "walk", true, "goblin");
-		skeletons["tank"] = loadSkeleton("tank-pro", "drive", true);
+		skeletons["mix-and-match-skel"] = loadSkeleton("mix-and-match-pro.skel", "dance", true, "full-skins/girl-blue-cape");
-		skeletons["goblins"] = loadSkeleton("goblins-pro", "walk", true, "goblin");
+		skeletons["mix-and-match-json"] = loadSkeleton("mix-and-match-pro.json", "dance", true, "full-skins/girl-blue-cape");
-		skeletons["vine"] = loadSkeleton("vine-pro", "grow", true);
+		skeletons["raptor"] = loadSkeleton("raptor-pro.skel", "walk", true);
-		skeletons["stretchyman"] = loadSkeleton("stretchyman-pro", "sneak", true);
+		skeletons["spineboy"] = loadSkeleton("spineboy-pro.skel", "run", true);
-		skeletons["coin"] = loadSkeleton("coin-pro", "animation", true);
+		skeletons["stretchyman"] = loadSkeleton("stretchyman-pro.skel", "sneak", true);
+		skeletons["tank"] = loadSkeleton("tank-pro.skel", "drive", true);
+		skeletons["vine"] = loadSkeleton("vine-pro.skel", "grow", true);
 		setupUI();
 		lastFrameTime = Date.now() / 1000;
 		requestAnimationFrame(render); // Loading is done, call render every frame.
-	} else {
+	} else
 		requestAnimationFrame(load);
 }
-}
 
 function loadSkeleton (name, initialAnimation, premultipliedAlpha, skin) {
 	if (skin === undefined) skin = "default";
 
 	// Load the texture atlas using name.atlas from the AssetManager.
-	var atlas = assetManager.get("assets/" + name.replace("-ess", "").replace("-pro", "") + (premultipliedAlpha ? "-pma": "") + ".atlas");
+	var atlas = assetManager.get("assets/" + name.replace(/(?:-ess|-pro)\.(skel|json)/, "") + (premultipliedAlpha ? "-pma": "") + ".atlas");
 
-	// Create a AtlasAttachmentLoader that resolves region, mesh, boundingbox and path attachments
+	// Create an AtlasAttachmentLoader that resolves region, mesh, boundingbox and path attachments
 	var atlasLoader = new spine.AtlasAttachmentLoader(atlas);
 
-	// Create a SkeletonBinary instance for parsing the .skel file.
+	// Create a skeleton loader instance for parsing the skeleton data file.
-	var skeletonBinary = new spine.SkeletonBinary(atlasLoader);
+	var skeletonLoader = name.endsWith(".skel") ? new spine.SkeletonBinary(atlasLoader) : new spine.SkeletonJson(atlasLoader);
 
 	// Set the scale to apply during parsing, parse the file, and create a new skeleton.
-	skeletonBinary.scale = 1;
+	skeletonLoader.scale = 1;
-	var skeletonData = skeletonBinary.readSkeletonData(assetManager.get("assets/" + name + ".skel"));
+	var skeletonData = skeletonLoader.readSkeletonData(assetManager.get("assets/" + name));
 	var skeleton = new spine.Skeleton(skeletonData);
 	skeleton.setSkinByName(skin);
 	var bounds = calculateSetupPoseBounds(skeleton);
@@ -126,33 +131,43 @@ function loadSkeleton (name, initialAnimation, premultipliedAlpha, skin) {
 	// Create an AnimationState, and set the initial animation in looping mode.
 	var animationStateData = new spine.AnimationStateData(skeleton.data);
 	var animationState = new spine.AnimationState(animationStateData);
-	if (name == "spineboy") {
+	if (name == "spineboy-pro.skel") {
-		animationStateData.setMix("walk", "jump", 0.4)
+		animationStateData.setMix("walk", "run", 1.5)
+		animationStateData.setMix("run", "jump", 0.2)
 		animationStateData.setMix("jump", "run", 0.4);
-		animationState.setAnimation(0, "walk", true);
+		animationState.setEmptyAnimation(0, 0);
-		var jumpEntry = animationState.addAnimation(0, "jump", false, 3);
+		var entry = animationState.addAnimation(0, "walk", true, 0);
+		entry.mixDuration = 1;
+		animationState.addAnimation(0, "run", true, 1.5);
+		animationState.addAnimation(0, "jump", false, 2);
 		animationState.addAnimation(0, "run", true, 0);
-	} else {
+		animationState.addEmptyAnimation(0, 1, 1);
+		entry = animationState.addAnimation(0, "walk", true, 1.5);
+		entry.mixDuration = 1;
+	} else
 		animationState.setAnimation(0, initialAnimation, true);
+
+	function log (message) {
+		if ($('#debug').is(':checked')) console.log(message);
 	}
 	animationState.addListener({
 		start: function(track) {
-			console.log("Animation on track " + track.trackIndex + " started");
+			log("Animation on track " + track.trackIndex + " started");
 		},
 		interrupt: function(track) {
-			console.log("Animation on track " + track.trackIndex + " interrupted");
+			log("Animation on track " + track.trackIndex + " interrupted");
 		},
 		end: function(track) {
-			console.log("Animation on track " + track.trackIndex + " ended");
+			log("Animation on track " + track.trackIndex + " ended");
 		},
 		disposed: function(track) {
-			console.log("Animation on track " + track.trackIndex + " disposed");
+			log("Animation on track " + track.trackIndex + " disposed");
 		},
 		complete: function(track) {
-			console.log("Animation on track " + track.trackIndex + " completed");
+			log("Animation on track " + track.trackIndex + " completed");
 		},
 		event: function(track, event) {
-			console.log("Event on track " + track.trackIndex + ": " + JSON.stringify(event));
+			log("Event on track " + track.trackIndex + ": " + JSON.stringify(event));
 		}
 	})
 
@@ -273,14 +288,13 @@ function render () {
 		swirlTime += delta;
 		var percent = swirlTime % 2;
 		if (percent > 1) percent = 1 - (percent -1 );
-		swirlEffect.angle = 120 * percent - 60;
+		swirlEffect.angle = pow2.apply(-60, 60, percent);
 		swirlEffect.centerX = bounds.offset.x + bounds.size.x / 2;
 		swirlEffect.centerY = bounds.offset.y + bounds.size.y / 2;
-		swirlEffect.radius = Math.sqrt(bounds.size.x * bounds.size.x + bounds.size.y * bounds.size.y);
+		swirlEffect.radius = Math.sqrt(bounds.size.x * bounds.size.x + bounds.size.y * bounds.size.y) * 0.75;
 		skeletonRenderer.vertexEffect = swirlEffect;
-	} else if (effect == "Jitter") {
+	} else if (effect == "Jitter")
 		skeletonRenderer.vertexEffect = jitterEffect;
-	}
 
 	skeletonRenderer.premultipliedAlpha = premultipliedAlpha;
 	skeletonRenderer.draw(batcher, skeleton);
@@ -317,7 +331,7 @@ function resize () {
 	var centerY = bounds.offset.y + bounds.size.y / 2;
 	var scaleX = bounds.size.x / canvas.width;
 	var scaleY = bounds.size.y / canvas.height;
-	var scale = Math.max(scaleX, scaleY) * 1.2;
+	var scale = Math.max(scaleX, scaleY) * 2;
 	if (scale < 1) scale = 1;
 	var width = canvas.width * scale;
 	var height = canvas.height * scale;