text: var __extends = (this && this.__extends) || (function () {
  	var extendStatics = function (d, b) {
  		extendStatics = Object.setPrototypeOf ||
  			({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
  			function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
  		return extendStatics(d, b);
  	};
  	return function (d, b) {
  		extendStatics(d, b);
  		function __() { this.constructor = d; }
  		d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
  	};
  })();
  var spine;
  (function (spine) {
  	var Animation = (function () {
  		function Animation(name, timelines, duration) {
  			if (name == null)
  				throw new Error("name cannot be null.");
  			if (timelines == null)
  				throw new Error("timelines cannot be null.");
  			this.name = name;
  			this.timelines = timelines;
  			this.timelineIds = [];
  			for (var i = 0; i < timelines.length; i++)
  				this.timelineIds[timelines[i].getPropertyId()] = true;
  			this.duration = duration;
  		}
  		Animation.prototype.hasTimeline = function (id) {
  			return this.timelineIds[id] == true;
  		};
  		Animation.prototype.apply = function (skeleton, lastTime, time, loop, events, alpha, blend, direction) {
  			if (skeleton == null)
  				throw new Error("skeleton cannot be null.");
  			if (loop && this.duration != 0) {
  				time %= this.duration;
  				if (lastTime > 0)
  					lastTime %= this.duration;
  			}
  			var timelines = this.timelines;
  			for (var i = 0, n = timelines.length; i < n; i++)
  				timelines[i].apply(skeleton, lastTime, time, events, alpha, blend, direction);
  		};
  		Animation.binarySearch = function (values, target, step) {
  			if (step === void 0) { step = 1; }
  			var low = 0;
  			var high = values.length / step - 2;
  			if (high == 0)
  				return step;
  			var current = high >>> 1;
  			while (true) {
  				if (values[(current + 1) * step] <= target)
  					low = current + 1;
  				else
  					high = current;
  				if (low == high)
  					return (low + 1) * step;
  				current = (low + high) >>> 1;
  			}
  		};
  		Animation.linearSearch = function (values, target, step) {
  			for (var i = 0, last = values.length - step; i <= last; i += step)
  				if (values[i] > target)
  					return i;
  			return -1;
  		};
  		return Animation;
  	}());
  	spine.Animation = Animation;
  	var MixBlend;
  	(function (MixBlend) {
  		MixBlend[MixBlend["setup"] = 0] = "setup";
  		MixBlend[MixBlend["first"] = 1] = "first";
  		MixBlend[MixBlend["replace"] = 2] = "replace";
  		MixBlend[MixBlend["add"] = 3] = "add";
  	})(MixBlend = spine.MixBlend || (spine.MixBlend = {}));
  	var MixDirection;
  	(function (MixDirection) {
  		MixDirection[MixDirection["mixIn"] = 0] = "mixIn";
  		MixDirection[MixDirection["mixOut"] = 1] = "mixOut";
  	})(MixDirection = spine.MixDirection || (spine.MixDirection = {}));
  	var TimelineType;
  	(function (TimelineType) {
  		TimelineType[TimelineType["rotate"] = 0] = "rotate";
  		TimelineType[TimelineType["translate"] = 1] = "translate";
  		TimelineType[TimelineType["scale"] = 2] = "scale";
  		TimelineType[TimelineType["shear"] = 3] = "shear";
  		TimelineType[TimelineType["attachment"] = 4] = "attachment";
  		TimelineType[TimelineType["color"] = 5] = "color";
  		TimelineType[TimelineType["deform"] = 6] = "deform";
  		TimelineType[TimelineType["event"] = 7] = "event";
  		TimelineType[TimelineType["drawOrder"] = 8] = "drawOrder";
  		TimelineType[TimelineType["ikConstraint"] = 9] = "ikConstraint";
  		TimelineType[TimelineType["transformConstraint"] = 10] = "transformConstraint";
  		TimelineType[TimelineType["pathConstraintPosition"] = 11] = "pathConstraintPosition";
  		TimelineType[TimelineType["pathConstraintSpacing"] = 12] = "pathConstraintSpacing";
  		TimelineType[TimelineType["pathConstraintMix"] = 13] = "pathConstraintMix";
  		TimelineType[TimelineType["twoColor"] = 14] = "twoColor";
  	})(TimelineType = spine.TimelineType || (spine.TimelineType = {}));
  	var CurveTimeline = (function () {
  		function CurveTimeline(frameCount) {
  			if (frameCount <= 0)
  				throw new Error("frameCount must be > 0: " + frameCount);
  			this.curves = spine.Utils.newFloatArray((frameCount - 1) * CurveTimeline.BEZIER_SIZE);
  		}
  		CurveTimeline.prototype.getFrameCount = function () {
  			return this.curves.length / CurveTimeline.BEZIER_SIZE + 1;
  		};
  		CurveTimeline.prototype.setLinear = function (frameIndex) {
  			this.curves[frameIndex * CurveTimeline.BEZIER_SIZE] = CurveTimeline.LINEAR;
  		};
  		CurveTimeline.prototype.setStepped = function (frameIndex) {
  			this.curves[frameIndex * CurveTimeline.BEZIER_SIZE] = CurveTimeline.STEPPED;
  		};
  		CurveTimeline.prototype.getCurveType = function (frameIndex) {
  			var index = frameIndex * CurveTimeline.BEZIER_SIZE;
  			if (index == this.curves.length)
  				return CurveTimeline.LINEAR;
  			var type = this.curves[index];
  			if (type == CurveTimeline.LINEAR)
  				return CurveTimeline.LINEAR;
  			if (type == CurveTimeline.STEPPED)
  				return CurveTimeline.STEPPED;
  			return CurveTimeline.BEZIER;
  		};
  		CurveTimeline.prototype.setCurve = function (frameIndex, cx1, cy1, cx2, cy2) {
  			var tmpx = (-cx1 * 2 + cx2) * 0.03, tmpy = (-cy1 * 2 + cy2) * 0.03;
  			var dddfx = ((cx1 - cx2) * 3 + 1) * 0.006, dddfy = ((cy1 - cy2) * 3 + 1) * 0.006;
  			var ddfx = tmpx * 2 + dddfx, ddfy = tmpy * 2 + dddfy;
  			var dfx = cx1 * 0.3 + tmpx + dddfx * 0.16666667, dfy = cy1 * 0.3 + tmpy + dddfy * 0.16666667;
  			var i = frameIndex * CurveTimeline.BEZIER_SIZE;
  			var curves = this.curves;
  			curves[i++] = CurveTimeline.BEZIER;
  			var x = dfx, y = dfy;
  			for (var n = i + CurveTimeline.BEZIER_SIZE - 1; i < n; i += 2) {
  				curves[i] = x;
  				curves[i + 1] = y;
  				dfx += ddfx;
  				dfy += ddfy;
  				ddfx += dddfx;
  				ddfy += dddfy;
  				x += dfx;
  				y += dfy;
  			}
  		};
  		CurveTimeline.prototype.getCurvePercent = function (frameIndex, percent) {
  			percent = spine.MathUtils.clamp(percent, 0, 1);
  			var curves = this.curves;
  			var i = frameIndex * CurveTimeline.BEZIER_SIZE;
  			var type = curves[i];
  			if (type == CurveTimeline.LINEAR)
  				return percent;
  			if (type == CurveTimeline.STEPPED)
  				return 0;
  			i++;
  			var x = 0;
  			for (var start = i, n = i + CurveTimeline.BEZIER_SIZE - 1; i < n; i += 2) {
  				x = curves[i];
  				if (x >= percent) {
  					var prevX = void 0, prevY = void 0;
  					if (i == start) {
  						prevX = 0;
  						prevY = 0;
  					}
  					else {
  						prevX = curves[i - 2];
  						prevY = curves[i - 1];
  					}
  					return prevY + (curves[i + 1] - prevY) * (percent - prevX) / (x - prevX);
  				}
  			}
  			var y = curves[i - 1];
  			return y + (1 - y) * (percent - x) / (1 - x);
  		};
  		CurveTimeline.LINEAR = 0;
  		CurveTimeline.STEPPED = 1;
  		CurveTimeline.BEZIER = 2;
  		CurveTimeline.BEZIER_SIZE = 10 * 2 - 1;
  		return CurveTimeline;
  	}());
  	spine.CurveTimeline = CurveTimeline;
  	var RotateTimeline = (function (_super) {
  		__extends(RotateTimeline, _super);
  		function RotateTimeline(frameCount) {
  			var _this = _super.call(this, frameCount) || this;
  			_this.frames = spine.Utils.newFloatArray(frameCount << 1);
  			return _this;
  		}
  		RotateTimeline.prototype.getPropertyId = function () {
  			return (TimelineType.rotate << 24) + this.boneIndex;
  		};
  		RotateTimeline.prototype.setFrame = function (frameIndex, time, degrees) {
  			frameIndex <<= 1;
  			this.frames[frameIndex] = time;
  			this.frames[frameIndex + RotateTimeline.ROTATION] = degrees;
  		};
  		RotateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) {
  			var frames = this.frames;
  			var bone = skeleton.bones[this.boneIndex];
  			if (!bone.active)
  				return;
  			if (time < frames[0]) {
  				switch (blend) {
  					case MixBlend.setup:
  						bone.rotation = bone.data.rotation;
  						return;
  					case MixBlend.first:
  						var r_1 = bone.data.rotation - bone.rotation;
  						bone.rotation += (r_1 - (16384 - ((16384.499999999996 - r_1 / 360) | 0)) * 360) * alpha;
  				}
  				return;
  			}
  			if (time >= frames[frames.length - RotateTimeline.ENTRIES]) {
  				var r_2 = frames[frames.length + RotateTimeline.PREV_ROTATION];
  				switch (blend) {
  					case MixBlend.setup:
  						bone.rotation = bone.data.rotation + r_2 * alpha;
  						break;
  					case MixBlend.first:
  					case MixBlend.replace:
  						r_2 += bone.data.rotation - bone.rotation;
  						r_2 -= (16384 - ((16384.499999999996 - r_2 / 360) | 0)) * 360;
  					case MixBlend.add:
  						bone.rotation += r_2 * alpha;
  				}
  				return;
  			}
  			var frame = Animation.binarySearch(frames, time, RotateTimeline.ENTRIES);
  			var prevRotation = frames[frame + RotateTimeline.PREV_ROTATION];
  			var frameTime = frames[frame];
  			var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
  			var r = frames[frame + RotateTimeline.ROTATION] - prevRotation;
  			r = prevRotation + (r - (16384 - ((16384.499999999996 - r / 360) | 0)) * 360) * percent;
  			switch (blend) {
  				case MixBlend.setup:
  					bone.rotation = bone.data.rotation + (r - (16384 - ((16384.499999999996 - r / 360) | 0)) * 360) * alpha;
  					break;
  				case MixBlend.first:
  				case MixBlend.replace:
  					r += bone.data.rotation - bone.rotation;
  				case MixBlend.add:
  					bone.rotation += (r - (16384 - ((16384.499999999996 - r / 360) | 0)) * 360) * alpha;
  			}
  		};
  		RotateTimeline.ENTRIES = 2;
  		RotateTimeline.PREV_TIME = -2;
  		RotateTimeline.PREV_ROTATION = -1;
  		RotateTimeline.ROTATION = 1;
  		return RotateTimeline;
  	}(CurveTimeline));
  	spine.RotateTimeline = RotateTimeline;
  	var TranslateTimeline = (function (_super) {
  		__extends(TranslateTimeline, _super);
  		function TranslateTimeline(frameCount) {
  			var _this = _super.call(this, frameCount) || this;
  			_this.frames = spine.Utils.newFloatArray(frameCount * TranslateTimeline.ENTRIES);
  			return _this;
  		}
  		TranslateTimeline.prototype.getPropertyId = function () {
  			return (TimelineType.translate << 24) + this.boneIndex;
  		};
  		TranslateTimeline.prototype.setFrame = function (frameIndex, time, x, y) {
  			frameIndex *= TranslateTimeline.ENTRIES;
  			this.frames[frameIndex] = time;
  			this.frames[frameIndex + TranslateTimeline.X] = x;
  			this.frames[frameIndex + TranslateTimeline.Y] = y;
  		};
  		TranslateTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) {
  			var frames = this.frames;
  			var bone = skeleton.bones[this.boneIndex];
  			if (!bone.active)
  				return;
  			if (time < frames[0]) {
  				switch (blend) {
  					case MixBlend.setup:
  						bone.x = bone.data.x;
  						bone.y = bone.data.y;
  						return;
  					case MixBlend.first:
  						bone.x += (bone.data.x - bone.x) * alpha;
  						bone.y += (bone.data.y - bone.y) * alpha;
  				}
  				return;
  			}
  			var x = 0, y = 0;
  			if (time >= frames[frames.length - TranslateTimeline.ENTRIES]) {
  				x = frames[frames.length + TranslateTimeline.PREV_X];
  				y = frames[frames.length + TranslateTimeline.PREV_Y];
  			}
  			else {
  				var frame = Animation.binarySearch(frames, time, TranslateTimeline.ENTRIES);
  				x = frames[frame + TranslateTimeline.PREV_X];
  				y = frames[frame + TranslateTimeline.PREV_Y];
  				var frameTime = frames[frame];
  				var percent = this.getCurvePercent(frame / TranslateTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + TranslateTimeline.PREV_TIME] - frameTime));
  				x += (frames[frame + TranslateTimeline.X] - x) * percent;
  				y += (frames[frame + TranslateTimeline.Y] - y) * percent;
  			}
  			switch (blend) {
  				case MixBlend.setup:
  					bone.x = bone.data.x + x * alpha;
  					bone.y = bone.data.y + y * alpha;
  					break;
  				case MixBlend.first:
  				case MixBlend.replace:
  					bone.x += (bone.data.x + x - bone.x) * alpha;
  					bone.y += (bone.data.y + y - bone.y) * alpha;
  					break;
  				case MixBlend.add:
  					bone.x += x * alpha;
  					bone.y += y * alpha;
  			}
  		};
  		TranslateTimeline.ENTRIES = 3;
  		TranslateTimeline.PREV_TIME = -3;
  		TranslateTimeline.PREV_X = -2;
  		TranslateTimeline.PREV_Y = -1;
  		TranslateTimeline.X = 1;
  		TranslateTimeline.Y = 2;
  		return TranslateTimeline;
  	}(CurveTimeline));
  	spine.TranslateTimeline = TranslateTimeline;
  	var ScaleTimeline = (function (_super) {
  		__extends(ScaleTimeline, _super);
  		function ScaleTimeline(frameCount) {
  			return _super.call(this, frameCount) || this;
  		}
  		ScaleTimeline.prototype.getPropertyId = function () {
  			return (TimelineType.scale << 24) + this.boneIndex;
  		};
  		ScaleTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) {
  			var frames = this.frames;
  			var bone = skeleton.bones[this.boneIndex];
  			if (!bone.active)
  				return;
  			if (time < frames[0]) {
  				switch (blend) {
  					case MixBlend.setup:
  						bone.scaleX = bone.data.scaleX;
  						bone.scaleY = bone.data.scaleY;
  						return;
  					case MixBlend.first:
  						bone.scaleX += (bone.data.scaleX - bone.scaleX) * alpha;
  						bone.scaleY += (bone.data.scaleY - bone.scaleY) * alpha;
  				}
  				return;
  			}
  			var x = 0, y = 0;
  			if (time >= frames[frames.length - ScaleTimeline.ENTRIES]) {
  				x = frames[frames.length + ScaleTimeline.PREV_X] * bone.data.scaleX;
  				y = frames[frames.length + ScaleTimeline.PREV_Y] * bone.data.scaleY;
  			}
  			else {
  				var frame = Animation.binarySearch(frames, time, ScaleTimeline.ENTRIES);
  				x = frames[frame + ScaleTimeline.PREV_X];
  				y = frames[frame + ScaleTimeline.PREV_Y];
  				var frameTime = frames[frame];
  				var percent = this.getCurvePercent(frame / ScaleTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + ScaleTimeline.PREV_TIME] - frameTime));
  				x = (x + (frames[frame + ScaleTimeline.X] - x) * percent) * bone.data.scaleX;
  				y = (y + (frames[frame + ScaleTimeline.Y] - y) * percent) * bone.data.scaleY;
  			}
  			if (alpha == 1) {
  				if (blend == MixBlend.add) {
  					bone.scaleX += x - bone.data.scaleX;
  					bone.scaleY += y - bone.data.scaleY;
  				}
  				else {
  					bone.scaleX = x;
  					bone.scaleY = y;
  				}
  			}
  			else {
  				var bx = 0, by = 0;
  				if (direction == MixDirection.mixOut) {
  					switch (blend) {
  						case MixBlend.setup:
  							bx = bone.data.scaleX;
  							by = bone.data.scaleY;
  							bone.scaleX = bx + (Math.abs(x) * spine.MathUtils.signum(bx) - bx) * alpha;
  							bone.scaleY = by + (Math.abs(y) * spine.MathUtils.signum(by) - by) * alpha;
  							break;
  						case MixBlend.first:
  						case MixBlend.replace:
  							bx = bone.scaleX;
  							by = bone.scaleY;
  							bone.scaleX = bx + (Math.abs(x) * spine.MathUtils.signum(bx) - bx) * alpha;
  							bone.scaleY = by + (Math.abs(y) * spine.MathUtils.signum(by) - by) * alpha;
  							break;
  						case MixBlend.add:
  							bx = bone.scaleX;
  							by = bone.scaleY;
  							bone.scaleX = bx + (Math.abs(x) * spine.MathUtils.signum(bx) - bone.data.scaleX) * alpha;
  							bone.scaleY = by + (Math.abs(y) * spine.MathUtils.signum(by) - bone.data.scaleY) * alpha;
  					}
  				}
  				else {
  					switch (blend) {
  						case MixBlend.setup:
  							bx = Math.abs(bone.data.scaleX) * spine.MathUtils.signum(x);
  							by = Math.abs(bone.data.scaleY) * spine.MathUtils.signum(y);
  							bone.scaleX = bx + (x - bx) * alpha;
  							bone.scaleY = by + (y - by) * alpha;
  							break;
  						case MixBlend.first:
  						case MixBlend.replace:
  							bx = Math.abs(bone.scaleX) * spine.MathUtils.signum(x);
  							by = Math.abs(bone.scaleY) * spine.MathUtils.signum(y);
  							bone.scaleX = bx + (x - bx) * alpha;
  							bone.scaleY = by + (y - by) * alpha;
  							break;
  						case MixBlend.add:
  							bx = spine.MathUtils.signum(x);
  							by = spine.MathUtils.signum(y);
  							bone.scaleX = Math.abs(bone.scaleX) * bx + (x - Math.abs(bone.data.scaleX) * bx) * alpha;
  							bone.scaleY = Math.abs(bone.scaleY) * by + (y - Math.abs(bone.data.scaleY) * by) * alpha;
  					}
  				}
  			}
  		};
  		return ScaleTimeline;
  	}(TranslateTimeline));
  	spine.ScaleTimeline = ScaleTimeline;
  	var ShearTimeline = (function (_super) {
  		__extends(ShearTimeline, _super);
  		function ShearTimeline(frameCount) {
  			return _super.call(this, frameCount) || this;
  		}
  		ShearTimeline.prototype.getPropertyId = function () {
  			return (TimelineType.shear << 24) + this.boneIndex;
  		};
  		ShearTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) {
  			var frames = this.frames;
  			var bone = skeleton.bones[this.boneIndex];
  			if (!bone.active)
  				return;
  			if (time < frames[0]) {
  				switch (blend) {
  					case MixBlend.setup:
  						bone.shearX = bone.data.shearX;
  						bone.shearY = bone.data.shearY;
  						return;
  					case MixBlend.first:
  						bone.shearX += (bone.data.shearX - bone.shearX) * alpha;
  						bone.shearY += (bone.data.shearY - bone.shearY) * alpha;
  				}
  				return;
  			}
  			var x = 0, y = 0;
  			if (time >= frames[frames.length - ShearTimeline.ENTRIES]) {
  				x = frames[frames.length + ShearTimeline.PREV_X];
  				y = frames[frames.length + ShearTimeline.PREV_Y];
  			}
  			else {
  				var frame = Animation.binarySearch(frames, time, ShearTimeline.ENTRIES);
  				x = frames[frame + ShearTimeline.PREV_X];
  				y = frames[frame + ShearTimeline.PREV_Y];
  				var frameTime = frames[frame];
  				var percent = this.getCurvePercent(frame / ShearTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + ShearTimeline.PREV_TIME] - frameTime));
  				x = x + (frames[frame + ShearTimeline.X] - x) * percent;
  				y = y + (frames[frame + ShearTimeline.Y] - y) * percent;
  			}
  			switch (blend) {
  				case MixBlend.setup:
  					bone.shearX = bone.data.shearX + x * alpha;
  					bone.shearY = bone.data.shearY + y * alpha;
  					break;
  				case MixBlend.first:
  				case MixBlend.replace:
  					bone.shearX += (bone.data.shearX + x - bone.shearX) * alpha;
  					bone.shearY += (bone.data.shearY + y - bone.shearY) * alpha;
  					break;
  				case MixBlend.add:
  					bone.shearX += x * alpha;
  					bone.shearY += y * alpha;
  			}
  		};
  		return ShearTimeline;
  	}(TranslateTimeline));
  	spine.ShearTimeline = ShearTimeline;
  	var ColorTimeline = (function (_super) {
  		__extends(ColorTimeline, _super);
  		function ColorTimeline(frameCount) {
  			var _this = _super.call(this, frameCount) || this;
  			_this.frames = spine.Utils.newFloatArray(frameCount * ColorTimeline.ENTRIES);
  			return _this;
  		}
  		ColorTimeline.prototype.getPropertyId = function () {
  			return (TimelineType.color << 24) + this.slotIndex;
  		};
  		ColorTimeline.prototype.setFrame = function (frameIndex, time, r, g, b, a) {
  			frameIndex *= ColorTimeline.ENTRIES;
  			this.frames[frameIndex] = time;
  			this.frames[frameIndex + ColorTimeline.R] = r;
  			this.frames[frameIndex + ColorTimeline.G] = g;
  			this.frames[frameIndex + ColorTimeline.B] = b;
  			this.frames[frameIndex + ColorTimeline.A] = a;
  		};
  		ColorTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) {
  			var slot = skeleton.slots[this.slotIndex];
  			if (!slot.bone.active)
  				return;
  			var frames = this.frames;
  			if (time < frames[0]) {
  				switch (blend) {
  					case MixBlend.setup:
  						slot.color.setFromColor(slot.data.color);
  						return;
  					case MixBlend.first:
  						var color = slot.color, setup = slot.data.color;
  						color.add((setup.r - color.r) * alpha, (setup.g - color.g) * alpha, (setup.b - color.b) * alpha, (setup.a - color.a) * alpha);
  				}
  				return;
  			}
  			var r = 0, g = 0, b = 0, a = 0;
  			if (time >= frames[frames.length - ColorTimeline.ENTRIES]) {
  				var i = frames.length;
  				r = frames[i + ColorTimeline.PREV_R];
  				g = frames[i + ColorTimeline.PREV_G];
  				b = frames[i + ColorTimeline.PREV_B];
  				a = frames[i + ColorTimeline.PREV_A];
  			}
  			else {
  				var frame = Animation.binarySearch(frames, time, ColorTimeline.ENTRIES);
  				r = frames[frame + ColorTimeline.PREV_R];
  				g = frames[frame + ColorTimeline.PREV_G];
  				b = frames[frame + ColorTimeline.PREV_B];
  				a = frames[frame + ColorTimeline.PREV_A];
  				var frameTime = frames[frame];
  				var percent = this.getCurvePercent(frame / ColorTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + ColorTimeline.PREV_TIME] - frameTime));
  				r += (frames[frame + ColorTimeline.R] - r) * percent;
  				g += (frames[frame + ColorTimeline.G] - g) * percent;
  				b += (frames[frame + ColorTimeline.B] - b) * percent;
  				a += (frames[frame + ColorTimeline.A] - a) * percent;
  			}
  			if (alpha == 1)
  				slot.color.set(r, g, b, a);
  			else {
  				var color = slot.color;
  				if (blend == MixBlend.setup)
  					color.setFromColor(slot.data.color);
  				color.add((r - color.r) * alpha, (g - color.g) * alpha, (b - color.b) * alpha, (a - color.a) * alpha);
  			}
  		};
  		ColorTimeline.ENTRIES = 5;
  		ColorTimeline.PREV_TIME = -5;
  		ColorTimeline.PREV_R = -4;
  		ColorTimeline.PREV_G = -3;
  		ColorTimeline.PREV_B = -2;
  		ColorTimeline.PREV_A = -1;
  		ColorTimeline.R = 1;
  		ColorTimeline.G = 2;
  		ColorTimeline.B = 3;
  		ColorTimeline.A = 4;
  		return ColorTimeline;
  	}(CurveTimeline));
  	spine.ColorTimeline = ColorTimeline;
  	var TwoColorTimeline = (function (_super) {
  		__extends(TwoColorTimeline, _super);
  		function TwoColorTimeline(frameCount) {
  			var _this = _super.call(this, frameCount) || this;
  			_this.frames = spine.Utils.newFloatArray(frameCount * TwoColorTimeline.ENTRIES);
  			return _this;
  		}
  		TwoColorTimeline.prototype.getPropertyId = function () {
  			return (TimelineType.twoColor << 24) + this.slotIndex;
  		};
  		TwoColorTimeline.prototype.setFrame = function (frameIndex, time, r, g, b, a, r2, g2, b2) {
  			frameIndex *= TwoColorTimeline.ENTRIES;
  			this.frames[frameIndex] = time;
  			this.frames[frameIndex + TwoColorTimeline.R] = r;
  			this.frames[frameIndex + TwoColorTimeline.G] = g;
  			this.frames[frameIndex + TwoColorTimeline.B] = b;
  			this.frames[frameIndex + TwoColorTimeline.A] = a;
  			this.frames[frameIndex + TwoColorTimeline.R2] = r2;
  			this.frames[frameIndex + TwoColorTimeline.G2] = g2;
  			this.frames[frameIndex + TwoColorTimeline.B2] = b2;
  		};
  		TwoColorTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) {
  			var slot = skeleton.slots[this.slotIndex];
  			if (!slot.bone.active)
  				return;
  			var frames = this.frames;
  			if (time < frames[0]) {
  				switch (blend) {
  					case MixBlend.setup:
  						slot.color.setFromColor(slot.data.color);
  						slot.darkColor.setFromColor(slot.data.darkColor);
  						return;
  					case MixBlend.first:
  						var light = slot.color, dark = slot.darkColor, setupLight = slot.data.color, setupDark = slot.data.darkColor;
  						light.add((setupLight.r - light.r) * alpha, (setupLight.g - light.g) * alpha, (setupLight.b - light.b) * alpha, (setupLight.a - light.a) * alpha);
  						dark.add((setupDark.r - dark.r) * alpha, (setupDark.g - dark.g) * alpha, (setupDark.b - dark.b) * alpha, 0);
  				}
  				return;
  			}
  			var r = 0, g = 0, b = 0, a = 0, r2 = 0, g2 = 0, b2 = 0;
  			if (time >= frames[frames.length - TwoColorTimeline.ENTRIES]) {
  				var i = frames.length;
  				r = frames[i + TwoColorTimeline.PREV_R];
  				g = frames[i + TwoColorTimeline.PREV_G];
  				b = frames[i + TwoColorTimeline.PREV_B];
  				a = frames[i + TwoColorTimeline.PREV_A];
  				r2 = frames[i + TwoColorTimeline.PREV_R2];
  				g2 = frames[i + TwoColorTimeline.PREV_G2];
  				b2 = frames[i + TwoColorTimeline.PREV_B2];
  			}
  			else {
  				var frame = Animation.binarySearch(frames, time, TwoColorTimeline.ENTRIES);
  				r = frames[frame + TwoColorTimeline.PREV_R];
  				g = frames[frame + TwoColorTimeline.PREV_G];
  				b = frames[frame + TwoColorTimeline.PREV_B];
  				a = frames[frame + TwoColorTimeline.PREV_A];
  				r2 = frames[frame + TwoColorTimeline.PREV_R2];
  				g2 = frames[frame + TwoColorTimeline.PREV_G2];
  				b2 = frames[frame + TwoColorTimeline.PREV_B2];
  				var frameTime = frames[frame];
  				var percent = this.getCurvePercent(frame / TwoColorTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + TwoColorTimeline.PREV_TIME] - frameTime));
  				r += (frames[frame + TwoColorTimeline.R] - r) * percent;
  				g += (frames[frame + TwoColorTimeline.G] - g) * percent;
  				b += (frames[frame + TwoColorTimeline.B] - b) * percent;
  				a += (frames[frame + TwoColorTimeline.A] - a) * percent;
  				r2 += (frames[frame + TwoColorTimeline.R2] - r2) * percent;
  				g2 += (frames[frame + TwoColorTimeline.G2] - g2) * percent;
  				b2 += (frames[frame + TwoColorTimeline.B2] - b2) * percent;
  			}
  			if (alpha == 1) {
  				slot.color.set(r, g, b, a);
  				slot.darkColor.set(r2, g2, b2, 1);
  			}
  			else {
  				var light = slot.color, dark = slot.darkColor;
  				if (blend == MixBlend.setup) {
  					light.setFromColor(slot.data.color);
  					dark.setFromColor(slot.data.darkColor);
  				}
  				light.add((r - light.r) * alpha, (g - light.g) * alpha, (b - light.b) * alpha, (a - light.a) * alpha);
  				dark.add((r2 - dark.r) * alpha, (g2 - dark.g) * alpha, (b2 - dark.b) * alpha, 0);
  			}
  		};
  		TwoColorTimeline.ENTRIES = 8;
  		TwoColorTimeline.PREV_TIME = -8;
  		TwoColorTimeline.PREV_R = -7;
  		TwoColorTimeline.PREV_G = -6;
  		TwoColorTimeline.PREV_B = -5;
  		TwoColorTimeline.PREV_A = -4;
  		TwoColorTimeline.PREV_R2 = -3;
  		TwoColorTimeline.PREV_G2 = -2;
  		TwoColorTimeline.PREV_B2 = -1;
  		TwoColorTimeline.R = 1;
  		TwoColorTimeline.G = 2;
  		TwoColorTimeline.B = 3;
  		TwoColorTimeline.A = 4;
  		TwoColorTimeline.R2 = 5;
  		TwoColorTimeline.G2 = 6;
  		TwoColorTimeline.B2 = 7;
  		return TwoColorTimeline;
  	}(CurveTimeline));
  	spine.TwoColorTimeline = TwoColorTimeline;
  	var AttachmentTimeline = (function () {
  		function AttachmentTimeline(frameCount) {
  			this.frames = spine.Utils.newFloatArray(frameCount);
  			this.attachmentNames = new Array(frameCount);
  		}
  		AttachmentTimeline.prototype.getPropertyId = function () {
  			return (TimelineType.attachment << 24) + this.slotIndex;
  		};
  		AttachmentTimeline.prototype.getFrameCount = function () {
  			return this.frames.length;
  		};
  		AttachmentTimeline.prototype.setFrame = function (frameIndex, time, attachmentName) {
  			this.frames[frameIndex] = time;
  			this.attachmentNames[frameIndex] = attachmentName;
  		};
  		AttachmentTimeline.prototype.apply = function (skeleton, lastTime, time, events, alpha, blend, direction) {
  			var slot = skeleton.slots[this.slotIndex];
  			if (!slot.bone.active)
  				return;
  			if (direction == MixDirection.mixOut) {
  				if (blend == MixBlend.setup)
  					this.setAttachment(skeleton, slot, slot.data.attachmentName);
  				return;
  			}
  			var frames = this.frames;
  			if (time < frames[0]) {
  				if (blend == MixBlend.setup || blend == MixBlend.first)
  					this.setAttachment(skeleton, slot, slot.data.attachmentName);
  				return;
  			}
  			var frameIndex = 0;
  			if (time >= frames[frames.length - 1])
  				frameIndex = frames.length - 1;
  			else
  				frameIndex = Animation.binarySearch(frames, time, 1) - 1;
  			var attachmentName = this.attachmentNames[frameIndex];
  			skeleton.slots[this.slotIndex]
  				.setAttachment(attachmentName == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName));
  		};
  		AttachmentTimeline.prototype.setAttachment = function (skeleton, slot, attachmentName) {
  			slot.attachment = attachmentName == null ? null : skeleton.getAttachment(this.slotIndex, attachmentName);
  		};
  		return AttachmentTimeline;
  	}());
  	spine.AttachmentTimeline = AttachmentTimeline;
  	var zeros = null;
  	var DeformTimeline = (function (_super) {
  		__extends(DeformTimeline, _super);
  		function DeformTimeline(frameCount) {
  			var _this = _super.call(this, frameCount) || this;
  			_this.frames = spine.Utils.newFloatArray(frameCount);
  			_this.frameVertices = new Array(frameCount);
  			if (zeros == null)
  				zeros = spine.Utils.newFloatArray(64);
  			return _this;
  		}
  		DeformTimeline.prototype.getPropertyId = function () {
  			return (TimelineType.deform << 27) + +this.attachment.id + this.slotIndex;
  		};
  		DeformTimeline.prototype.setFrame = function (frameIndex, time, vertices) {
  			this.frames[frameIndex] = time;
  			this.frameVertices[frameIndex] = vertices;
  		};
  		DeformTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
  			var slot = skeleton.slots[this.slotIndex];
  			if (!slot.bone.active)
  				return;
  			var slotAttachment = slot.getAttachment();
  			if (!(slotAttachment instanceof spine.VertexAttachment) || !(slotAttachment.deformAttachment == this.attachment))
  				return;
  			var deformArray = slot.deform;
  			if (deformArray.length == 0)
  				blend = MixBlend.setup;
  			var frameVertices = this.frameVertices;
  			var vertexCount = frameVertices[0].length;
  			var frames = this.frames;
  			if (time < frames[0]) {
  				var vertexAttachment = slotAttachment;
  				switch (blend) {
  					case MixBlend.setup:
  						deformArray.length = 0;
  						return;
  					case MixBlend.first:
  						if (alpha == 1) {
  							deformArray.length = 0;
  							break;
  						}
  						var deform_1 = spine.Utils.setArraySize(deformArray, vertexCount);
  						if (vertexAttachment.bones == null) {
  							var setupVertices = vertexAttachment.vertices;
  							for (var i = 0; i < vertexCount; i++)
  								deform_1[i] += (setupVertices[i] - deform_1[i]) * alpha;
  						}
  						else {
  							alpha = 1 - alpha;
  							for (var i = 0; i < vertexCount; i++)
  								deform_1[i] *= alpha;
  						}
  				}
  				return;
  			}
  			var deform = spine.Utils.setArraySize(deformArray, vertexCount);
  			if (time >= frames[frames.length - 1]) {
  				var lastVertices = frameVertices[frames.length - 1];
  				if (alpha == 1) {
  					if (blend == MixBlend.add) {
  						var vertexAttachment = slotAttachment;
  						if (vertexAttachment.bones == null) {
  							var setupVertices = vertexAttachment.vertices;
  							for (var i_1 = 0; i_1 < vertexCount; i_1++) {
  								deform[i_1] += lastVertices[i_1] - setupVertices[i_1];
  							}
  						}
  						else {
  							for (var i_2 = 0; i_2 < vertexCount; i_2++)
  								deform[i_2] += lastVertices[i_2];
  						}
  					}
  					else {
  						spine.Utils.arrayCopy(lastVertices, 0, deform, 0, vertexCount);
  					}
  				}
  				else {
  					switch (blend) {
  						case MixBlend.setup: {
  							var vertexAttachment_1 = slotAttachment;
  							if (vertexAttachment_1.bones == null) {
  								var setupVertices = vertexAttachment_1.vertices;
  								for (var i_3 = 0; i_3 < vertexCount; i_3++) {
  									var setup = setupVertices[i_3];
  									deform[i_3] = setup + (lastVertices[i_3] - setup) * alpha;
  								}
  							}
  							else {
  								for (var i_4 = 0; i_4 < vertexCount; i_4++)
  									deform[i_4] = lastVertices[i_4] * alpha;
  							}
  							break;
  						}
  						case MixBlend.first:
  						case MixBlend.replace:
  							for (var i_5 = 0; i_5 < vertexCount; i_5++)
  								deform[i_5] += (lastVertices[i_5] - deform[i_5]) * alpha;
  							break;
  						case MixBlend.add:
  							var vertexAttachment = slotAttachment;
  							if (vertexAttachment.bones == null) {
  								var setupVertices = vertexAttachment.vertices;
  								for (var i_6 = 0; i_6 < vertexCount; i_6++) {
  									deform[i_6] += (lastVertices[i_6] - setupVertices[i_6]) * alpha;
  								}
  							}
  							else {
  								for (var i_7 = 0; i_7 < vertexCount; i_7++)
  									deform[i_7] += lastVertices[i_7] * alpha;
  							}
  					}
  				}
  				return;
  			}
  			var frame = Animation.binarySearch(frames, time);
  			var prevVertices = frameVertices[frame - 1];
  			var nextVertices = frameVertices[frame];
  			var frameTime = frames[frame];
  			var percent = this.getCurvePercent(frame - 1, 1 - (time - frameTime) / (frames[frame - 1] - frameTime));
  			if (alpha == 1) {
  				if (blend == MixBlend.add) {
  					var vertexAttachment = slotAttachment;
  					if (vertexAttachment.bones == null) {
  						var setupVertices = vertexAttachment.vertices;
  						for (var i_8 = 0; i_8 < vertexCount; i_8++) {
  							var prev = prevVertices[i_8];
  							deform[i_8] += prev + (nextVertices[i_8] - prev) * percent - setupVertices[i_8];
  						}
  					}
  					else {
  						for (var i_9 = 0; i_9 < vertexCount; i_9++) {
  							var prev = prevVertices[i_9];
  							deform[i_9] += prev + (nextVertices[i_9] - prev) * percent;
  						}
  					}
  				}
  				else {
  					for (var i_10 = 0; i_10 < vertexCount; i_10++) {
  						var prev = prevVertices[i_10];
  						deform[i_10] = prev + (nextVertices[i_10] - prev) * percent;
  					}
  				}
  			}
  			else {
  				switch (blend) {
  					case MixBlend.setup: {
  						var vertexAttachment_2 = slotAttachment;
  						if (vertexAttachment_2.bones == null) {
  							var setupVertices = vertexAttachment_2.vertices;
  							for (var i_11 = 0; i_11 < vertexCount; i_11++) {
  								var prev = prevVertices[i_11], setup = setupVertices[i_11];
  								deform[i_11] = setup + (prev + (nextVertices[i_11] - prev) * percent - setup) * alpha;
  							}
  						}
  						else {
  							for (var i_12 = 0; i_12 < vertexCount; i_12++) {
  								var prev = prevVertices[i_12];
  								deform[i_12] = (prev + (nextVertices[i_12] - prev) * percent) * alpha;
  							}
  						}
  						break;
  					}
  					case MixBlend.first:
  					case MixBlend.replace:
  						for (var i_13 = 0; i_13 < vertexCount; i_13++) {
  							var prev = prevVertices[i_13];
  							deform[i_13] += (prev + (nextVertices[i_13] - prev) * percent - deform[i_13]) * alpha;
  						}
  						break;
  					case MixBlend.add:
  						var vertexAttachment = slotAttachment;
  						if (vertexAttachment.bones == null) {
  							var setupVertices = vertexAttachment.vertices;
  							for (var i_14 = 0; i_14 < vertexCount; i_14++) {
  								var prev = prevVertices[i_14];
  								deform[i_14] += (prev + (nextVertices[i_14] - prev) * percent - setupVertices[i_14]) * alpha;
  							}
  						}
  						else {
  							for (var i_15 = 0; i_15 < vertexCount; i_15++) {
  								var prev = prevVertices[i_15];
  								deform[i_15] += (prev + (nextVertices[i_15] - prev) * percent) * alpha;
  							}
  						}
  				}
  			}
  		};
  		return DeformTimeline;
  	}(CurveTimeline));
  	spine.DeformTimeline = DeformTimeline;
  	var EventTimeline = (function () {
  		function EventTimeline(frameCount) {
  			this.frames = spine.Utils.newFloatArray(frameCount);
  			this.events = new Array(frameCount);
  		}
  		EventTimeline.prototype.getPropertyId = function () {
  			return TimelineType.event << 24;
  		};
  		EventTimeline.prototype.getFrameCount = function () {
  			return this.frames.length;
  		};
  		EventTimeline.prototype.setFrame = function (frameIndex, event) {
  			this.frames[frameIndex] = event.time;
  			this.events[frameIndex] = event;
  		};
  		EventTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
  			if (firedEvents == null)
  				return;
  			var frames = this.frames;
  			var frameCount = this.frames.length;
  			if (lastTime > time) {
  				this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, blend, direction);
  				lastTime = -1;
  			}
  			else if (lastTime >= frames[frameCount - 1])
  				return;
  			if (time < frames[0])
  				return;
  			var frame = 0;
  			if (lastTime < frames[0])
  				frame = 0;
  			else {
  				frame = Animation.binarySearch(frames, lastTime);
  				var frameTime = frames[frame];
  				while (frame > 0) {
  					if (frames[frame - 1] != frameTime)
  						break;
  					frame--;
  				}
  			}
  			for (; frame < frameCount && time >= frames[frame]; frame++)
  				firedEvents.push(this.events[frame]);
  		};
  		return EventTimeline;
  	}());
  	spine.EventTimeline = EventTimeline;
  	var DrawOrderTimeline = (function () {
  		function DrawOrderTimeline(frameCount) {
  			this.frames = spine.Utils.newFloatArray(frameCount);
  			this.drawOrders = new Array(frameCount);
  		}
  		DrawOrderTimeline.prototype.getPropertyId = function () {
  			return TimelineType.drawOrder << 24;
  		};
  		DrawOrderTimeline.prototype.getFrameCount = function () {
  			return this.frames.length;
  		};
  		DrawOrderTimeline.prototype.setFrame = function (frameIndex, time, drawOrder) {
  			this.frames[frameIndex] = time;
  			this.drawOrders[frameIndex] = drawOrder;
  		};
  		DrawOrderTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
  			var drawOrder = skeleton.drawOrder;
  			var slots = skeleton.slots;
  			if (direction == MixDirection.mixOut) {
  				if (blend == MixBlend.setup)
  					spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
  				return;
  			}
  			var frames = this.frames;
  			if (time < frames[0]) {
  				if (blend == MixBlend.setup || blend == MixBlend.first)
  					spine.Utils.arrayCopy(skeleton.slots, 0, skeleton.drawOrder, 0, skeleton.slots.length);
  				return;
  			}
  			var frame = 0;
  			if (time >= frames[frames.length - 1])
  				frame = frames.length - 1;
  			else
  				frame = Animation.binarySearch(frames, time) - 1;
  			var drawOrderToSetupIndex = this.drawOrders[frame];
  			if (drawOrderToSetupIndex == null)
  				spine.Utils.arrayCopy(slots, 0, drawOrder, 0, slots.length);
  			else {
  				for (var i = 0, n = drawOrderToSetupIndex.length; i < n; i++)
  					drawOrder[i] = slots[drawOrderToSetupIndex[i]];
  			}
  		};
  		return DrawOrderTimeline;
  	}());
  	spine.DrawOrderTimeline = DrawOrderTimeline;
  	var IkConstraintTimeline = (function (_super) {
  		__extends(IkConstraintTimeline, _super);
  		function IkConstraintTimeline(frameCount) {
  			var _this = _super.call(this, frameCount) || this;
  			_this.frames = spine.Utils.newFloatArray(frameCount * IkConstraintTimeline.ENTRIES);
  			return _this;
  		}
  		IkConstraintTimeline.prototype.getPropertyId = function () {
  			return (TimelineType.ikConstraint << 24) + this.ikConstraintIndex;
  		};
  		IkConstraintTimeline.prototype.setFrame = function (frameIndex, time, mix, softness, bendDirection, compress, stretch) {
  			frameIndex *= IkConstraintTimeline.ENTRIES;
  			this.frames[frameIndex] = time;
  			this.frames[frameIndex + IkConstraintTimeline.MIX] = mix;
  			this.frames[frameIndex + IkConstraintTimeline.SOFTNESS] = softness;
  			this.frames[frameIndex + IkConstraintTimeline.BEND_DIRECTION] = bendDirection;
  			this.frames[frameIndex + IkConstraintTimeline.COMPRESS] = compress ? 1 : 0;
  			this.frames[frameIndex + IkConstraintTimeline.STRETCH] = stretch ? 1 : 0;
  		};
  		IkConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
  			var frames = this.frames;
  			var constraint = skeleton.ikConstraints[this.ikConstraintIndex];
  			if (!constraint.active)
  				return;
  			if (time < frames[0]) {
  				switch (blend) {
  					case MixBlend.setup:
  						constraint.mix = constraint.data.mix;
  						constraint.softness = constraint.data.softness;
  						constraint.bendDirection = constraint.data.bendDirection;
  						constraint.compress = constraint.data.compress;
  						constraint.stretch = constraint.data.stretch;
  						return;
  					case MixBlend.first:
  						constraint.mix += (constraint.data.mix - constraint.mix) * alpha;
  						constraint.softness += (constraint.data.softness - constraint.softness) * alpha;
  						constraint.bendDirection = constraint.data.bendDirection;
  						constraint.compress = constraint.data.compress;
  						constraint.stretch = constraint.data.stretch;
  				}
  				return;
  			}
  			if (time >= frames[frames.length - IkConstraintTimeline.ENTRIES]) {
  				if (blend == MixBlend.setup) {
  					constraint.mix = constraint.data.mix + (frames[frames.length + IkConstraintTimeline.PREV_MIX] - constraint.data.mix) * alpha;
  					constraint.softness = constraint.data.softness
  						+ (frames[frames.length + IkConstraintTimeline.PREV_SOFTNESS] - constraint.data.softness) * alpha;
  					if (direction == MixDirection.mixOut) {
  						constraint.bendDirection = constraint.data.bendDirection;
  						constraint.compress = constraint.data.compress;
  						constraint.stretch = constraint.data.stretch;
  					}
  					else {
  						constraint.bendDirection = frames[frames.length + IkConstraintTimeline.PREV_BEND_DIRECTION];
  						constraint.compress = frames[frames.length + IkConstraintTimeline.PREV_COMPRESS] != 0;
  						constraint.stretch = frames[frames.length + IkConstraintTimeline.PREV_STRETCH] != 0;
  					}
  				}
  				else {
  					constraint.mix += (frames[frames.length + IkConstraintTimeline.PREV_MIX] - constraint.mix) * alpha;
  					constraint.softness += (frames[frames.length + IkConstraintTimeline.PREV_SOFTNESS] - constraint.softness) * alpha;
  					if (direction == MixDirection.mixIn) {
  						constraint.bendDirection = frames[frames.length + IkConstraintTimeline.PREV_BEND_DIRECTION];
  						constraint.compress = frames[frames.length + IkConstraintTimeline.PREV_COMPRESS] != 0;
  						constraint.stretch = frames[frames.length + IkConstraintTimeline.PREV_STRETCH] != 0;
  					}
  				}
  				return;
  			}
  			var frame = Animation.binarySearch(frames, time, IkConstraintTimeline.ENTRIES);
  			var mix = frames[frame + IkConstraintTimeline.PREV_MIX];
  			var softness = frames[frame + IkConstraintTimeline.PREV_SOFTNESS];
  			var frameTime = frames[frame];
  			var percent = this.getCurvePercent(frame / IkConstraintTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + IkConstraintTimeline.PREV_TIME] - frameTime));
  			if (blend == MixBlend.setup) {
  				constraint.mix = constraint.data.mix + (mix + (frames[frame + IkConstraintTimeline.MIX] - mix) * percent - constraint.data.mix) * alpha;
  				constraint.softness = constraint.data.softness
  					+ (softness + (frames[frame + IkConstraintTimeline.SOFTNESS] - softness) * percent - constraint.data.softness) * alpha;
  				if (direction == MixDirection.mixOut) {
  					constraint.bendDirection = constraint.data.bendDirection;
  					constraint.compress = constraint.data.compress;
  					constraint.stretch = constraint.data.stretch;
  				}
  				else {
  					constraint.bendDirection = frames[frame + IkConstraintTimeline.PREV_BEND_DIRECTION];
  					constraint.compress = frames[frame + IkConstraintTimeline.PREV_COMPRESS] != 0;
  					constraint.stretch = frames[frame + IkConstraintTimeline.PREV_STRETCH] != 0;
  				}
  			}
  			else {
  				constraint.mix += (mix + (frames[frame + IkConstraintTimeline.MIX] - mix) * percent - constraint.mix) * alpha;
  				constraint.softness += (softness + (frames[frame + IkConstraintTimeline.SOFTNESS] - softness) * percent - constraint.softness) * alpha;
  				if (direction == MixDirection.mixIn) {
  					constraint.bendDirection = frames[frame + IkConstraintTimeline.PREV_BEND_DIRECTION];
  					constraint.compress = frames[frame + IkConstraintTimeline.PREV_COMPRESS] != 0;
  					constraint.stretch = frames[frame + IkConstraintTimeline.PREV_STRETCH] != 0;
  				}
  			}
  		};
  		IkConstraintTimeline.ENTRIES = 6;
  		IkConstraintTimeline.PREV_TIME = -6;
  		IkConstraintTimeline.PREV_MIX = -5;
  		IkConstraintTimeline.PREV_SOFTNESS = -4;
  		IkConstraintTimeline.PREV_BEND_DIRECTION = -3;
  		IkConstraintTimeline.PREV_COMPRESS = -2;
  		IkConstraintTimeline.PREV_STRETCH = -1;
  		IkConstraintTimeline.MIX = 1;
  		IkConstraintTimeline.SOFTNESS = 2;
  		IkConstraintTimeline.BEND_DIRECTION = 3;
  		IkConstraintTimeline.COMPRESS = 4;
  		IkConstraintTimeline.STRETCH = 5;
  		return IkConstraintTimeline;
  	}(CurveTimeline));
  	spine.IkConstraintTimeline = IkConstraintTimeline;
  	var TransformConstraintTimeline = (function (_super) {
  		__extends(TransformConstraintTimeline, _super);
  		function TransformConstraintTimeline(frameCount) {
  			var _this = _super.call(this, frameCount) || this;
  			_this.frames = spine.Utils.newFloatArray(frameCount * TransformConstraintTimeline.ENTRIES);
  			return _this;
  		}
  		TransformConstraintTimeline.prototype.getPropertyId = function () {
  			return (TimelineType.transformConstraint << 24) + this.transformConstraintIndex;
  		};
  		TransformConstraintTimeline.prototype.setFrame = function (frameIndex, time, rotateMix, translateMix, scaleMix, shearMix) {
  			frameIndex *= TransformConstraintTimeline.ENTRIES;
  			this.frames[frameIndex] = time;
  			this.frames[frameIndex + TransformConstraintTimeline.ROTATE] = rotateMix;
  			this.frames[frameIndex + TransformConstraintTimeline.TRANSLATE] = translateMix;
  			this.frames[frameIndex + TransformConstraintTimeline.SCALE] = scaleMix;
  			this.frames[frameIndex + TransformConstraintTimeline.SHEAR] = shearMix;
  		};
  		TransformConstraintTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
  			var frames = this.frames;
  			var constraint = skeleton.transformConstraints[this.transformConstraintIndex];
  			if (!constraint.active)
  				return;
  			if (time < frames[0]) {
  				var data = constraint.data;
  				switch (blend) {
  					case MixBlend.setup:
  						constraint.rotateMix = data.rotateMix;
  						constraint.translateMix = data.translateMix;
  						constraint.scaleMix = data.scaleMix;
  						constraint.shearMix = data.shearMix;
  						return;
  					case MixBlend.first:
  						constraint.rotateMix += (data.rotateMix - constraint.rotateMix) * alpha;
  						constraint.translateMix += (data.translateMix - constraint.translateMix) * alpha;
  						constraint.scaleMix += (data.scaleMix - constraint.scaleMix) * alpha;
  						constraint.shearMix += (data.shearMix - constraint.shearMix) * alpha;
  				}
  				return;
  			}
  			var rotate = 0, translate = 0, scale = 0, shear = 0;
  			if (time >= frames[frames.length - TransformConstraintTimeline.ENTRIES]) {
  				var i = frames.length;
  				rotate = frames[i + TransformConstraintTimeline.PREV_ROTATE];
  				translate = frames[i + TransformConstraintTimeline.PREV_TRANSLATE];
  				scale = frames[i + TransformConstraintTimeline.PREV_SCALE];
  				shear = frames[i + TransformConstraintTimeline.PREV_SHEAR];
  			}
  			else {
  				var frame = Animation.binarySearch(frames, time, TransformConstraintTimeline.ENTRIES);
  				rotate = frames[frame + TransformConstraintTimeline.PREV_ROTATE];
  				translate = frames[frame + TransformConstraintTimeline.PREV_TRANSLATE];
  				scale = frames[frame + TransformConstraintTimeline.PREV_SCALE];
  				shear = frames[frame + TransformConstraintTimeline.PREV_SHEAR];
  				var frameTime = frames[frame];
  				var percent = this.getCurvePercent(frame / TransformConstraintTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + TransformConstraintTimeline.PREV_TIME] - frameTime));
  				rotate += (frames[frame + TransformConstraintTimeline.ROTATE] - rotate) * percent;
  				translate += (frames[frame + TransformConstraintTimeline.TRANSLATE] - translate) * percent;
  				scale += (frames[frame + TransformConstraintTimeline.SCALE] - scale) * percent;
  				shear += (frames[frame + TransformConstraintTimeline.SHEAR] - shear) * percent;
  			}
  			if (blend == MixBlend.setup) {
  				var data = constraint.data;
  				constraint.rotateMix = data.rotateMix + (rotate - data.rotateMix) * alpha;
  				constraint.translateMix = data.translateMix + (translate - data.translateMix) * alpha;
  				constraint.scaleMix = data.scaleMix + (scale - data.scaleMix) * alpha;
  				constraint.shearMix = data.shearMix + (shear - data.shearMix) * alpha;
  			}
  			else {
  				constraint.rotateMix += (rotate - constraint.rotateMix) * alpha;
  				constraint.translateMix += (translate - constraint.translateMix) * alpha;
  				constraint.scaleMix += (scale - constraint.scaleMix) * alpha;
  				constraint.shearMix += (shear - constraint.shearMix) * alpha;
  			}
  		};
  		TransformConstraintTimeline.ENTRIES = 5;
  		TransformConstraintTimeline.PREV_TIME = -5;
  		TransformConstraintTimeline.PREV_ROTATE = -4;
  		TransformConstraintTimeline.PREV_TRANSLATE = -3;
  		TransformConstraintTimeline.PREV_SCALE = -2;
  		TransformConstraintTimeline.PREV_SHEAR = -1;
  		TransformConstraintTimeline.ROTATE = 1;
  		TransformConstraintTimeline.TRANSLATE = 2;
  		TransformConstraintTimeline.SCALE = 3;
  		TransformConstraintTimeline.SHEAR = 4;
  		return TransformConstraintTimeline;
  	}(CurveTimeline));
  	spine.TransformConstraintTimeline = TransformConstraintTimeline;
  	var PathConstraintPositionTimeline = (function (_super) {
  		__extends(PathConstraintPositionTimeline, _super);
  		function PathConstraintPositionTimeline(frameCount) {
  			var _this = _super.call(this, frameCount) || this;
  			_this.frames = spine.Utils.newFloatArray(frameCount * PathConstraintPositionTimeline.ENTRIES);
  			return _this;
  		}
  		PathConstraintPositionTimeline.prototype.getPropertyId = function () {
  			return (TimelineType.pathConstraintPosition << 24) + this.pathConstraintIndex;
  		};
  		PathConstraintPositionTimeline.prototype.setFrame = function (frameIndex, time, value) {
  			frameIndex *= PathConstraintPositionTimeline.ENTRIES;
  			this.frames[frameIndex] = time;
  			this.frames[frameIndex + PathConstraintPositionTimeline.VALUE] = value;
  		};
  		PathConstraintPositionTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
  			var frames = this.frames;
  			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
  			if (!constraint.active)
  				return;
  			if (time < frames[0]) {
  				switch (blend) {
  					case MixBlend.setup:
  						constraint.position = constraint.data.position;
  						return;
  					case MixBlend.first:
  						constraint.position += (constraint.data.position - constraint.position) * alpha;
  				}
  				return;
  			}
  			var position = 0;
  			if (time >= frames[frames.length - PathConstraintPositionTimeline.ENTRIES])
  				position = frames[frames.length + PathConstraintPositionTimeline.PREV_VALUE];
  			else {
  				var frame = Animation.binarySearch(frames, time, PathConstraintPositionTimeline.ENTRIES);
  				position = frames[frame + PathConstraintPositionTimeline.PREV_VALUE];
  				var frameTime = frames[frame];
  				var percent = this.getCurvePercent(frame / PathConstraintPositionTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PathConstraintPositionTimeline.PREV_TIME] - frameTime));
  				position += (frames[frame + PathConstraintPositionTimeline.VALUE] - position) * percent;
  			}
  			if (blend == MixBlend.setup)
  				constraint.position = constraint.data.position + (position - constraint.data.position) * alpha;
  			else
  				constraint.position += (position - constraint.position) * alpha;
  		};
  		PathConstraintPositionTimeline.ENTRIES = 2;
  		PathConstraintPositionTimeline.PREV_TIME = -2;
  		PathConstraintPositionTimeline.PREV_VALUE = -1;
  		PathConstraintPositionTimeline.VALUE = 1;
  		return PathConstraintPositionTimeline;
  	}(CurveTimeline));
  	spine.PathConstraintPositionTimeline = PathConstraintPositionTimeline;
  	var PathConstraintSpacingTimeline = (function (_super) {
  		__extends(PathConstraintSpacingTimeline, _super);
  		function PathConstraintSpacingTimeline(frameCount) {
  			return _super.call(this, frameCount) || this;
  		}
  		PathConstraintSpacingTimeline.prototype.getPropertyId = function () {
  			return (TimelineType.pathConstraintSpacing << 24) + this.pathConstraintIndex;
  		};
  		PathConstraintSpacingTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
  			var frames = this.frames;
  			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
  			if (!constraint.active)
  				return;
  			if (time < frames[0]) {
  				switch (blend) {
  					case MixBlend.setup:
  						constraint.spacing = constraint.data.spacing;
  						return;
  					case MixBlend.first:
  						constraint.spacing += (constraint.data.spacing - constraint.spacing) * alpha;
  				}
  				return;
  			}
  			var spacing = 0;
  			if (time >= frames[frames.length - PathConstraintSpacingTimeline.ENTRIES])
  				spacing = frames[frames.length + PathConstraintSpacingTimeline.PREV_VALUE];
  			else {
  				var frame = Animation.binarySearch(frames, time, PathConstraintSpacingTimeline.ENTRIES);
  				spacing = frames[frame + PathConstraintSpacingTimeline.PREV_VALUE];
  				var frameTime = frames[frame];
  				var percent = this.getCurvePercent(frame / PathConstraintSpacingTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PathConstraintSpacingTimeline.PREV_TIME] - frameTime));
  				spacing += (frames[frame + PathConstraintSpacingTimeline.VALUE] - spacing) * percent;
  			}
  			if (blend == MixBlend.setup)
  				constraint.spacing = constraint.data.spacing + (spacing - constraint.data.spacing) * alpha;
  			else
  				constraint.spacing += (spacing - constraint.spacing) * alpha;
  		};
  		return PathConstraintSpacingTimeline;
  	}(PathConstraintPositionTimeline));
  	spine.PathConstraintSpacingTimeline = PathConstraintSpacingTimeline;
  	var PathConstraintMixTimeline = (function (_super) {
  		__extends(PathConstraintMixTimeline, _super);
  		function PathConstraintMixTimeline(frameCount) {
  			var _this = _super.call(this, frameCount) || this;
  			_this.frames = spine.Utils.newFloatArray(frameCount * PathConstraintMixTimeline.ENTRIES);
  			return _this;
  		}
  		PathConstraintMixTimeline.prototype.getPropertyId = function () {
  			return (TimelineType.pathConstraintMix << 24) + this.pathConstraintIndex;
  		};
  		PathConstraintMixTimeline.prototype.setFrame = function (frameIndex, time, rotateMix, translateMix) {
  			frameIndex *= PathConstraintMixTimeline.ENTRIES;
  			this.frames[frameIndex] = time;
  			this.frames[frameIndex + PathConstraintMixTimeline.ROTATE] = rotateMix;
  			this.frames[frameIndex + PathConstraintMixTimeline.TRANSLATE] = translateMix;
  		};
  		PathConstraintMixTimeline.prototype.apply = function (skeleton, lastTime, time, firedEvents, alpha, blend, direction) {
  			var frames = this.frames;
  			var constraint = skeleton.pathConstraints[this.pathConstraintIndex];
  			if (!constraint.active)
  				return;
  			if (time < frames[0]) {
  				switch (blend) {
  					case MixBlend.setup:
  						constraint.rotateMix = constraint.data.rotateMix;
  						constraint.translateMix = constraint.data.translateMix;
  						return;
  					case MixBlend.first:
  						constraint.rotateMix += (constraint.data.rotateMix - constraint.rotateMix) * alpha;
  						constraint.translateMix += (constraint.data.translateMix - constraint.translateMix) * alpha;
  				}
  				return;
  			}
  			var rotate = 0, translate = 0;
  			if (time >= frames[frames.length - PathConstraintMixTimeline.ENTRIES]) {
  				rotate = frames[frames.length + PathConstraintMixTimeline.PREV_ROTATE];
  				translate = frames[frames.length + PathConstraintMixTimeline.PREV_TRANSLATE];
  			}
  			else {
  				var frame = Animation.binarySearch(frames, time, PathConstraintMixTimeline.ENTRIES);
  				rotate = frames[frame + PathConstraintMixTimeline.PREV_ROTATE];
  				translate = frames[frame + PathConstraintMixTimeline.PREV_TRANSLATE];
  				var frameTime = frames[frame];
  				var percent = this.getCurvePercent(frame / PathConstraintMixTimeline.ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PathConstraintMixTimeline.PREV_TIME] - frameTime));
  				rotate += (frames[frame + PathConstraintMixTimeline.ROTATE] - rotate) * percent;
  				translate += (frames[frame + PathConstraintMixTimeline.TRANSLATE] - translate) * percent;
  			}
  			if (blend == MixBlend.setup) {
  				constraint.rotateMix = constraint.data.rotateMix + (rotate - constraint.data.rotateMix) * alpha;
  				constraint.translateMix = constraint.data.translateMix + (translate - constraint.data.translateMix) * alpha;
  			}
  			else {
  				constraint.rotateMix += (rotate - constraint.rotateMix) * alpha;
  				constraint.translateMix += (translate - constraint.translateMix) * alpha;
  			}
  		};
  		PathConstraintMixTimeline.ENTRIES = 3;
  		PathConstraintMixTimeline.PREV_TIME = -3;
  		PathConstraintMixTimeline.PREV_ROTATE = -2;
  		PathConstraintMixTimeline.PREV_TRANSLATE = -1;
  		PathConstraintMixTimeline.ROTATE = 1;
  		PathConstraintMixTimeline.TRANSLATE = 2;
  		return PathConstraintMixTimeline;
  	}(CurveTimeline));
  	spine.PathConstraintMixTimeline = PathConstraintMixTimeline;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var AnimationState = (function () {
  		function AnimationState(data) {
  			this.tracks = new Array();
  			this.timeScale = 1;
  			this.unkeyedState = 0;
  			this.events = new Array();
  			this.listeners = new Array();
  			this.queue = new EventQueue(this);
  			this.propertyIDs = new spine.IntSet();
  			this.animationsChanged = false;
  			this.trackEntryPool = new spine.Pool(function () { return new TrackEntry(); });
  			this.data = data;
  		}
  		AnimationState.prototype.update = function (delta) {
  			delta *= this.timeScale;
  			var tracks = this.tracks;
  			for (var i = 0, n = tracks.length; i < n; i++) {
  				var current = tracks[i];
  				if (current == null)
  					continue;
  				current.animationLast = current.nextAnimationLast;
  				current.trackLast = current.nextTrackLast;
  				var currentDelta = delta * current.timeScale;
  				if (current.delay > 0) {
  					current.delay -= currentDelta;
  					if (current.delay > 0)
  						continue;
  					currentDelta = -current.delay;
  					current.delay = 0;
  				}
  				var next = current.next;
  				if (next != null) {
  					var nextTime = current.trackLast - next.delay;
  					if (nextTime >= 0) {
  						next.delay = 0;
  						next.trackTime += current.timeScale == 0 ? 0 : (nextTime / current.timeScale + delta) * next.timeScale;
  						current.trackTime += currentDelta;
  						this.setCurrent(i, next, true);
  						while (next.mixingFrom != null) {
  							next.mixTime += delta;
  							next = next.mixingFrom;
  						}
  						continue;
  					}
  				}
  				else if (current.trackLast >= current.trackEnd && current.mixingFrom == null) {
  					tracks[i] = null;
  					this.queue.end(current);
  					this.disposeNext(current);
  					continue;
  				}
  				if (current.mixingFrom != null && this.updateMixingFrom(current, delta)) {
  					var from = current.mixingFrom;
  					current.mixingFrom = null;
  					if (from != null)
  						from.mixingTo = null;
  					while (from != null) {
  						this.queue.end(from);
  						from = from.mixingFrom;
  					}
  				}
  				current.trackTime += currentDelta;
  			}
  			this.queue.drain();
  		};
  		AnimationState.prototype.updateMixingFrom = function (to, delta) {
  			var from = to.mixingFrom;
  			if (from == null)
  				return true;
  			var finished = this.updateMixingFrom(from, delta);
  			from.animationLast = from.nextAnimationLast;
  			from.trackLast = from.nextTrackLast;
  			if (to.mixTime > 0 && to.mixTime >= to.mixDuration) {
  				if (from.totalAlpha == 0 || to.mixDuration == 0) {
  					to.mixingFrom = from.mixingFrom;
  					if (from.mixingFrom != null)
  						from.mixingFrom.mixingTo = to;
  					to.interruptAlpha = from.interruptAlpha;
  					this.queue.end(from);
  				}
  				return finished;
  			}
  			from.trackTime += delta * from.timeScale;
  			to.mixTime += delta;
  			return false;
  		};
  		AnimationState.prototype.apply = function (skeleton) {
  			if (skeleton == null)
  				throw new Error("skeleton cannot be null.");
  			if (this.animationsChanged)
  				this._animationsChanged();
  			var events = this.events;
  			var tracks = this.tracks;
  			var applied = false;
  			for (var i_16 = 0, n_1 = tracks.length; i_16 < n_1; i_16++) {
  				var current = tracks[i_16];
  				if (current == null || current.delay > 0)
  					continue;
  				applied = true;
  				var blend = i_16 == 0 ? spine.MixBlend.first : current.mixBlend;
  				var mix = current.alpha;
  				if (current.mixingFrom != null)
  					mix *= this.applyMixingFrom(current, skeleton, blend);
  				else if (current.trackTime >= current.trackEnd && current.next == null)
  					mix = 0;
  				var animationLast = current.animationLast, animationTime = current.getAnimationTime();
  				var timelineCount = current.animation.timelines.length;
  				var timelines = current.animation.timelines;
  				if ((i_16 == 0 && mix == 1) || blend == spine.MixBlend.add) {
  					for (var ii = 0; ii < timelineCount; ii++) {
  						spine.Utils.webkit602BugfixHelper(mix, blend);
  						var timeline = timelines[ii];
  						if (timeline instanceof spine.AttachmentTimeline)
  							this.applyAttachmentTimeline(timeline, skeleton, animationTime, blend, true);
  						else
  							timeline.apply(skeleton, animationLast, animationTime, events, mix, blend, spine.MixDirection.mixIn);
  					}
  				}
  				else {
  					var timelineMode = current.timelineMode;
  					var firstFrame = current.timelinesRotation.length == 0;
  					if (firstFrame)
  						spine.Utils.setArraySize(current.timelinesRotation, timelineCount << 1, null);
  					var timelinesRotation = current.timelinesRotation;
  					for (var ii = 0; ii < timelineCount; ii++) {
  						var timeline_1 = timelines[ii];
  						var timelineBlend = timelineMode[ii] == AnimationState.SUBSEQUENT ? blend : spine.MixBlend.setup;
  						if (timeline_1 instanceof spine.RotateTimeline) {
  							this.applyRotateTimeline(timeline_1, skeleton, animationTime, mix, timelineBlend, timelinesRotation, ii << 1, firstFrame);
  						}
  						else if (timeline_1 instanceof spine.AttachmentTimeline) {
  							this.applyAttachmentTimeline(timeline_1, skeleton, animationTime, blend, true);
  						}
  						else {
  							spine.Utils.webkit602BugfixHelper(mix, blend);
  							timeline_1.apply(skeleton, animationLast, animationTime, events, mix, timelineBlend, spine.MixDirection.mixIn);
  						}
  					}
  				}
  				this.queueEvents(current, animationTime);
  				events.length = 0;
  				current.nextAnimationLast = animationTime;
  				current.nextTrackLast = current.trackTime;
  			}
  			var setupState = this.unkeyedState + AnimationState.SETUP;
  			var slots = skeleton.slots;
  			for (var i = 0, n = skeleton.slots.length; i < n; i++) {
  				var slot = slots[i];
  				if (slot.attachmentState == setupState) {
  					var attachmentName = slot.data.attachmentName;
  					slot.attachment = (attachmentName == null ? null : skeleton.getAttachment(slot.data.index, attachmentName));
  				}
  			}
  			this.unkeyedState += 2;
  			this.queue.drain();
  			return applied;
  		};
  		AnimationState.prototype.applyMixingFrom = function (to, skeleton, blend) {
  			var from = to.mixingFrom;
  			if (from.mixingFrom != null)
  				this.applyMixingFrom(from, skeleton, blend);
  			var mix = 0;
  			if (to.mixDuration == 0) {
  				mix = 1;
  				if (blend == spine.MixBlend.first)
  					blend = spine.MixBlend.setup;
  			}
  			else {
  				mix = to.mixTime / to.mixDuration;
  				if (mix > 1)
  					mix = 1;
  				if (blend != spine.MixBlend.first)
  					blend = from.mixBlend;
  			}
  			var events = mix < from.eventThreshold ? this.events : null;
  			var attachments = mix < from.attachmentThreshold, drawOrder = mix < from.drawOrderThreshold;
  			var animationLast = from.animationLast, animationTime = from.getAnimationTime();
  			var timelineCount = from.animation.timelines.length;
  			var timelines = from.animation.timelines;
  			var alphaHold = from.alpha * to.interruptAlpha, alphaMix = alphaHold * (1 - mix);
  			if (blend == spine.MixBlend.add) {
  				for (var i = 0; i < timelineCount; i++)
  					timelines[i].apply(skeleton, animationLast, animationTime, events, alphaMix, blend, spine.MixDirection.mixOut);
  			}
  			else {
  				var timelineMode = from.timelineMode;
  				var timelineHoldMix = from.timelineHoldMix;
  				var firstFrame = from.timelinesRotation.length == 0;
  				if (firstFrame)
  					spine.Utils.setArraySize(from.timelinesRotation, timelineCount << 1, null);
  				var timelinesRotation = from.timelinesRotation;
  				from.totalAlpha = 0;
  				for (var i = 0; i < timelineCount; i++) {
  					var timeline = timelines[i];
  					var direction = spine.MixDirection.mixOut;
  					var timelineBlend = void 0;
  					var alpha = 0;
  					switch (timelineMode[i]) {
  						case AnimationState.SUBSEQUENT:
  							if (!drawOrder && timeline instanceof spine.DrawOrderTimeline)
  								continue;
  							timelineBlend = blend;
  							alpha = alphaMix;
  							break;
  						case AnimationState.FIRST:
  							timelineBlend = spine.MixBlend.setup;
  							alpha = alphaMix;
  							break;
  						case AnimationState.HOLD:
  							timelineBlend = spine.MixBlend.setup;
  							alpha = alphaHold;
  							break;
  						default:
  							timelineBlend = spine.MixBlend.setup;
  							var holdMix = timelineHoldMix[i];
  							alpha = alphaHold * Math.max(0, 1 - holdMix.mixTime / holdMix.mixDuration);
  							break;
  					}
  					from.totalAlpha += alpha;
  					if (timeline instanceof spine.RotateTimeline)
  						this.applyRotateTimeline(timeline, skeleton, animationTime, alpha, timelineBlend, timelinesRotation, i << 1, firstFrame);
  					else if (timeline instanceof spine.AttachmentTimeline)
  						this.applyAttachmentTimeline(timeline, skeleton, animationTime, timelineBlend, attachments);
  					else {
  						spine.Utils.webkit602BugfixHelper(alpha, blend);
  						if (drawOrder && timeline instanceof spine.DrawOrderTimeline && timelineBlend == spine.MixBlend.setup)
  							direction = spine.MixDirection.mixIn;
  						timeline.apply(skeleton, animationLast, animationTime, events, alpha, timelineBlend, direction);
  					}
  				}
  			}
  			if (to.mixDuration > 0)
  				this.queueEvents(from, animationTime);
  			this.events.length = 0;
  			from.nextAnimationLast = animationTime;
  			from.nextTrackLast = from.trackTime;
  			return mix;
  		};
  		AnimationState.prototype.applyAttachmentTimeline = function (timeline, skeleton, time, blend, attachments) {
  			var slot = skeleton.slots[timeline.slotIndex];
  			if (!slot.bone.active)
  				return;
  			var frames = timeline.frames;
  			if (time < frames[0]) {
  				if (blend == spine.MixBlend.setup || blend == spine.MixBlend.first)
  					this.setAttachment(skeleton, slot, slot.data.attachmentName, attachments);
  			}
  			else {
  				var frameIndex;
  				if (time >= frames[frames.length - 1])
  					frameIndex = frames.length - 1;
  				else
  					frameIndex = spine.Animation.binarySearch(frames, time) - 1;
  				this.setAttachment(skeleton, slot, timeline.attachmentNames[frameIndex], attachments);
  			}
  			if (slot.attachmentState <= this.unkeyedState)
  				slot.attachmentState = this.unkeyedState + AnimationState.SETUP;
  		};
  		AnimationState.prototype.setAttachment = function (skeleton, slot, attachmentName, attachments) {
  			slot.attachment = attachmentName == null ? null : skeleton.getAttachment(slot.data.index, attachmentName);
  			if (attachments)
  				slot.attachmentState = this.unkeyedState + AnimationState.CURRENT;
  		};
  		AnimationState.prototype.applyRotateTimeline = function (timeline, skeleton, time, alpha, blend, timelinesRotation, i, firstFrame) {
  			if (firstFrame)
  				timelinesRotation[i] = 0;
  			if (alpha == 1) {
  				timeline.apply(skeleton, 0, time, null, 1, blend, spine.MixDirection.mixIn);
  				return;
  			}
  			var rotateTimeline = timeline;
  			var frames = rotateTimeline.frames;
  			var bone = skeleton.bones[rotateTimeline.boneIndex];
  			if (!bone.active)
  				return;
  			var r1 = 0, r2 = 0;
  			if (time < frames[0]) {
  				switch (blend) {
  					case spine.MixBlend.setup:
  						bone.rotation = bone.data.rotation;
  					default:
  						return;
  					case spine.MixBlend.first:
  						r1 = bone.rotation;
  						r2 = bone.data.rotation;
  				}
  			}
  			else {
  				r1 = blend == spine.MixBlend.setup ? bone.data.rotation : bone.rotation;
  				if (time >= frames[frames.length - spine.RotateTimeline.ENTRIES])
  					r2 = bone.data.rotation + frames[frames.length + spine.RotateTimeline.PREV_ROTATION];
  				else {
  					var frame = spine.Animation.binarySearch(frames, time, spine.RotateTimeline.ENTRIES);
  					var prevRotation = frames[frame + spine.RotateTimeline.PREV_ROTATION];
  					var frameTime = frames[frame];
  					var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime));
  					r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
  					r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
  					r2 = prevRotation + r2 * percent + bone.data.rotation;
  					r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
  				}
  			}
  			var total = 0, diff = r2 - r1;
  			diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
  			if (diff == 0) {
  				total = timelinesRotation[i];
  			}
  			else {
  				var lastTotal = 0, lastDiff = 0;
  				if (firstFrame) {
  					lastTotal = 0;
  					lastDiff = diff;
  				}
  				else {
  					lastTotal = timelinesRotation[i];
  					lastDiff = timelinesRotation[i + 1];
  				}
  				var current = diff > 0, dir = lastTotal >= 0;
  				if (spine.MathUtils.signum(lastDiff) != spine.MathUtils.signum(diff) && Math.abs(lastDiff) <= 90) {
  					if (Math.abs(lastTotal) > 180)
  						lastTotal += 360 * spine.MathUtils.signum(lastTotal);
  					dir = current;
  				}
  				total = diff + lastTotal - lastTotal % 360;
  				if (dir != current)
  					total += 360 * spine.MathUtils.signum(lastTotal);
  				timelinesRotation[i] = total;
  			}
  			timelinesRotation[i + 1] = diff;
  			r1 += total * alpha;
  			bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360;
  		};
  		AnimationState.prototype.queueEvents = function (entry, animationTime) {
  			var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
  			var duration = animationEnd - animationStart;
  			var trackLastWrapped = entry.trackLast % duration;
  			var events = this.events;
  			var i = 0, n = events.length;
  			for (; i < n; i++) {
  				var event_1 = events[i];
  				if (event_1.time < trackLastWrapped)
  					break;
  				if (event_1.time > animationEnd)
  					continue;
  				this.queue.event(entry, event_1);
  			}
  			var complete = false;
  			if (entry.loop)
  				complete = duration == 0 || trackLastWrapped > entry.trackTime % duration;
  			else
  				complete = animationTime >= animationEnd && entry.animationLast < animationEnd;
  			if (complete)
  				this.queue.complete(entry);
  			for (; i < n; i++) {
  				var event_2 = events[i];
  				if (event_2.time < animationStart)
  					continue;
  				this.queue.event(entry, events[i]);
  			}
  		};
  		AnimationState.prototype.clearTracks = function () {
  			var oldDrainDisabled = this.queue.drainDisabled;
  			this.queue.drainDisabled = true;
  			for (var i = 0, n = this.tracks.length; i < n; i++)
  				this.clearTrack(i);
  			this.tracks.length = 0;
  			this.queue.drainDisabled = oldDrainDisabled;
  			this.queue.drain();
  		};
  		AnimationState.prototype.clearTrack = function (trackIndex) {
  			if (trackIndex >= this.tracks.length)
  				return;
  			var current = this.tracks[trackIndex];
  			if (current == null)
  				return;
  			this.queue.end(current);
  			this.disposeNext(current);
  			var entry = current;
  			while (true) {
  				var from = entry.mixingFrom;
  				if (from == null)
  					break;
  				this.queue.end(from);
  				entry.mixingFrom = null;
  				entry.mixingTo = null;
  				entry = from;
  			}
  			this.tracks[current.trackIndex] = null;
  			this.queue.drain();
  		};
  		AnimationState.prototype.setCurrent = function (index, current, interrupt) {
  			var from = this.expandToIndex(index);
  			this.tracks[index] = current;
  			if (from != null) {
  				if (interrupt)
  					this.queue.interrupt(from);
  				current.mixingFrom = from;
  				from.mixingTo = current;
  				current.mixTime = 0;
  				if (from.mixingFrom != null && from.mixDuration > 0)
  					current.interruptAlpha *= Math.min(1, from.mixTime / from.mixDuration);
  				from.timelinesRotation.length = 0;
  			}
  			this.queue.start(current);
  		};
  		AnimationState.prototype.setAnimation = function (trackIndex, animationName, loop) {
  			var animation = this.data.skeletonData.findAnimation(animationName);
  			if (animation == null)
  				throw new Error("Animation not found: " + animationName);
  			return this.setAnimationWith(trackIndex, animation, loop);
  		};
  		AnimationState.prototype.setAnimationWith = function (trackIndex, animation, loop) {
  			if (animation == null)
  				throw new Error("animation cannot be null.");
  			var interrupt = true;
  			var current = this.expandToIndex(trackIndex);
  			if (current != null) {
  				if (current.nextTrackLast == -1) {
  					this.tracks[trackIndex] = current.mixingFrom;
  					this.queue.interrupt(current);
  					this.queue.end(current);
  					this.disposeNext(current);
  					current = current.mixingFrom;
  					interrupt = false;
  				}
  				else
  					this.disposeNext(current);
  			}
  			var entry = this.trackEntry(trackIndex, animation, loop, current);
  			this.setCurrent(trackIndex, entry, interrupt);
  			this.queue.drain();
  			return entry;
  		};
  		AnimationState.prototype.addAnimation = function (trackIndex, animationName, loop, delay) {
  			var animation = this.data.skeletonData.findAnimation(animationName);
  			if (animation == null)
  				throw new Error("Animation not found: " + animationName);
  			return this.addAnimationWith(trackIndex, animation, loop, delay);
  		};
  		AnimationState.prototype.addAnimationWith = function (trackIndex, animation, loop, delay) {
  			if (animation == null)
  				throw new Error("animation cannot be null.");
  			var last = this.expandToIndex(trackIndex);
  			if (last != null) {
  				while (last.next != null)
  					last = last.next;
  			}
  			var entry = this.trackEntry(trackIndex, animation, loop, last);
  			if (last == null) {
  				this.setCurrent(trackIndex, entry, true);
  				this.queue.drain();
  			}
  			else {
  				last.next = entry;
  				if (delay <= 0) {
  					var duration = last.animationEnd - last.animationStart;
  					if (duration != 0) {
  						if (last.loop)
  							delay += duration * (1 + ((last.trackTime / duration) | 0));
  						else
  							delay += Math.max(duration, last.trackTime);
  						delay -= this.data.getMix(last.animation, animation);
  					}
  					else
  						delay = last.trackTime;
  				}
  			}
  			entry.delay = delay;
  			return entry;
  		};
  		AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) {
  			var entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false);
  			entry.mixDuration = mixDuration;
  			entry.trackEnd = mixDuration;
  			return entry;
  		};
  		AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
  			if (delay <= 0)
  				delay -= mixDuration;
  			var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
  			entry.mixDuration = mixDuration;
  			entry.trackEnd = mixDuration;
  			return entry;
  		};
  		AnimationState.prototype.setEmptyAnimations = function (mixDuration) {
  			var oldDrainDisabled = this.queue.drainDisabled;
  			this.queue.drainDisabled = true;
  			for (var i = 0, n = this.tracks.length; i < n; i++) {
  				var current = this.tracks[i];
  				if (current != null)
  					this.setEmptyAnimation(current.trackIndex, mixDuration);
  			}
  			this.queue.drainDisabled = oldDrainDisabled;
  			this.queue.drain();
  		};
  		AnimationState.prototype.expandToIndex = function (index) {
  			if (index < this.tracks.length)
  				return this.tracks[index];
  			spine.Utils.ensureArrayCapacity(this.tracks, index + 1, null);
  			this.tracks.length = index + 1;
  			return null;
  		};
  		AnimationState.prototype.trackEntry = function (trackIndex, animation, loop, last) {
  			var entry = this.trackEntryPool.obtain();
  			entry.trackIndex = trackIndex;
  			entry.animation = animation;
  			entry.loop = loop;
  			entry.holdPrevious = false;
  			entry.eventThreshold = 0;
  			entry.attachmentThreshold = 0;
  			entry.drawOrderThreshold = 0;
  			entry.animationStart = 0;
  			entry.animationEnd = animation.duration;
  			entry.animationLast = -1;
  			entry.nextAnimationLast = -1;
  			entry.delay = 0;
  			entry.trackTime = 0;
  			entry.trackLast = -1;
  			entry.nextTrackLast = -1;
  			entry.trackEnd = Number.MAX_VALUE;
  			entry.timeScale = 1;
  			entry.alpha = 1;
  			entry.interruptAlpha = 1;
  			entry.mixTime = 0;
  			entry.mixDuration = last == null ? 0 : this.data.getMix(last.animation, animation);
  			entry.mixBlend = spine.MixBlend.replace;
  			return entry;
  		};
  		AnimationState.prototype.disposeNext = function (entry) {
  			var next = entry.next;
  			while (next != null) {
  				this.queue.dispose(next);
  				next = next.next;
  			}
  			entry.next = null;
  		};
  		AnimationState.prototype._animationsChanged = function () {
  			this.animationsChanged = false;
  			this.propertyIDs.clear();
  			for (var i = 0, n = this.tracks.length; i < n; i++) {
  				var entry = this.tracks[i];
  				if (entry == null)
  					continue;
  				while (entry.mixingFrom != null)
  					entry = entry.mixingFrom;
  				do {
  					if (entry.mixingFrom == null || entry.mixBlend != spine.MixBlend.add)
  						this.computeHold(entry);
  					entry = entry.mixingTo;
  				} while (entry != null);
  			}
  		};
  		AnimationState.prototype.computeHold = function (entry) {
  			var to = entry.mixingTo;
  			var timelines = entry.animation.timelines;
  			var timelinesCount = entry.animation.timelines.length;
  			var timelineMode = spine.Utils.setArraySize(entry.timelineMode, timelinesCount);
  			entry.timelineHoldMix.length = 0;
  			var timelineDipMix = spine.Utils.setArraySize(entry.timelineHoldMix, timelinesCount);
  			var propertyIDs = this.propertyIDs;
  			if (to != null && to.holdPrevious) {
  				for (var i = 0; i < timelinesCount; i++) {
  					propertyIDs.add(timelines[i].getPropertyId());
  					timelineMode[i] = AnimationState.HOLD;
  				}
  				return;
  			}
  			outer: for (var i = 0; i < timelinesCount; i++) {
  				var timeline = timelines[i];
  				var id = timeline.getPropertyId();
  				if (!propertyIDs.add(id))
  					timelineMode[i] = AnimationState.SUBSEQUENT;
  				else if (to == null || timeline instanceof spine.AttachmentTimeline || timeline instanceof spine.DrawOrderTimeline
  					|| timeline instanceof spine.EventTimeline || !to.animation.hasTimeline(id)) {
  					timelineMode[i] = AnimationState.FIRST;
  				}
  				else {
  					for (var next = to.mixingTo; next != null; next = next.mixingTo) {
  						if (next.animation.hasTimeline(id))
  							continue;
  						if (entry.mixDuration > 0) {
  							timelineMode[i] = AnimationState.HOLD_MIX;
  							timelineDipMix[i] = next;
  							continue outer;
  						}
  						break;
  					}
  					timelineMode[i] = AnimationState.HOLD;
  				}
  			}
  		};
  		AnimationState.prototype.getCurrent = function (trackIndex) {
  			if (trackIndex >= this.tracks.length)
  				return null;
  			return this.tracks[trackIndex];
  		};
  		AnimationState.prototype.addListener = function (listener) {
  			if (listener == null)
  				throw new Error("listener cannot be null.");
  			this.listeners.push(listener);
  		};
  		AnimationState.prototype.removeListener = function (listener) {
  			var index = this.listeners.indexOf(listener);
  			if (index >= 0)
  				this.listeners.splice(index, 1);
  		};
  		AnimationState.prototype.clearListeners = function () {
  			this.listeners.length = 0;
  		};
  		AnimationState.prototype.clearListenerNotifications = function () {
  			this.queue.clear();
  		};
  		AnimationState.emptyAnimation = new spine.Animation("<empty>", [], 0);
  		AnimationState.SUBSEQUENT = 0;
  		AnimationState.FIRST = 1;
  		AnimationState.HOLD = 2;
  		AnimationState.HOLD_MIX = 3;
  		AnimationState.SETUP = 1;
  		AnimationState.CURRENT = 2;
  		return AnimationState;
  	}());
  	spine.AnimationState = AnimationState;
  	var TrackEntry = (function () {
  		function TrackEntry() {
  			this.mixBlend = spine.MixBlend.replace;
  			this.timelineMode = new Array();
  			this.timelineHoldMix = new Array();
  			this.timelinesRotation = new Array();
  		}
  		TrackEntry.prototype.reset = function () {
  			this.next = null;
  			this.mixingFrom = null;
  			this.mixingTo = null;
  			this.animation = null;
  			this.listener = null;
  			this.timelineMode.length = 0;
  			this.timelineHoldMix.length = 0;
  			this.timelinesRotation.length = 0;
  		};
  		TrackEntry.prototype.getAnimationTime = function () {
  			if (this.loop) {
  				var duration = this.animationEnd - this.animationStart;
  				if (duration == 0)
  					return this.animationStart;
  				return (this.trackTime % duration) + this.animationStart;
  			}
  			return Math.min(this.trackTime + this.animationStart, this.animationEnd);
  		};
  		TrackEntry.prototype.setAnimationLast = function (animationLast) {
  			this.animationLast = animationLast;
  			this.nextAnimationLast = animationLast;
  		};
  		TrackEntry.prototype.isComplete = function () {
  			return this.trackTime >= this.animationEnd - this.animationStart;
  		};
  		TrackEntry.prototype.resetRotationDirections = function () {
  			this.timelinesRotation.length = 0;
  		};
  		return TrackEntry;
  	}());
  	spine.TrackEntry = TrackEntry;
  	var EventQueue = (function () {
  		function EventQueue(animState) {
  			this.objects = [];
  			this.drainDisabled = false;
  			this.animState = animState;
  		}
  		EventQueue.prototype.start = function (entry) {
  			this.objects.push(EventType.start);
  			this.objects.push(entry);
  			this.animState.animationsChanged = true;
  		};
  		EventQueue.prototype.interrupt = function (entry) {
  			this.objects.push(EventType.interrupt);
  			this.objects.push(entry);
  		};
  		EventQueue.prototype.end = function (entry) {
  			this.objects.push(EventType.end);
  			this.objects.push(entry);
  			this.animState.animationsChanged = true;
  		};
  		EventQueue.prototype.dispose = function (entry) {
  			this.objects.push(EventType.dispose);
  			this.objects.push(entry);
  		};
  		EventQueue.prototype.complete = function (entry) {
  			this.objects.push(EventType.complete);
  			this.objects.push(entry);
  		};
  		EventQueue.prototype.event = function (entry, event) {
  			this.objects.push(EventType.event);
  			this.objects.push(entry);
  			this.objects.push(event);
  		};
  		EventQueue.prototype.drain = function () {
  			if (this.drainDisabled)
  				return;
  			this.drainDisabled = true;
  			var objects = this.objects;
  			var listeners = this.animState.listeners;
  			for (var i = 0; i < objects.length; i += 2) {
  				var type = objects[i];
  				var entry = objects[i + 1];
  				switch (type) {
  					case EventType.start:
  						if (entry.listener != null && entry.listener.start)
  							entry.listener.start(entry);
  						for (var ii = 0; ii < listeners.length; ii++)
  							if (listeners[ii].start)
  								listeners[ii].start(entry);
  						break;
  					case EventType.interrupt:
  						if (entry.listener != null && entry.listener.interrupt)
  							entry.listener.interrupt(entry);
  						for (var ii = 0; ii < listeners.length; ii++)
  							if (listeners[ii].interrupt)
  								listeners[ii].interrupt(entry);
  						break;
  					case EventType.end:
  						if (entry.listener != null && entry.listener.end)
  							entry.listener.end(entry);
  						for (var ii = 0; ii < listeners.length; ii++)
  							if (listeners[ii].end)
  								listeners[ii].end(entry);
  					case EventType.dispose:
  						if (entry.listener != null && entry.listener.dispose)
  							entry.listener.dispose(entry);
  						for (var ii = 0; ii < listeners.length; ii++)
  							if (listeners[ii].dispose)
  								listeners[ii].dispose(entry);
  						this.animState.trackEntryPool.free(entry);
  						break;
  					case EventType.complete:
  						if (entry.listener != null && entry.listener.complete)
  							entry.listener.complete(entry);
  						for (var ii = 0; ii < listeners.length; ii++)
  							if (listeners[ii].complete)
  								listeners[ii].complete(entry);
  						break;
  					case EventType.event:
  						var event_3 = objects[i++ + 2];
  						if (entry.listener != null && entry.listener.event)
  							entry.listener.event(entry, event_3);
  						for (var ii = 0; ii < listeners.length; ii++)
  							if (listeners[ii].event)
  								listeners[ii].event(entry, event_3);
  						break;
  				}
  			}
  			this.clear();
  			this.drainDisabled = false;
  		};
  		EventQueue.prototype.clear = function () {
  			this.objects.length = 0;
  		};
  		return EventQueue;
  	}());
  	spine.EventQueue = EventQueue;
  	var EventType;
  	(function (EventType) {
  		EventType[EventType["start"] = 0] = "start";
  		EventType[EventType["interrupt"] = 1] = "interrupt";
  		EventType[EventType["end"] = 2] = "end";
  		EventType[EventType["dispose"] = 3] = "dispose";
  		EventType[EventType["complete"] = 4] = "complete";
  		EventType[EventType["event"] = 5] = "event";
  	})(EventType = spine.EventType || (spine.EventType = {}));
  	var AnimationStateAdapter = (function () {
  		function AnimationStateAdapter() {
  		}
  		AnimationStateAdapter.prototype.start = function (entry) {
  		};
  		AnimationStateAdapter.prototype.interrupt = function (entry) {
  		};
  		AnimationStateAdapter.prototype.end = function (entry) {
  		};
  		AnimationStateAdapter.prototype.dispose = function (entry) {
  		};
  		AnimationStateAdapter.prototype.complete = function (entry) {
  		};
  		AnimationStateAdapter.prototype.event = function (entry, event) {
  		};
  		return AnimationStateAdapter;
  	}());
  	spine.AnimationStateAdapter = AnimationStateAdapter;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var AnimationStateData = (function () {
  		function AnimationStateData(skeletonData) {
  			this.animationToMixTime = {};
  			this.defaultMix = 0;
  			if (skeletonData == null)
  				throw new Error("skeletonData cannot be null.");
  			this.skeletonData = skeletonData;
  		}
  		AnimationStateData.prototype.setMix = function (fromName, toName, duration) {
  			var from = this.skeletonData.findAnimation(fromName);
  			if (from == null)
  				throw new Error("Animation not found: " + fromName);
  			var to = this.skeletonData.findAnimation(toName);
  			if (to == null)
  				throw new Error("Animation not found: " + toName);
  			this.setMixWith(from, to, duration);
  		};
  		AnimationStateData.prototype.setMixWith = function (from, to, duration) {
  			if (from == null)
  				throw new Error("from cannot be null.");
  			if (to == null)
  				throw new Error("to cannot be null.");
  			var key = from.name + "." + to.name;
  			this.animationToMixTime[key] = duration;
  		};
  		AnimationStateData.prototype.getMix = function (from, to) {
  			var key = from.name + "." + to.name;
  			var value = this.animationToMixTime[key];
  			return value === undefined ? this.defaultMix : value;
  		};
  		return AnimationStateData;
  	}());
  	spine.AnimationStateData = AnimationStateData;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var AssetManager = (function () {
  		function AssetManager(textureLoader, pathPrefix) {
  			if (pathPrefix === void 0) { pathPrefix = ""; }
  			this.assets = {};
  			this.errors = {};
  			this.toLoad = 0;
  			this.loaded = 0;
  			this.rawDataUris = {};
  			this.textureLoader = textureLoader;
  			this.pathPrefix = pathPrefix;
  		}
  		AssetManager.prototype.downloadText = function (url, success, error) {
  			var request = new XMLHttpRequest();
  			request.overrideMimeType("text/html");
  			if (this.rawDataUris[url])
  				url = this.rawDataUris[url];
  			request.open("GET", url, true);
  			request.onload = function () {
  				if (request.status == 200) {
  					success(request.responseText);
  				}
  				else {
  					error(request.status, request.responseText);
  				}
  			};
  			request.onerror = function () {
  				error(request.status, request.responseText);
  			};
  			request.send();
  		};
  		AssetManager.prototype.downloadBinary = function (url, success, error) {
  			var request = new XMLHttpRequest();
  			if (this.rawDataUris[url])
  				url = this.rawDataUris[url];
  			request.open("GET", url, true);
  			request.responseType = "arraybuffer";
  			request.onload = function () {
  				if (request.status == 200) {
  					success(new Uint8Array(request.response));
  				}
  				else {
  					error(request.status, request.responseText);
  				}
  			};
  			request.onerror = function () {
  				error(request.status, request.responseText);
  			};
  			request.send();
  		};
  		AssetManager.prototype.setRawDataURI = function (path, data) {
  			this.rawDataUris[this.pathPrefix + path] = data;
  		};
  		AssetManager.prototype.loadBinary = function (path, success, error) {
  			var _this = this;
  			if (success === void 0) { success = null; }
  			if (error === void 0) { error = null; }
  			path = this.pathPrefix + path;
  			this.toLoad++;
  			this.downloadBinary(path, function (data) {
  				_this.assets[path] = data;
  				if (success)
  					success(path, data);
  				_this.toLoad--;
  				_this.loaded++;
  			}, function (state, responseText) {
  				_this.errors[path] = "Couldn't load binary " + path + ": status " + status + ", " + responseText;
  				if (error)
  					error(path, "Couldn't load binary " + path + ": status " + status + ", " + responseText);
  				_this.toLoad--;
  				_this.loaded++;
  			});
  		};
  		AssetManager.prototype.loadText = function (path, success, error) {
  			var _this = this;
  			if (success === void 0) { success = null; }
  			if (error === void 0) { error = null; }
  			path = this.pathPrefix + path;
  			this.toLoad++;
  			this.downloadText(path, function (data) {
  				_this.assets[path] = data;
  				if (success)
  					success(path, data);
  				_this.toLoad--;
  				_this.loaded++;
  			}, function (state, responseText) {
  				_this.errors[path] = "Couldn't load text " + path + ": status " + status + ", " + responseText;
  				if (error)
  					error(path, "Couldn't load text " + path + ": status " + status + ", " + responseText);
  				_this.toLoad--;
  				_this.loaded++;
  			});
  		};
  		AssetManager.prototype.loadTexture = function (path, success, error) {
  			var _this = this;
  			if (success === void 0) { success = null; }
  			if (error === void 0) { error = null; }
  			path = this.pathPrefix + path;
  			var storagePath = path;
  			this.toLoad++;
  			var img = new Image();
  			img.crossOrigin = "anonymous";
  			img.onload = function (ev) {
  				var texture = _this.textureLoader(img);
  				_this.assets[storagePath] = texture;
  				_this.toLoad--;
  				_this.loaded++;
  				if (success)
  					success(path, img);
  			};
  			img.onerror = function (ev) {
  				_this.errors[path] = "Couldn't load image " + path;
  				_this.toLoad--;
  				_this.loaded++;
  				if (error)
  					error(path, "Couldn't load image " + path);
  			};
  			if (this.rawDataUris[path])
  				path = this.rawDataUris[path];
  			img.src = path;
  		};
  		AssetManager.prototype.loadTextureAtlas = function (path, success, error) {
  			var _this = this;
  			if (success === void 0) { success = null; }
  			if (error === void 0) { error = null; }
  			var parent = path.lastIndexOf("/") >= 0 ? path.substring(0, path.lastIndexOf("/")) : "";
  			path = this.pathPrefix + path;
  			this.toLoad++;
  			this.downloadText(path, function (atlasData) {
  				var pagesLoaded = { count: 0 };
  				var atlasPages = new Array();
  				try {
  					var atlas = new spine.TextureAtlas(atlasData, function (path) {
  						atlasPages.push(parent == "" ? path : parent + "/" + path);
  						var image = document.createElement("img");
  						image.width = 16;
  						image.height = 16;
  						return new spine.FakeTexture(image);
  					});
  				}
  				catch (e) {
  					var ex = e;
  					_this.errors[path] = "Couldn't load texture atlas " + path + ": " + ex.message;
  					if (error)
  						error(path, "Couldn't load texture atlas " + path + ": " + ex.message);
  					_this.toLoad--;
  					_this.loaded++;
  					return;
  				}
  				var _loop_1 = function (atlasPage) {
  					var pageLoadError = false;
  					_this.loadTexture(atlasPage, function (imagePath, image) {
  						pagesLoaded.count++;
  						if (pagesLoaded.count == atlasPages.length) {
  							if (!pageLoadError) {
  								try {
  									var atlas = new spine.TextureAtlas(atlasData, function (path) {
  										return _this.get(parent == "" ? path : parent + "/" + path);
  									});
  									_this.assets[path] = atlas;
  									if (success)
  										success(path, atlas);
  									_this.toLoad--;
  									_this.loaded++;
  								}
  								catch (e) {
  									var ex = e;
  									_this.errors[path] = "Couldn't load texture atlas " + path + ": " + ex.message;
  									if (error)
  										error(path, "Couldn't load texture atlas " + path + ": " + ex.message);
  									_this.toLoad--;
  									_this.loaded++;
  								}
  							}
  							else {
  								_this.errors[path] = "Couldn't load texture atlas page " + imagePath + "} of atlas " + path;
  								if (error)
  									error(path, "Couldn't load texture atlas page " + imagePath + " of atlas " + path);
  								_this.toLoad--;
  								_this.loaded++;
  							}
  						}
  					}, function (imagePath, errorMessage) {
  						pageLoadError = true;
  						pagesLoaded.count++;
  						if (pagesLoaded.count == atlasPages.length) {
  							_this.errors[path] = "Couldn't load texture atlas page " + imagePath + "} of atlas " + path;
  							if (error)
  								error(path, "Couldn't load texture atlas page " + imagePath + " of atlas " + path);
  							_this.toLoad--;
  							_this.loaded++;
  						}
  					});
  				};
  				for (var _i = 0, atlasPages_1 = atlasPages; _i < atlasPages_1.length; _i++) {
  					var atlasPage = atlasPages_1[_i];
  					_loop_1(atlasPage);
  				}
  			}, function (state, responseText) {
  				_this.errors[path] = "Couldn't load texture atlas " + path + ": status " + status + ", " + responseText;
  				if (error)
  					error(path, "Couldn't load texture atlas " + path + ": status " + status + ", " + responseText);
  				_this.toLoad--;
  				_this.loaded++;
  			});
  		};
  		AssetManager.prototype.get = function (path) {
  			path = this.pathPrefix + path;
  			return this.assets[path];
  		};
  		AssetManager.prototype.remove = function (path) {
  			path = this.pathPrefix + path;
  			var asset = this.assets[path];
  			if (asset.dispose)
  				asset.dispose();
  			this.assets[path] = null;
  		};
  		AssetManager.prototype.removeAll = function () {
  			for (var key in this.assets) {
  				var asset = this.assets[key];
  				if (asset.dispose)
  					asset.dispose();
  			}
  			this.assets = {};
  		};
  		AssetManager.prototype.isLoadingComplete = function () {
  			return this.toLoad == 0;
  		};
  		AssetManager.prototype.getToLoad = function () {
  			return this.toLoad;
  		};
  		AssetManager.prototype.getLoaded = function () {
  			return this.loaded;
  		};
  		AssetManager.prototype.dispose = function () {
  			this.removeAll();
  		};
  		AssetManager.prototype.hasErrors = function () {
  			return Object.keys(this.errors).length > 0;
  		};
  		AssetManager.prototype.getErrors = function () {
  			return this.errors;
  		};
  		return AssetManager;
  	}());
  	spine.AssetManager = AssetManager;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var AtlasAttachmentLoader = (function () {
  		function AtlasAttachmentLoader(atlas) {
  			this.atlas = atlas;
  		}
  		AtlasAttachmentLoader.prototype.newRegionAttachment = function (skin, name, path) {
  			var region = this.atlas.findRegion(path);
  			if (region == null)
  				throw new Error("Region not found in atlas: " + path + " (region attachment: " + name + ")");
  			region.renderObject = region;
  			var attachment = new spine.RegionAttachment(name);
  			attachment.setRegion(region);
  			return attachment;
  		};
  		AtlasAttachmentLoader.prototype.newMeshAttachment = function (skin, name, path) {
  			var region = this.atlas.findRegion(path);
  			if (region == null)
  				throw new Error("Region not found in atlas: " + path + " (mesh attachment: " + name + ")");
  			region.renderObject = region;
  			var attachment = new spine.MeshAttachment(name);
  			attachment.region = region;
  			return attachment;
  		};
  		AtlasAttachmentLoader.prototype.newBoundingBoxAttachment = function (skin, name) {
  			return new spine.BoundingBoxAttachment(name);
  		};
  		AtlasAttachmentLoader.prototype.newPathAttachment = function (skin, name) {
  			return new spine.PathAttachment(name);
  		};
  		AtlasAttachmentLoader.prototype.newPointAttachment = function (skin, name) {
  			return new spine.PointAttachment(name);
  		};
  		AtlasAttachmentLoader.prototype.newClippingAttachment = function (skin, name) {
  			return new spine.ClippingAttachment(name);
  		};
  		return AtlasAttachmentLoader;
  	}());
  	spine.AtlasAttachmentLoader = AtlasAttachmentLoader;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var BlendMode;
  	(function (BlendMode) {
  		BlendMode[BlendMode["Normal"] = 0] = "Normal";
  		BlendMode[BlendMode["Additive"] = 1] = "Additive";
  		BlendMode[BlendMode["Multiply"] = 2] = "Multiply";
  		BlendMode[BlendMode["Screen"] = 3] = "Screen";
  	})(BlendMode = spine.BlendMode || (spine.BlendMode = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var Bone = (function () {
  		function Bone(data, skeleton, parent) {
  			this.children = new Array();
  			this.x = 0;
  			this.y = 0;
  			this.rotation = 0;
  			this.scaleX = 0;
  			this.scaleY = 0;
  			this.shearX = 0;
  			this.shearY = 0;
  			this.ax = 0;
  			this.ay = 0;
  			this.arotation = 0;
  			this.ascaleX = 0;
  			this.ascaleY = 0;
  			this.ashearX = 0;
  			this.ashearY = 0;
  			this.appliedValid = false;
  			this.a = 0;
  			this.b = 0;
  			this.c = 0;
  			this.d = 0;
  			this.worldY = 0;
  			this.worldX = 0;
  			this.sorted = false;
  			this.active = false;
  			if (data == null)
  				throw new Error("data cannot be null.");
  			if (skeleton == null)
  				throw new Error("skeleton cannot be null.");
  			this.data = data;
  			this.skeleton = skeleton;
  			this.parent = parent;
  			this.setToSetupPose();
  		}
  		Bone.prototype.isActive = function () {
  			return this.active;
  		};
  		Bone.prototype.update = function () {
  			this.updateWorldTransformWith(this.x, this.y, this.rotation, this.scaleX, this.scaleY, this.shearX, this.shearY);
  		};
  		Bone.prototype.updateWorldTransform = function () {
  			this.updateWorldTransformWith(this.x, this.y, this.rotation, this.scaleX, this.scaleY, this.shearX, this.shearY);
  		};
  		Bone.prototype.updateWorldTransformWith = function (x, y, rotation, scaleX, scaleY, shearX, shearY) {
  			this.ax = x;
  			this.ay = y;
  			this.arotation = rotation;
  			this.ascaleX = scaleX;
  			this.ascaleY = scaleY;
  			this.ashearX = shearX;
  			this.ashearY = shearY;
  			this.appliedValid = true;
  			var parent = this.parent;
  			if (parent == null) {
  				var skeleton = this.skeleton;
  				var rotationY = rotation + 90 + shearY;
  				var sx = skeleton.scaleX;
  				var sy = skeleton.scaleY;
  				this.a = spine.MathUtils.cosDeg(rotation + shearX) * scaleX * sx;
  				this.b = spine.MathUtils.cosDeg(rotationY) * scaleY * sx;
  				this.c = spine.MathUtils.sinDeg(rotation + shearX) * scaleX * sy;
  				this.d = spine.MathUtils.sinDeg(rotationY) * scaleY * sy;
  				this.worldX = x * sx + skeleton.x;
  				this.worldY = y * sy + skeleton.y;
  				return;
  			}
  			var pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d;
  			this.worldX = pa * x + pb * y + parent.worldX;
  			this.worldY = pc * x + pd * y + parent.worldY;
  			switch (this.data.transformMode) {
  				case spine.TransformMode.Normal: {
  					var rotationY = rotation + 90 + shearY;
  					var la = spine.MathUtils.cosDeg(rotation + shearX) * scaleX;
  					var lb = spine.MathUtils.cosDeg(rotationY) * scaleY;
  					var lc = spine.MathUtils.sinDeg(rotation + shearX) * scaleX;
  					var ld = spine.MathUtils.sinDeg(rotationY) * scaleY;
  					this.a = pa * la + pb * lc;
  					this.b = pa * lb + pb * ld;
  					this.c = pc * la + pd * lc;
  					this.d = pc * lb + pd * ld;
  					return;
  				}
  				case spine.TransformMode.OnlyTranslation: {
  					var rotationY = rotation + 90 + shearY;
  					this.a = spine.MathUtils.cosDeg(rotation + shearX) * scaleX;
  					this.b = spine.MathUtils.cosDeg(rotationY) * scaleY;
  					this.c = spine.MathUtils.sinDeg(rotation + shearX) * scaleX;
  					this.d = spine.MathUtils.sinDeg(rotationY) * scaleY;
  					break;
  				}
  				case spine.TransformMode.NoRotationOrReflection: {
  					var s = pa * pa + pc * pc;
  					var prx = 0;
  					if (s > 0.0001) {
  						s = Math.abs(pa * pd - pb * pc) / s;
  						pb = pc * s;
  						pd = pa * s;
  						prx = Math.atan2(pc, pa) * spine.MathUtils.radDeg;
  					}
  					else {
  						pa = 0;
  						pc = 0;
  						prx = 90 - Math.atan2(pd, pb) * spine.MathUtils.radDeg;
  					}
  					var rx = rotation + shearX - prx;
  					var ry = rotation + shearY - prx + 90;
  					var la = spine.MathUtils.cosDeg(rx) * scaleX;
  					var lb = spine.MathUtils.cosDeg(ry) * scaleY;
  					var lc = spine.MathUtils.sinDeg(rx) * scaleX;
  					var ld = spine.MathUtils.sinDeg(ry) * scaleY;
  					this.a = pa * la - pb * lc;
  					this.b = pa * lb - pb * ld;
  					this.c = pc * la + pd * lc;
  					this.d = pc * lb + pd * ld;
  					break;
  				}
  				case spine.TransformMode.NoScale:
  				case spine.TransformMode.NoScaleOrReflection: {
  					var cos = spine.MathUtils.cosDeg(rotation);
  					var sin = spine.MathUtils.sinDeg(rotation);
  					var za = (pa * cos + pb * sin) / this.skeleton.scaleX;
  					var zc = (pc * cos + pd * sin) / this.skeleton.scaleY;
  					var s = Math.sqrt(za * za + zc * zc);
  					if (s > 0.00001)
  						s = 1 / s;
  					za *= s;
  					zc *= s;
  					s = Math.sqrt(za * za + zc * zc);
  					if (this.data.transformMode == spine.TransformMode.NoScale
  						&& (pa * pd - pb * pc < 0) != (this.skeleton.scaleX < 0 != this.skeleton.scaleY < 0))
  						s = -s;
  					var r = Math.PI / 2 + Math.atan2(zc, za);
  					var zb = Math.cos(r) * s;
  					var zd = Math.sin(r) * s;
  					var la = spine.MathUtils.cosDeg(shearX) * scaleX;
  					var lb = spine.MathUtils.cosDeg(90 + shearY) * scaleY;
  					var lc = spine.MathUtils.sinDeg(shearX) * scaleX;
  					var ld = spine.MathUtils.sinDeg(90 + shearY) * scaleY;
  					this.a = za * la + zb * lc;
  					this.b = za * lb + zb * ld;
  					this.c = zc * la + zd * lc;
  					this.d = zc * lb + zd * ld;
  					break;
  				}
  			}
  			this.a *= this.skeleton.scaleX;
  			this.b *= this.skeleton.scaleX;
  			this.c *= this.skeleton.scaleY;
  			this.d *= this.skeleton.scaleY;
  		};
  		Bone.prototype.setToSetupPose = function () {
  			var data = this.data;
  			this.x = data.x;
  			this.y = data.y;
  			this.rotation = data.rotation;
  			this.scaleX = data.scaleX;
  			this.scaleY = data.scaleY;
  			this.shearX = data.shearX;
  			this.shearY = data.shearY;
  		};
  		Bone.prototype.getWorldRotationX = function () {
  			return Math.atan2(this.c, this.a) * spine.MathUtils.radDeg;
  		};
  		Bone.prototype.getWorldRotationY = function () {
  			return Math.atan2(this.d, this.b) * spine.MathUtils.radDeg;
  		};
  		Bone.prototype.getWorldScaleX = function () {
  			return Math.sqrt(this.a * this.a + this.c * this.c);
  		};
  		Bone.prototype.getWorldScaleY = function () {
  			return Math.sqrt(this.b * this.b + this.d * this.d);
  		};
  		Bone.prototype.updateAppliedTransform = function () {
  			this.appliedValid = true;
  			var parent = this.parent;
  			if (parent == null) {
  				this.ax = this.worldX;
  				this.ay = this.worldY;
  				this.arotation = Math.atan2(this.c, this.a) * spine.MathUtils.radDeg;
  				this.ascaleX = Math.sqrt(this.a * this.a + this.c * this.c);
  				this.ascaleY = Math.sqrt(this.b * this.b + this.d * this.d);
  				this.ashearX = 0;
  				this.ashearY = Math.atan2(this.a * this.b + this.c * this.d, this.a * this.d - this.b * this.c) * spine.MathUtils.radDeg;
  				return;
  			}
  			var pa = parent.a, pb = parent.b, pc = parent.c, pd = parent.d;
  			var pid = 1 / (pa * pd - pb * pc);
  			var dx = this.worldX - parent.worldX, dy = this.worldY - parent.worldY;
  			this.ax = (dx * pd * pid - dy * pb * pid);
  			this.ay = (dy * pa * pid - dx * pc * pid);
  			var ia = pid * pd;
  			var id = pid * pa;
  			var ib = pid * pb;
  			var ic = pid * pc;
  			var ra = ia * this.a - ib * this.c;
  			var rb = ia * this.b - ib * this.d;
  			var rc = id * this.c - ic * this.a;
  			var rd = id * this.d - ic * this.b;
  			this.ashearX = 0;
  			this.ascaleX = Math.sqrt(ra * ra + rc * rc);
  			if (this.ascaleX > 0.0001) {
  				var det = ra * rd - rb * rc;
  				this.ascaleY = det / this.ascaleX;
  				this.ashearY = Math.atan2(ra * rb + rc * rd, det) * spine.MathUtils.radDeg;
  				this.arotation = Math.atan2(rc, ra) * spine.MathUtils.radDeg;
  			}
  			else {
  				this.ascaleX = 0;
  				this.ascaleY = Math.sqrt(rb * rb + rd * rd);
  				this.ashearY = 0;
  				this.arotation = 90 - Math.atan2(rd, rb) * spine.MathUtils.radDeg;
  			}
  		};
  		Bone.prototype.worldToLocal = function (world) {
  			var a = this.a, b = this.b, c = this.c, d = this.d;
  			var invDet = 1 / (a * d - b * c);
  			var x = world.x - this.worldX, y = world.y - this.worldY;
  			world.x = (x * d * invDet - y * b * invDet);
  			world.y = (y * a * invDet - x * c * invDet);
  			return world;
  		};
  		Bone.prototype.localToWorld = function (local) {
  			var x = local.x, y = local.y;
  			local.x = x * this.a + y * this.b + this.worldX;
  			local.y = x * this.c + y * this.d + this.worldY;
  			return local;
  		};
  		Bone.prototype.worldToLocalRotation = function (worldRotation) {
  			var sin = spine.MathUtils.sinDeg(worldRotation), cos = spine.MathUtils.cosDeg(worldRotation);
  			return Math.atan2(this.a * sin - this.c * cos, this.d * cos - this.b * sin) * spine.MathUtils.radDeg + this.rotation - this.shearX;
  		};
  		Bone.prototype.localToWorldRotation = function (localRotation) {
  			localRotation -= this.rotation - this.shearX;
  			var sin = spine.MathUtils.sinDeg(localRotation), cos = spine.MathUtils.cosDeg(localRotation);
  			return Math.atan2(cos * this.c + sin * this.d, cos * this.a + sin * this.b) * spine.MathUtils.radDeg;
  		};
  		Bone.prototype.rotateWorld = function (degrees) {
  			var a = this.a, b = this.b, c = this.c, d = this.d;
  			var cos = spine.MathUtils.cosDeg(degrees), sin = spine.MathUtils.sinDeg(degrees);
  			this.a = cos * a - sin * c;
  			this.b = cos * b - sin * d;
  			this.c = sin * a + cos * c;
  			this.d = sin * b + cos * d;
  			this.appliedValid = false;
  		};
  		return Bone;
  	}());
  	spine.Bone = Bone;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var BoneData = (function () {
  		function BoneData(index, name, parent) {
  			this.x = 0;
  			this.y = 0;
  			this.rotation = 0;
  			this.scaleX = 1;
  			this.scaleY = 1;
  			this.shearX = 0;
  			this.shearY = 0;
  			this.transformMode = TransformMode.Normal;
  			this.skinRequired = false;
  			this.color = new spine.Color();
  			if (index < 0)
  				throw new Error("index must be >= 0.");
  			if (name == null)
  				throw new Error("name cannot be null.");
  			this.index = index;
  			this.name = name;
  			this.parent = parent;
  		}
  		return BoneData;
  	}());
  	spine.BoneData = BoneData;
  	var TransformMode;
  	(function (TransformMode) {
  		TransformMode[TransformMode["Normal"] = 0] = "Normal";
  		TransformMode[TransformMode["OnlyTranslation"] = 1] = "OnlyTranslation";
  		TransformMode[TransformMode["NoRotationOrReflection"] = 2] = "NoRotationOrReflection";
  		TransformMode[TransformMode["NoScale"] = 3] = "NoScale";
  		TransformMode[TransformMode["NoScaleOrReflection"] = 4] = "NoScaleOrReflection";
  	})(TransformMode = spine.TransformMode || (spine.TransformMode = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var ConstraintData = (function () {
  		function ConstraintData(name, order, skinRequired) {
  			this.name = name;
  			this.order = order;
  			this.skinRequired = skinRequired;
  		}
  		return ConstraintData;
  	}());
  	spine.ConstraintData = ConstraintData;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var Event = (function () {
  		function Event(time, data) {
  			if (data == null)
  				throw new Error("data cannot be null.");
  			this.time = time;
  			this.data = data;
  		}
  		return Event;
  	}());
  	spine.Event = Event;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var EventData = (function () {
  		function EventData(name) {
  			this.name = name;
  		}
  		return EventData;
  	}());
  	spine.EventData = EventData;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var IkConstraint = (function () {
  		function IkConstraint(data, skeleton) {
  			this.bendDirection = 0;
  			this.compress = false;
  			this.stretch = false;
  			this.mix = 1;
  			this.softness = 0;
  			this.active = false;
  			if (data == null)
  				throw new Error("data cannot be null.");
  			if (skeleton == null)
  				throw new Error("skeleton cannot be null.");
  			this.data = data;
  			this.mix = data.mix;
  			this.softness = data.softness;
  			this.bendDirection = data.bendDirection;
  			this.compress = data.compress;
  			this.stretch = data.stretch;
  			this.bones = new Array();
  			for (var i = 0; i < data.bones.length; i++)
  				this.bones.push(skeleton.findBone(data.bones[i].name));
  			this.target = skeleton.findBone(data.target.name);
  		}
  		IkConstraint.prototype.isActive = function () {
  			return this.active;
  		};
  		IkConstraint.prototype.apply = function () {
  			this.update();
  		};
  		IkConstraint.prototype.update = function () {
  			var target = this.target;
  			var bones = this.bones;
  			switch (bones.length) {
  				case 1:
  					this.apply1(bones[0], target.worldX, target.worldY, this.compress, this.stretch, this.data.uniform, this.mix);
  					break;
  				case 2:
  					this.apply2(bones[0], bones[1], target.worldX, target.worldY, this.bendDirection, this.stretch, this.softness, this.mix);
  					break;
  			}
  		};
  		IkConstraint.prototype.apply1 = function (bone, targetX, targetY, compress, stretch, uniform, alpha) {
  			if (!bone.appliedValid)
  				bone.updateAppliedTransform();
  			var p = bone.parent;
  			var pa = p.a, pb = p.b, pc = p.c, pd = p.d;
  			var rotationIK = -bone.ashearX - bone.arotation, tx = 0, ty = 0;
  			switch (bone.data.transformMode) {
  				case spine.TransformMode.OnlyTranslation:
  					tx = targetX - bone.worldX;
  					ty = targetY - bone.worldY;
  					break;
  				case spine.TransformMode.NoRotationOrReflection:
  					rotationIK += Math.atan2(pc, pa) * spine.MathUtils.radDeg;
  					var ps = Math.abs(pa * pd - pb * pc) / (pa * pa + pc * pc);
  					pb = -pc * ps;
  					pd = pa * ps;
  				default:
  					var x = targetX - p.worldX, y = targetY - p.worldY;
  					var d = pa * pd - pb * pc;
  					tx = (x * pd - y * pb) / d - bone.ax;
  					ty = (y * pa - x * pc) / d - bone.ay;
  			}
  			rotationIK += Math.atan2(ty, tx) * spine.MathUtils.radDeg;
  			if (bone.ascaleX < 0)
  				rotationIK += 180;
  			if (rotationIK > 180)
  				rotationIK -= 360;
  			else if (rotationIK < -180)
  				rotationIK += 360;
  			var sx = bone.ascaleX, sy = bone.ascaleY;
  			if (compress || stretch) {
  				switch (bone.data.transformMode) {
  					case spine.TransformMode.NoScale:
  					case spine.TransformMode.NoScaleOrReflection:
  						tx = targetX - bone.worldX;
  						ty = targetY - bone.worldY;
  				}
  				var b = bone.data.length * sx, dd = Math.sqrt(tx * tx + ty * ty);
  				if ((compress && dd < b) || (stretch && dd > b) && b > 0.0001) {
  					var s = (dd / b - 1) * alpha + 1;
  					sx *= s;
  					if (uniform)
  						sy *= s;
  				}
  			}
  			bone.updateWorldTransformWith(bone.ax, bone.ay, bone.arotation + rotationIK * alpha, sx, sy, bone.ashearX, bone.ashearY);
  		};
  		IkConstraint.prototype.apply2 = function (parent, child, targetX, targetY, bendDir, stretch, softness, alpha) {
  			if (alpha == 0) {
  				child.updateWorldTransform();
  				return;
  			}
  			if (!parent.appliedValid)
  				parent.updateAppliedTransform();
  			if (!child.appliedValid)
  				child.updateAppliedTransform();
  			var px = parent.ax, py = parent.ay, psx = parent.ascaleX, sx = psx, psy = parent.ascaleY, csx = child.ascaleX;
  			var os1 = 0, os2 = 0, s2 = 0;
  			if (psx < 0) {
  				psx = -psx;
  				os1 = 180;
  				s2 = -1;
  			}
  			else {
  				os1 = 0;
  				s2 = 1;
  			}
  			if (psy < 0) {
  				psy = -psy;
  				s2 = -s2;
  			}
  			if (csx < 0) {
  				csx = -csx;
  				os2 = 180;
  			}
  			else
  				os2 = 0;
  			var cx = child.ax, cy = 0, cwx = 0, cwy = 0, a = parent.a, b = parent.b, c = parent.c, d = parent.d;
  			var u = Math.abs(psx - psy) <= 0.0001;
  			if (!u) {
  				cy = 0;
  				cwx = a * cx + parent.worldX;
  				cwy = c * cx + parent.worldY;
  			}
  			else {
  				cy = child.ay;
  				cwx = a * cx + b * cy + parent.worldX;
  				cwy = c * cx + d * cy + parent.worldY;
  			}
  			var pp = parent.parent;
  			a = pp.a;
  			b = pp.b;
  			c = pp.c;
  			d = pp.d;
  			var id = 1 / (a * d - b * c), x = cwx - pp.worldX, y = cwy - pp.worldY;
  			var dx = (x * d - y * b) * id - px, dy = (y * a - x * c) * id - py;
  			var l1 = Math.sqrt(dx * dx + dy * dy), l2 = child.data.length * csx, a1, a2;
  			if (l1 < 0.0001) {
  				this.apply1(parent, targetX, targetY, false, stretch, false, alpha);
  				child.updateWorldTransformWith(cx, cy, 0, child.ascaleX, child.ascaleY, child.ashearX, child.ashearY);
  				return;
  			}
  			x = targetX - pp.worldX;
  			y = targetY - pp.worldY;
  			var tx = (x * d - y * b) * id - px, ty = (y * a - x * c) * id - py;
  			var dd = tx * tx + ty * ty;
  			if (softness != 0) {
  				softness *= psx * (csx + 1) / 2;
  				var td = Math.sqrt(dd), sd = td - l1 - l2 * psx + softness;
  				if (sd > 0) {
  					var p = Math.min(1, sd / (softness * 2)) - 1;
  					p = (sd - softness * (1 - p * p)) / td;
  					tx -= p * tx;
  					ty -= p * ty;
  					dd = tx * tx + ty * ty;
  				}
  			}
  			outer: if (u) {
  				l2 *= psx;
  				var cos = (dd - l1 * l1 - l2 * l2) / (2 * l1 * l2);
  				if (cos < -1)
  					cos = -1;
  				else if (cos > 1) {
  					cos = 1;
  					if (stretch)
  						sx *= (Math.sqrt(dd) / (l1 + l2) - 1) * alpha + 1;
  				}
  				a2 = Math.acos(cos) * bendDir;
  				a = l1 + l2 * cos;
  				b = l2 * Math.sin(a2);
  				a1 = Math.atan2(ty * a - tx * b, tx * a + ty * b);
  			}
  			else {
  				a = psx * l2;
  				b = psy * l2;
  				var aa = a * a, bb = b * b, ta = Math.atan2(ty, tx);
  				c = bb * l1 * l1 + aa * dd - aa * bb;
  				var c1 = -2 * bb * l1, c2 = bb - aa;
  				d = c1 * c1 - 4 * c2 * c;
  				if (d >= 0) {
  					var q = Math.sqrt(d);
  					if (c1 < 0)
  						q = -q;
  					q = -(c1 + q) / 2;
  					var r0 = q / c2, r1 = c / q;
  					var r = Math.abs(r0) < Math.abs(r1) ? r0 : r1;
  					if (r * r <= dd) {
  						y = Math.sqrt(dd - r * r) * bendDir;
  						a1 = ta - Math.atan2(y, r);
  						a2 = Math.atan2(y / psy, (r - l1) / psx);
  						break outer;
  					}
  				}
  				var minAngle = spine.MathUtils.PI, minX = l1 - a, minDist = minX * minX, minY = 0;
  				var maxAngle = 0, maxX = l1 + a, maxDist = maxX * maxX, maxY = 0;
  				c = -a * l1 / (aa - bb);
  				if (c >= -1 && c <= 1) {
  					c = Math.acos(c);
  					x = a * Math.cos(c) + l1;
  					y = b * Math.sin(c);
  					d = x * x + y * y;
  					if (d < minDist) {
  						minAngle = c;
  						minDist = d;
  						minX = x;
  						minY = y;
  					}
  					if (d > maxDist) {
  						maxAngle = c;
  						maxDist = d;
  						maxX = x;
  						maxY = y;
  					}
  				}
  				if (dd <= (minDist + maxDist) / 2) {
  					a1 = ta - Math.atan2(minY * bendDir, minX);
  					a2 = minAngle * bendDir;
  				}
  				else {
  					a1 = ta - Math.atan2(maxY * bendDir, maxX);
  					a2 = maxAngle * bendDir;
  				}
  			}
  			var os = Math.atan2(cy, cx) * s2;
  			var rotation = parent.arotation;
  			a1 = (a1 - os) * spine.MathUtils.radDeg + os1 - rotation;
  			if (a1 > 180)
  				a1 -= 360;
  			else if (a1 < -180)
  				a1 += 360;
  			parent.updateWorldTransformWith(px, py, rotation + a1 * alpha, sx, parent.ascaleY, 0, 0);
  			rotation = child.arotation;
  			a2 = ((a2 + os) * spine.MathUtils.radDeg - child.ashearX) * s2 + os2 - rotation;
  			if (a2 > 180)
  				a2 -= 360;
  			else if (a2 < -180)
  				a2 += 360;
  			child.updateWorldTransformWith(cx, cy, rotation + a2 * alpha, child.ascaleX, child.ascaleY, child.ashearX, child.ashearY);
  		};
  		return IkConstraint;
  	}());
  	spine.IkConstraint = IkConstraint;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var IkConstraintData = (function (_super) {
  		__extends(IkConstraintData, _super);
  		function IkConstraintData(name) {
  			var _this = _super.call(this, name, 0, false) || this;
  			_this.bones = new Array();
  			_this.bendDirection = 1;
  			_this.compress = false;
  			_this.stretch = false;
  			_this.uniform = false;
  			_this.mix = 1;
  			_this.softness = 0;
  			return _this;
  		}
  		return IkConstraintData;
  	}(spine.ConstraintData));
  	spine.IkConstraintData = IkConstraintData;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var PathConstraint = (function () {
  		function PathConstraint(data, skeleton) {
  			this.position = 0;
  			this.spacing = 0;
  			this.rotateMix = 0;
  			this.translateMix = 0;
  			this.spaces = new Array();
  			this.positions = new Array();
  			this.world = new Array();
  			this.curves = new Array();
  			this.lengths = new Array();
  			this.segments = new Array();
  			this.active = false;
  			if (data == null)
  				throw new Error("data cannot be null.");
  			if (skeleton == null)
  				throw new Error("skeleton cannot be null.");
  			this.data = data;
  			this.bones = new Array();
  			for (var i = 0, n = data.bones.length; i < n; i++)
  				this.bones.push(skeleton.findBone(data.bones[i].name));
  			this.target = skeleton.findSlot(data.target.name);
  			this.position = data.position;
  			this.spacing = data.spacing;
  			this.rotateMix = data.rotateMix;
  			this.translateMix = data.translateMix;
  		}
  		PathConstraint.prototype.isActive = function () {
  			return this.active;
  		};
  		PathConstraint.prototype.apply = function () {
  			this.update();
  		};
  		PathConstraint.prototype.update = function () {
  			var attachment = this.target.getAttachment();
  			if (!(attachment instanceof spine.PathAttachment))
  				return;
  			var rotateMix = this.rotateMix, translateMix = this.translateMix;
  			var translate = translateMix > 0, rotate = rotateMix > 0;
  			if (!translate && !rotate)
  				return;
  			var data = this.data;
  			var percentSpacing = data.spacingMode == spine.SpacingMode.Percent;
  			var rotateMode = data.rotateMode;
  			var tangents = rotateMode == spine.RotateMode.Tangent, scale = rotateMode == spine.RotateMode.ChainScale;
  			var boneCount = this.bones.length, spacesCount = tangents ? boneCount : boneCount + 1;
  			var bones = this.bones;
  			var spaces = spine.Utils.setArraySize(this.spaces, spacesCount), lengths = null;
  			var spacing = this.spacing;
  			if (scale || !percentSpacing) {
  				if (scale)
  					lengths = spine.Utils.setArraySize(this.lengths, boneCount);
  				var lengthSpacing = data.spacingMode == spine.SpacingMode.Length;
  				for (var i = 0, n = spacesCount - 1; i < n;) {
  					var bone = bones[i];
  					var setupLength = bone.data.length;
  					if (setupLength < PathConstraint.epsilon) {
  						if (scale)
  							lengths[i] = 0;
  						spaces[++i] = 0;
  					}
  					else if (percentSpacing) {
  						if (scale) {
  							var x = setupLength * bone.a, y = setupLength * bone.c;
  							var length_1 = Math.sqrt(x * x + y * y);
  							lengths[i] = length_1;
  						}
  						spaces[++i] = spacing;
  					}
  					else {
  						var x = setupLength * bone.a, y = setupLength * bone.c;
  						var length_2 = Math.sqrt(x * x + y * y);
  						if (scale)
  							lengths[i] = length_2;
  						spaces[++i] = (lengthSpacing ? setupLength + spacing : spacing) * length_2 / setupLength;
  					}
  				}
  			}
  			else {
  				for (var i = 1; i < spacesCount; i++)
  					spaces[i] = spacing;
  			}
  			var positions = this.computeWorldPositions(attachment, spacesCount, tangents, data.positionMode == spine.PositionMode.Percent, percentSpacing);
  			var boneX = positions[0], boneY = positions[1], offsetRotation = data.offsetRotation;
  			var tip = false;
  			if (offsetRotation == 0)
  				tip = rotateMode == spine.RotateMode.Chain;
  			else {
  				tip = false;
  				var p = this.target.bone;
  				offsetRotation *= p.a * p.d - p.b * p.c > 0 ? spine.MathUtils.degRad : -spine.MathUtils.degRad;
  			}
  			for (var i = 0, p = 3; i < boneCount; i++, p += 3) {
  				var bone = bones[i];
  				bone.worldX += (boneX - bone.worldX) * translateMix;
  				bone.worldY += (boneY - bone.worldY) * translateMix;
  				var x = positions[p], y = positions[p + 1], dx = x - boneX, dy = y - boneY;
  				if (scale) {
  					var length_3 = lengths[i];
  					if (length_3 != 0) {
  						var s = (Math.sqrt(dx * dx + dy * dy) / length_3 - 1) * rotateMix + 1;
  						bone.a *= s;
  						bone.c *= s;
  					}
  				}
  				boneX = x;
  				boneY = y;
  				if (rotate) {
  					var a = bone.a, b = bone.b, c = bone.c, d = bone.d, r = 0, cos = 0, sin = 0;
  					if (tangents)
  						r = positions[p - 1];
  					else if (spaces[i + 1] == 0)
  						r = positions[p + 2];
  					else
  						r = Math.atan2(dy, dx);
  					r -= Math.atan2(c, a);
  					if (tip) {
  						cos = Math.cos(r);
  						sin = Math.sin(r);
  						var length_4 = bone.data.length;
  						boneX += (length_4 * (cos * a - sin * c) - dx) * rotateMix;
  						boneY += (length_4 * (sin * a + cos * c) - dy) * rotateMix;
  					}
  					else {
  						r += offsetRotation;
  					}
  					if (r > spine.MathUtils.PI)
  						r -= spine.MathUtils.PI2;
  					else if (r < -spine.MathUtils.PI)
  						r += spine.MathUtils.PI2;
  					r *= rotateMix;
  					cos = Math.cos(r);
  					sin = Math.sin(r);
  					bone.a = cos * a - sin * c;
  					bone.b = cos * b - sin * d;
  					bone.c = sin * a + cos * c;
  					bone.d = sin * b + cos * d;
  				}
  				bone.appliedValid = false;
  			}
  		};
  		PathConstraint.prototype.computeWorldPositions = function (path, spacesCount, tangents, percentPosition, percentSpacing) {
  			var target = this.target;
  			var position = this.position;
  			var spaces = this.spaces, out = spine.Utils.setArraySize(this.positions, spacesCount * 3 + 2), world = null;
  			var closed = path.closed;
  			var verticesLength = path.worldVerticesLength, curveCount = verticesLength / 6, prevCurve = PathConstraint.NONE;
  			if (!path.constantSpeed) {
  				var lengths = path.lengths;
  				curveCount -= closed ? 1 : 2;
  				var pathLength_1 = lengths[curveCount];
  				if (percentPosition)
  					position *= pathLength_1;
  				if (percentSpacing) {
  					for (var i = 1; i < spacesCount; i++)
  						spaces[i] *= pathLength_1;
  				}
  				world = spine.Utils.setArraySize(this.world, 8);
  				for (var i = 0, o = 0, curve = 0; i < spacesCount; i++, o += 3) {
  					var space = spaces[i];
  					position += space;
  					var p = position;
  					if (closed) {
  						p %= pathLength_1;
  						if (p < 0)
  							p += pathLength_1;
  						curve = 0;
  					}
  					else if (p < 0) {
  						if (prevCurve != PathConstraint.BEFORE) {
  							prevCurve = PathConstraint.BEFORE;
  							path.computeWorldVertices(target, 2, 4, world, 0, 2);
  						}
  						this.addBeforePosition(p, world, 0, out, o);
  						continue;
  					}
  					else if (p > pathLength_1) {
  						if (prevCurve != PathConstraint.AFTER) {
  							prevCurve = PathConstraint.AFTER;
  							path.computeWorldVertices(target, verticesLength - 6, 4, world, 0, 2);
  						}
  						this.addAfterPosition(p - pathLength_1, world, 0, out, o);
  						continue;
  					}
  					for (;; curve++) {
  						var length_5 = lengths[curve];
  						if (p > length_5)
  							continue;
  						if (curve == 0)
  							p /= length_5;
  						else {
  							var prev = lengths[curve - 1];
  							p = (p - prev) / (length_5 - prev);
  						}
  						break;
  					}
  					if (curve != prevCurve) {
  						prevCurve = curve;
  						if (closed && curve == curveCount) {
  							path.computeWorldVertices(target, verticesLength - 4, 4, world, 0, 2);
  							path.computeWorldVertices(target, 0, 4, world, 4, 2);
  						}
  						else
  							path.computeWorldVertices(target, curve * 6 + 2, 8, world, 0, 2);
  					}
  					this.addCurvePosition(p, world[0], world[1], world[2], world[3], world[4], world[5], world[6], world[7], out, o, tangents || (i > 0 && space == 0));
  				}
  				return out;
  			}
  			if (closed) {
  				verticesLength += 2;
  				world = spine.Utils.setArraySize(this.world, verticesLength);
  				path.computeWorldVertices(target, 2, verticesLength - 4, world, 0, 2);
  				path.computeWorldVertices(target, 0, 2, world, verticesLength - 4, 2);
  				world[verticesLength - 2] = world[0];
  				world[verticesLength - 1] = world[1];
  			}
  			else {
  				curveCount--;
  				verticesLength -= 4;
  				world = spine.Utils.setArraySize(this.world, verticesLength);
  				path.computeWorldVertices(target, 2, verticesLength, world, 0, 2);
  			}
  			var curves = spine.Utils.setArraySize(this.curves, curveCount);
  			var pathLength = 0;
  			var x1 = world[0], y1 = world[1], cx1 = 0, cy1 = 0, cx2 = 0, cy2 = 0, x2 = 0, y2 = 0;
  			var tmpx = 0, tmpy = 0, dddfx = 0, dddfy = 0, ddfx = 0, ddfy = 0, dfx = 0, dfy = 0;
  			for (var i = 0, w = 2; i < curveCount; i++, w += 6) {
  				cx1 = world[w];
  				cy1 = world[w + 1];
  				cx2 = world[w + 2];
  				cy2 = world[w + 3];
  				x2 = world[w + 4];
  				y2 = world[w + 5];
  				tmpx = (x1 - cx1 * 2 + cx2) * 0.1875;
  				tmpy = (y1 - cy1 * 2 + cy2) * 0.1875;
  				dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375;
  				dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375;
  				ddfx = tmpx * 2 + dddfx;
  				ddfy = tmpy * 2 + dddfy;
  				dfx = (cx1 - x1) * 0.75 + tmpx + dddfx * 0.16666667;
  				dfy = (cy1 - y1) * 0.75 + tmpy + dddfy * 0.16666667;
  				pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
  				dfx += ddfx;
  				dfy += ddfy;
  				ddfx += dddfx;
  				ddfy += dddfy;
  				pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
  				dfx += ddfx;
  				dfy += ddfy;
  				pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
  				dfx += ddfx + dddfx;
  				dfy += ddfy + dddfy;
  				pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
  				curves[i] = pathLength;
  				x1 = x2;
  				y1 = y2;
  			}
  			if (percentPosition)
  				position *= pathLength;
  			else
  				position *= pathLength / path.lengths[curveCount - 1];
  			if (percentSpacing) {
  				for (var i = 1; i < spacesCount; i++)
  					spaces[i] *= pathLength;
  			}
  			var segments = this.segments;
  			var curveLength = 0;
  			for (var i = 0, o = 0, curve = 0, segment = 0; i < spacesCount; i++, o += 3) {
  				var space = spaces[i];
  				position += space;
  				var p = position;
  				if (closed) {
  					p %= pathLength;
  					if (p < 0)
  						p += pathLength;
  					curve = 0;
  				}
  				else if (p < 0) {
  					this.addBeforePosition(p, world, 0, out, o);
  					continue;
  				}
  				else if (p > pathLength) {
  					this.addAfterPosition(p - pathLength, world, verticesLength - 4, out, o);
  					continue;
  				}
  				for (;; curve++) {
  					var length_6 = curves[curve];
  					if (p > length_6)
  						continue;
  					if (curve == 0)
  						p /= length_6;
  					else {
  						var prev = curves[curve - 1];
  						p = (p - prev) / (length_6 - prev);
  					}
  					break;
  				}
  				if (curve != prevCurve) {
  					prevCurve = curve;
  					var ii = curve * 6;
  					x1 = world[ii];
  					y1 = world[ii + 1];
  					cx1 = world[ii + 2];
  					cy1 = world[ii + 3];
  					cx2 = world[ii + 4];
  					cy2 = world[ii + 5];
  					x2 = world[ii + 6];
  					y2 = world[ii + 7];
  					tmpx = (x1 - cx1 * 2 + cx2) * 0.03;
  					tmpy = (y1 - cy1 * 2 + cy2) * 0.03;
  					dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.006;
  					dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.006;
  					ddfx = tmpx * 2 + dddfx;
  					ddfy = tmpy * 2 + dddfy;
  					dfx = (cx1 - x1) * 0.3 + tmpx + dddfx * 0.16666667;
  					dfy = (cy1 - y1) * 0.3 + tmpy + dddfy * 0.16666667;
  					curveLength = Math.sqrt(dfx * dfx + dfy * dfy);
  					segments[0] = curveLength;
  					for (ii = 1; ii < 8; ii++) {
  						dfx += ddfx;
  						dfy += ddfy;
  						ddfx += dddfx;
  						ddfy += dddfy;
  						curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
  						segments[ii] = curveLength;
  					}
  					dfx += ddfx;
  					dfy += ddfy;
  					curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
  					segments[8] = curveLength;
  					dfx += ddfx + dddfx;
  					dfy += ddfy + dddfy;
  					curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
  					segments[9] = curveLength;
  					segment = 0;
  				}
  				p *= curveLength;
  				for (;; segment++) {
  					var length_7 = segments[segment];
  					if (p > length_7)
  						continue;
  					if (segment == 0)
  						p /= length_7;
  					else {
  						var prev = segments[segment - 1];
  						p = segment + (p - prev) / (length_7 - prev);
  					}
  					break;
  				}
  				this.addCurvePosition(p * 0.1, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, tangents || (i > 0 && space == 0));
  			}
  			return out;
  		};
  		PathConstraint.prototype.addBeforePosition = function (p, temp, i, out, o) {
  			var x1 = temp[i], y1 = temp[i + 1], dx = temp[i + 2] - x1, dy = temp[i + 3] - y1, r = Math.atan2(dy, dx);
  			out[o] = x1 + p * Math.cos(r);
  			out[o + 1] = y1 + p * Math.sin(r);
  			out[o + 2] = r;
  		};
  		PathConstraint.prototype.addAfterPosition = function (p, temp, i, out, o) {
  			var x1 = temp[i + 2], y1 = temp[i + 3], dx = x1 - temp[i], dy = y1 - temp[i + 1], r = Math.atan2(dy, dx);
  			out[o] = x1 + p * Math.cos(r);
  			out[o + 1] = y1 + p * Math.sin(r);
  			out[o + 2] = r;
  		};
  		PathConstraint.prototype.addCurvePosition = function (p, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, tangents) {
  			if (p == 0 || isNaN(p)) {
  				out[o] = x1;
  				out[o + 1] = y1;
  				out[o + 2] = Math.atan2(cy1 - y1, cx1 - x1);
  				return;
  			}
  			var tt = p * p, ttt = tt * p, u = 1 - p, uu = u * u, uuu = uu * u;
  			var ut = u * p, ut3 = ut * 3, uut3 = u * ut3, utt3 = ut3 * p;
  			var x = x1 * uuu + cx1 * uut3 + cx2 * utt3 + x2 * ttt, y = y1 * uuu + cy1 * uut3 + cy2 * utt3 + y2 * ttt;
  			out[o] = x;
  			out[o + 1] = y;
  			if (tangents) {
  				if (p < 0.001)
  					out[o + 2] = Math.atan2(cy1 - y1, cx1 - x1);
  				else
  					out[o + 2] = Math.atan2(y - (y1 * uu + cy1 * ut * 2 + cy2 * tt), x - (x1 * uu + cx1 * ut * 2 + cx2 * tt));
  			}
  		};
  		PathConstraint.NONE = -1;
  		PathConstraint.BEFORE = -2;
  		PathConstraint.AFTER = -3;
  		PathConstraint.epsilon = 0.00001;
  		return PathConstraint;
  	}());
  	spine.PathConstraint = PathConstraint;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var PathConstraintData = (function (_super) {
  		__extends(PathConstraintData, _super);
  		function PathConstraintData(name) {
  			var _this = _super.call(this, name, 0, false) || this;
  			_this.bones = new Array();
  			return _this;
  		}
  		return PathConstraintData;
  	}(spine.ConstraintData));
  	spine.PathConstraintData = PathConstraintData;
  	var PositionMode;
  	(function (PositionMode) {
  		PositionMode[PositionMode["Fixed"] = 0] = "Fixed";
  		PositionMode[PositionMode["Percent"] = 1] = "Percent";
  	})(PositionMode = spine.PositionMode || (spine.PositionMode = {}));
  	var SpacingMode;
  	(function (SpacingMode) {
  		SpacingMode[SpacingMode["Length"] = 0] = "Length";
  		SpacingMode[SpacingMode["Fixed"] = 1] = "Fixed";
  		SpacingMode[SpacingMode["Percent"] = 2] = "Percent";
  	})(SpacingMode = spine.SpacingMode || (spine.SpacingMode = {}));
  	var RotateMode;
  	(function (RotateMode) {
  		RotateMode[RotateMode["Tangent"] = 0] = "Tangent";
  		RotateMode[RotateMode["Chain"] = 1] = "Chain";
  		RotateMode[RotateMode["ChainScale"] = 2] = "ChainScale";
  	})(RotateMode = spine.RotateMode || (spine.RotateMode = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var Assets = (function () {
  		function Assets(clientId) {
  			this.toLoad = new Array();
  			this.assets = {};
  			this.clientId = clientId;
  		}
  		Assets.prototype.loaded = function () {
  			var i = 0;
  			for (var v in this.assets)
  				i++;
  			return i;
  		};
  		return Assets;
  	}());
  	var SharedAssetManager = (function () {
  		function SharedAssetManager(pathPrefix) {
  			if (pathPrefix === void 0) { pathPrefix = ""; }
  			this.clientAssets = {};
  			this.queuedAssets = {};
  			this.rawAssets = {};
  			this.errors = {};
  			this.pathPrefix = pathPrefix;
  		}
  		SharedAssetManager.prototype.queueAsset = function (clientId, textureLoader, path) {
  			var clientAssets = this.clientAssets[clientId];
  			if (clientAssets === null || clientAssets === undefined) {
  				clientAssets = new Assets(clientId);
  				this.clientAssets[clientId] = clientAssets;
  			}
  			if (textureLoader !== null)
  				clientAssets.textureLoader = textureLoader;
  			clientAssets.toLoad.push(path);
  			if (this.queuedAssets[path] === path) {
  				return false;
  			}
  			else {
  				this.queuedAssets[path] = path;
  				return true;
  			}
  		};
  		SharedAssetManager.prototype.loadText = function (clientId, path) {
  			var _this = this;
  			path = this.pathPrefix + path;
  			if (!this.queueAsset(clientId, null, path))
  				return;
  			var request = new XMLHttpRequest();
  			request.overrideMimeType("text/html");
  			request.onreadystatechange = function () {
  				if (request.readyState == XMLHttpRequest.DONE) {
  					if (request.status >= 200 && request.status < 300) {
  						_this.rawAssets[path] = request.responseText;
  					}
  					else {
  						_this.errors[path] = "Couldn't load text " + path + ": status " + request.status + ", " + request.responseText;
  					}
  				}
  			};
  			request.open("GET", path, true);
  			request.send();
  		};
  		SharedAssetManager.prototype.loadJson = function (clientId, path) {
  			var _this = this;
  			path = this.pathPrefix + path;
  			if (!this.queueAsset(clientId, null, path))
  				return;
  			var request = new XMLHttpRequest();
  			request.overrideMimeType("text/html");
  			request.onreadystatechange = function () {
  				if (request.readyState == XMLHttpRequest.DONE) {
  					if (request.status >= 200 && request.status < 300) {
  						_this.rawAssets[path] = JSON.parse(request.responseText);
  					}
  					else {
  						_this.errors[path] = "Couldn't load text " + path + ": status " + request.status + ", " + request.responseText;
  					}
  				}
  			};
  			request.open("GET", path, true);
  			request.send();
  		};
  		SharedAssetManager.prototype.loadTexture = function (clientId, textureLoader, path) {
  			var _this = this;
  			path = this.pathPrefix + path;
  			if (!this.queueAsset(clientId, textureLoader, path))
  				return;
  			var img = new Image();
  			img.crossOrigin = "anonymous";
  			img.onload = function (ev) {
  				_this.rawAssets[path] = img;
  			};
  			img.onerror = function (ev) {
  				_this.errors[path] = "Couldn't load image " + path;
  			};
  			img.src = path;
  		};
  		SharedAssetManager.prototype.get = function (clientId, path) {
  			path = this.pathPrefix + path;
  			var clientAssets = this.clientAssets[clientId];
  			if (clientAssets === null || clientAssets === undefined)
  				return true;
  			return clientAssets.assets[path];
  		};
  		SharedAssetManager.prototype.updateClientAssets = function (clientAssets) {
  			for (var i = 0; i < clientAssets.toLoad.length; i++) {
  				var path = clientAssets.toLoad[i];
  				var asset = clientAssets.assets[path];
  				if (asset === null || asset === undefined) {
  					var rawAsset = this.rawAssets[path];
  					if (rawAsset === null || rawAsset === undefined)
  						continue;
  					if (rawAsset instanceof HTMLImageElement) {
  						clientAssets.assets[path] = clientAssets.textureLoader(rawAsset);
  					}
  					else {
  						clientAssets.assets[path] = rawAsset;
  					}
  				}
  			}
  		};
  		SharedAssetManager.prototype.isLoadingComplete = function (clientId) {
  			var clientAssets = this.clientAssets[clientId];
  			if (clientAssets === null || clientAssets === undefined)
  				return true;
  			this.updateClientAssets(clientAssets);
  			return clientAssets.toLoad.length == clientAssets.loaded();
  		};
  		SharedAssetManager.prototype.dispose = function () {
  		};
  		SharedAssetManager.prototype.hasErrors = function () {
  			return Object.keys(this.errors).length > 0;
  		};
  		SharedAssetManager.prototype.getErrors = function () {
  			return this.errors;
  		};
  		return SharedAssetManager;
  	}());
  	spine.SharedAssetManager = SharedAssetManager;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var Skeleton = (function () {
  		function Skeleton(data) {
  			this._updateCache = new Array();
  			this.updateCacheReset = new Array();
  			this.time = 0;
  			this.scaleX = 1;
  			this.scaleY = 1;
  			this.x = 0;
  			this.y = 0;
  			if (data == null)
  				throw new Error("data cannot be null.");
  			this.data = data;
  			this.bones = new Array();
  			for (var i = 0; i < data.bones.length; i++) {
  				var boneData = data.bones[i];
  				var bone = void 0;
  				if (boneData.parent == null)
  					bone = new spine.Bone(boneData, this, null);
  				else {
  					var parent_1 = this.bones[boneData.parent.index];
  					bone = new spine.Bone(boneData, this, parent_1);
  					parent_1.children.push(bone);
  				}
  				this.bones.push(bone);
  			}
  			this.slots = new Array();
  			this.drawOrder = new Array();
  			for (var i = 0; i < data.slots.length; i++) {
  				var slotData = data.slots[i];
  				var bone = this.bones[slotData.boneData.index];
  				var slot = new spine.Slot(slotData, bone);
  				this.slots.push(slot);
  				this.drawOrder.push(slot);
  			}
  			this.ikConstraints = new Array();
  			for (var i = 0; i < data.ikConstraints.length; i++) {
  				var ikConstraintData = data.ikConstraints[i];
  				this.ikConstraints.push(new spine.IkConstraint(ikConstraintData, this));
  			}
  			this.transformConstraints = new Array();
  			for (var i = 0; i < data.transformConstraints.length; i++) {
  				var transformConstraintData = data.transformConstraints[i];
  				this.transformConstraints.push(new spine.TransformConstraint(transformConstraintData, this));
  			}
  			this.pathConstraints = new Array();
  			for (var i = 0; i < data.pathConstraints.length; i++) {
  				var pathConstraintData = data.pathConstraints[i];
  				this.pathConstraints.push(new spine.PathConstraint(pathConstraintData, this));
  			}
  			this.color = new spine.Color(1, 1, 1, 1);
  			this.updateCache();
  		}
  		Skeleton.prototype.updateCache = function () {
  			var updateCache = this._updateCache;
  			updateCache.length = 0;
  			this.updateCacheReset.length = 0;
  			var bones = this.bones;
  			for (var i = 0, n = bones.length; i < n; i++) {
  				var bone = bones[i];
  				bone.sorted = bone.data.skinRequired;
  				bone.active = !bone.sorted;
  			}
  			if (this.skin != null) {
  				var skinBones = this.skin.bones;
  				for (var i = 0, n = this.skin.bones.length; i < n; i++) {
  					var bone = this.bones[skinBones[i].index];
  					do {
  						bone.sorted = false;
  						bone.active = true;
  						bone = bone.parent;
  					} while (bone != null);
  				}
  			}
  			var ikConstraints = this.ikConstraints;
  			var transformConstraints = this.transformConstraints;
  			var pathConstraints = this.pathConstraints;
  			var ikCount = ikConstraints.length, transformCount = transformConstraints.length, pathCount = pathConstraints.length;
  			var constraintCount = ikCount + transformCount + pathCount;
  			outer: for (var i = 0; i < constraintCount; i++) {
  				for (var ii = 0; ii < ikCount; ii++) {
  					var constraint = ikConstraints[ii];
  					if (constraint.data.order == i) {
  						this.sortIkConstraint(constraint);
  						continue outer;
  					}
  				}
  				for (var ii = 0; ii < transformCount; ii++) {
  					var constraint = transformConstraints[ii];
  					if (constraint.data.order == i) {
  						this.sortTransformConstraint(constraint);
  						continue outer;
  					}
  				}
  				for (var ii = 0; ii < pathCount; ii++) {
  					var constraint = pathConstraints[ii];
  					if (constraint.data.order == i) {
  						this.sortPathConstraint(constraint);
  						continue outer;
  					}
  				}
  			}
  			for (var i = 0, n = bones.length; i < n; i++)
  				this.sortBone(bones[i]);
  		};
  		Skeleton.prototype.sortIkConstraint = function (constraint) {
  			constraint.active = constraint.target.isActive() && (!constraint.data.skinRequired || (this.skin != null && spine.Utils.contains(this.skin.constraints, constraint.data, true)));
  			if (!constraint.active)
  				return;
  			var target = constraint.target;
  			this.sortBone(target);
  			var constrained = constraint.bones;
  			var parent = constrained[0];
  			this.sortBone(parent);
  			if (constrained.length > 1) {
  				var child = constrained[constrained.length - 1];
  				if (!(this._updateCache.indexOf(child) > -1))
  					this.updateCacheReset.push(child);
  			}
  			this._updateCache.push(constraint);
  			this.sortReset(parent.children);
  			constrained[constrained.length - 1].sorted = true;
  		};
  		Skeleton.prototype.sortPathConstraint = function (constraint) {
  			constraint.active = constraint.target.bone.isActive() && (!constraint.data.skinRequired || (this.skin != null && spine.Utils.contains(this.skin.constraints, constraint.data, true)));
  			if (!constraint.active)
  				return;
  			var slot = constraint.target;
  			var slotIndex = slot.data.index;
  			var slotBone = slot.bone;
  			if (this.skin != null)
  				this.sortPathConstraintAttachment(this.skin, slotIndex, slotBone);
  			if (this.data.defaultSkin != null && this.data.defaultSkin != this.skin)
  				this.sortPathConstraintAttachment(this.data.defaultSkin, slotIndex, slotBone);
  			for (var i = 0, n = this.data.skins.length; i < n; i++)
  				this.sortPathConstraintAttachment(this.data.skins[i], slotIndex, slotBone);
  			var attachment = slot.getAttachment();
  			if (attachment instanceof spine.PathAttachment)
  				this.sortPathConstraintAttachmentWith(attachment, slotBone);
  			var constrained = constraint.bones;
  			var boneCount = constrained.length;
  			for (var i = 0; i < boneCount; i++)
  				this.sortBone(constrained[i]);
  			this._updateCache.push(constraint);
  			for (var i = 0; i < boneCount; i++)
  				this.sortReset(constrained[i].children);
  			for (var i = 0; i < boneCount; i++)
  				constrained[i].sorted = true;
  		};
  		Skeleton.prototype.sortTransformConstraint = function (constraint) {
  			constraint.active = constraint.target.isActive() && (!constraint.data.skinRequired || (this.skin != null && spine.Utils.contains(this.skin.constraints, constraint.data, true)));
  			if (!constraint.active)
  				return;
  			this.sortBone(constraint.target);
  			var constrained = constraint.bones;
  			var boneCount = constrained.length;
  			if (constraint.data.local) {
  				for (var i = 0; i < boneCount; i++) {
  					var child = constrained[i];
  					this.sortBone(child.parent);
  					if (!(this._updateCache.indexOf(child) > -1))
  						this.updateCacheReset.push(child);
  				}
  			}
  			else {
  				for (var i = 0; i < boneCount; i++) {
  					this.sortBone(constrained[i]);
  				}
  			}
  			this._updateCache.push(constraint);
  			for (var ii = 0; ii < boneCount; ii++)
  				this.sortReset(constrained[ii].children);
  			for (var ii = 0; ii < boneCount; ii++)
  				constrained[ii].sorted = true;
  		};
  		Skeleton.prototype.sortPathConstraintAttachment = function (skin, slotIndex, slotBone) {
  			var attachments = skin.attachments[slotIndex];
  			if (!attachments)
  				return;
  			for (var key in attachments) {
  				this.sortPathConstraintAttachmentWith(attachments[key], slotBone);
  			}
  		};
  		Skeleton.prototype.sortPathConstraintAttachmentWith = function (attachment, slotBone) {
  			if (!(attachment instanceof spine.PathAttachment))
  				return;
  			var pathBones = attachment.bones;
  			if (pathBones == null)
  				this.sortBone(slotBone);
  			else {
  				var bones = this.bones;
  				var i = 0;
  				while (i < pathBones.length) {
  					var boneCount = pathBones[i++];
  					for (var n = i + boneCount; i < n; i++) {
  						var boneIndex = pathBones[i];
  						this.sortBone(bones[boneIndex]);
  					}
  				}
  			}
  		};
  		Skeleton.prototype.sortBone = function (bone) {
  			if (bone.sorted)
  				return;
  			var parent = bone.parent;
  			if (parent != null)
  				this.sortBone(parent);
  			bone.sorted = true;
  			this._updateCache.push(bone);
  		};
  		Skeleton.prototype.sortReset = function (bones) {
  			for (var i = 0, n = bones.length; i < n; i++) {
  				var bone = bones[i];
  				if (!bone.active)
  					continue;
  				if (bone.sorted)
  					this.sortReset(bone.children);
  				bone.sorted = false;
  			}
  		};
  		Skeleton.prototype.updateWorldTransform = function () {
  			var updateCacheReset = this.updateCacheReset;
  			for (var i = 0, n = updateCacheReset.length; i < n; i++) {
  				var bone = updateCacheReset[i];
  				bone.ax = bone.x;
  				bone.ay = bone.y;
  				bone.arotation = bone.rotation;
  				bone.ascaleX = bone.scaleX;
  				bone.ascaleY = bone.scaleY;
  				bone.ashearX = bone.shearX;
  				bone.ashearY = bone.shearY;
  				bone.appliedValid = true;
  			}
  			var updateCache = this._updateCache;
  			for (var i = 0, n = updateCache.length; i < n; i++)
  				updateCache[i].update();
  		};
  		Skeleton.prototype.setToSetupPose = function () {
  			this.setBonesToSetupPose();
  			this.setSlotsToSetupPose();
  		};
  		Skeleton.prototype.setBonesToSetupPose = function () {
  			var bones = this.bones;
  			for (var i = 0, n = bones.length; i < n; i++)
  				bones[i].setToSetupPose();
  			var ikConstraints = this.ikConstraints;
  			for (var i = 0, n = ikConstraints.length; i < n; i++) {
  				var constraint = ikConstraints[i];
  				constraint.mix = constraint.data.mix;
  				constraint.softness = constraint.data.softness;
  				constraint.bendDirection = constraint.data.bendDirection;
  				constraint.compress = constraint.data.compress;
  				constraint.stretch = constraint.data.stretch;
  			}
  			var transformConstraints = this.transformConstraints;
  			for (var i = 0, n = transformConstraints.length; i < n; i++) {
  				var constraint = transformConstraints[i];
  				var data = constraint.data;
  				constraint.rotateMix = data.rotateMix;
  				constraint.translateMix = data.translateMix;
  				constraint.scaleMix = data.scaleMix;
  				constraint.shearMix = data.shearMix;
  			}
  			var pathConstraints = this.pathConstraints;
  			for (var i = 0, n = pathConstraints.length; i < n; i++) {
  				var constraint = pathConstraints[i];
  				var data = constraint.data;
  				constraint.position = data.position;
  				constraint.spacing = data.spacing;
  				constraint.rotateMix = data.rotateMix;
  				constraint.translateMix = data.translateMix;
  			}
  		};
  		Skeleton.prototype.setSlotsToSetupPose = function () {
  			var slots = this.slots;
  			spine.Utils.arrayCopy(slots, 0, this.drawOrder, 0, slots.length);
  			for (var i = 0, n = slots.length; i < n; i++)
  				slots[i].setToSetupPose();
  		};
  		Skeleton.prototype.getRootBone = function () {
  			if (this.bones.length == 0)
  				return null;
  			return this.bones[0];
  		};
  		Skeleton.prototype.findBone = function (boneName) {
  			if (boneName == null)
  				throw new Error("boneName cannot be null.");
  			var bones = this.bones;
  			for (var i = 0, n = bones.length; i < n; i++) {
  				var bone = bones[i];
  				if (bone.data.name == boneName)
  					return bone;
  			}
  			return null;
  		};
  		Skeleton.prototype.findBoneIndex = function (boneName) {
  			if (boneName == null)
  				throw new Error("boneName cannot be null.");
  			var bones = this.bones;
  			for (var i = 0, n = bones.length; i < n; i++)
  				if (bones[i].data.name == boneName)
  					return i;
  			return -1;
  		};
  		Skeleton.prototype.findSlot = function (slotName) {
  			if (slotName == null)
  				throw new Error("slotName cannot be null.");
  			var slots = this.slots;
  			for (var i = 0, n = slots.length; i < n; i++) {
  				var slot = slots[i];
  				if (slot.data.name == slotName)
  					return slot;
  			}
  			return null;
  		};
  		Skeleton.prototype.findSlotIndex = function (slotName) {
  			if (slotName == null)
  				throw new Error("slotName cannot be null.");
  			var slots = this.slots;
  			for (var i = 0, n = slots.length; i < n; i++)
  				if (slots[i].data.name == slotName)
  					return i;
  			return -1;
  		};
  		Skeleton.prototype.setSkinByName = function (skinName) {
  			var skin = this.data.findSkin(skinName);
  			if (skin == null)
  				throw new Error("Skin not found: " + skinName);
  			this.setSkin(skin);
  		};
  		Skeleton.prototype.setSkin = function (newSkin) {
  			if (newSkin == this.skin)
  				return;
  			if (newSkin != null) {
  				if (this.skin != null)
  					newSkin.attachAll(this, this.skin);
  				else {
  					var slots = this.slots;
  					for (var i = 0, n = slots.length; i < n; i++) {
  						var slot = slots[i];
  						var name_1 = slot.data.attachmentName;
  						if (name_1 != null) {
  							var attachment = newSkin.getAttachment(i, name_1);
  							if (attachment != null)
  								slot.setAttachment(attachment);
  						}
  					}
  				}
  			}
  			this.skin = newSkin;
  			this.updateCache();
  		};
  		Skeleton.prototype.getAttachmentByName = function (slotName, attachmentName) {
  			return this.getAttachment(this.data.findSlotIndex(slotName), attachmentName);
  		};
  		Skeleton.prototype.getAttachment = function (slotIndex, attachmentName) {
  			if (attachmentName == null)
  				throw new Error("attachmentName cannot be null.");
  			if (this.skin != null) {
  				var attachment = this.skin.getAttachment(slotIndex, attachmentName);
  				if (attachment != null)
  					return attachment;
  			}
  			if (this.data.defaultSkin != null)
  				return this.data.defaultSkin.getAttachment(slotIndex, attachmentName);
  			return null;
  		};
  		Skeleton.prototype.setAttachment = function (slotName, attachmentName) {
  			if (slotName == null)
  				throw new Error("slotName cannot be null.");
  			var slots = this.slots;
  			for (var i = 0, n = slots.length; i < n; i++) {
  				var slot = slots[i];
  				if (slot.data.name == slotName) {
  					var attachment = null;
  					if (attachmentName != null) {
  						attachment = this.getAttachment(i, attachmentName);
  						if (attachment == null)
  							throw new Error("Attachment not found: " + attachmentName + ", for slot: " + slotName);
  					}
  					slot.setAttachment(attachment);
  					return;
  				}
  			}
  			throw new Error("Slot not found: " + slotName);
  		};
  		Skeleton.prototype.findIkConstraint = function (constraintName) {
  			if (constraintName == null)
  				throw new Error("constraintName cannot be null.");
  			var ikConstraints = this.ikConstraints;
  			for (var i = 0, n = ikConstraints.length; i < n; i++) {
  				var ikConstraint = ikConstraints[i];
  				if (ikConstraint.data.name == constraintName)
  					return ikConstraint;
  			}
  			return null;
  		};
  		Skeleton.prototype.findTransformConstraint = function (constraintName) {
  			if (constraintName == null)
  				throw new Error("constraintName cannot be null.");
  			var transformConstraints = this.transformConstraints;
  			for (var i = 0, n = transformConstraints.length; i < n; i++) {
  				var constraint = transformConstraints[i];
  				if (constraint.data.name == constraintName)
  					return constraint;
  			}
  			return null;
  		};
  		Skeleton.prototype.findPathConstraint = function (constraintName) {
  			if (constraintName == null)
  				throw new Error("constraintName cannot be null.");
  			var pathConstraints = this.pathConstraints;
  			for (var i = 0, n = pathConstraints.length; i < n; i++) {
  				var constraint = pathConstraints[i];
  				if (constraint.data.name == constraintName)
  					return constraint;
  			}
  			return null;
  		};
  		Skeleton.prototype.getBounds = function (offset, size, temp) {
  			if (temp === void 0) { temp = new Array(2); }
  			if (offset == null)
  				throw new Error("offset cannot be null.");
  			if (size == null)
  				throw new Error("size cannot be null.");
  			var drawOrder = this.drawOrder;
  			var minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;
  			for (var i = 0, n = drawOrder.length; i < n; i++) {
  				var slot = drawOrder[i];
  				if (!slot.bone.active)
  					continue;
  				var verticesLength = 0;
  				var vertices = null;
  				var attachment = slot.getAttachment();
  				if (attachment instanceof spine.RegionAttachment) {
  					verticesLength = 8;
  					vertices = spine.Utils.setArraySize(temp, verticesLength, 0);
  					attachment.computeWorldVertices(slot.bone, vertices, 0, 2);
  				}
  				else if (attachment instanceof spine.MeshAttachment) {
  					var mesh = attachment;
  					verticesLength = mesh.worldVerticesLength;
  					vertices = spine.Utils.setArraySize(temp, verticesLength, 0);
  					mesh.computeWorldVertices(slot, 0, verticesLength, vertices, 0, 2);
  				}
  				if (vertices != null) {
  					for (var ii = 0, nn = vertices.length; ii < nn; ii += 2) {
  						var x = vertices[ii], y = vertices[ii + 1];
  						minX = Math.min(minX, x);
  						minY = Math.min(minY, y);
  						maxX = Math.max(maxX, x);
  						maxY = Math.max(maxY, y);
  					}
  				}
  			}
  			offset.set(minX, minY);
  			size.set(maxX - minX, maxY - minY);
  		};
  		Skeleton.prototype.update = function (delta) {
  			this.time += delta;
  		};
  		return Skeleton;
  	}());
  	spine.Skeleton = Skeleton;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var SkeletonBinary = (function () {
  		function SkeletonBinary(attachmentLoader) {
  			this.scale = 1;
  			this.linkedMeshes = new Array();
  			this.attachmentLoader = attachmentLoader;
  		}
  		SkeletonBinary.prototype.readSkeletonData = function (binary) {
  			var scale = this.scale;
  			var skeletonData = new spine.SkeletonData();
  			skeletonData.name = "";
  			var input = new BinaryInput(binary);
  			skeletonData.hash = input.readString();
  			skeletonData.version = input.readString();
  			if ("3.8.75" == skeletonData.version)
  				throw new Error("Unsupported skeleton data, please export with a newer version of Spine.");
  			skeletonData.x = input.readFloat();
  			skeletonData.y = input.readFloat();
  			skeletonData.width = input.readFloat();
  			skeletonData.height = input.readFloat();
  			var nonessential = input.readBoolean();
  			if (nonessential) {
  				skeletonData.fps = input.readFloat();
  				skeletonData.imagesPath = input.readString();
  				skeletonData.audioPath = input.readString();
  			}
  			var n = 0;
  			n = input.readInt(true);
  			for (var i = 0; i < n; i++)
  				input.strings.push(input.readString());
  			n = input.readInt(true);
  			for (var i = 0; i < n; i++) {
  				var name_2 = input.readString();
  				var parent_2 = i == 0 ? null : skeletonData.bones[input.readInt(true)];
  				var data = new spine.BoneData(i, name_2, parent_2);
  				data.rotation = input.readFloat();
  				data.x = input.readFloat() * scale;
  				data.y = input.readFloat() * scale;
  				data.scaleX = input.readFloat();
  				data.scaleY = input.readFloat();
  				data.shearX = input.readFloat();
  				data.shearY = input.readFloat();
  				data.length = input.readFloat() * scale;
  				data.transformMode = SkeletonBinary.TransformModeValues[input.readInt(true)];
  				data.skinRequired = input.readBoolean();
  				if (nonessential)
  					spine.Color.rgba8888ToColor(data.color, input.readInt32());
  				skeletonData.bones.push(data);
  			}
  			n = input.readInt(true);
  			for (var i = 0; i < n; i++) {
  				var slotName = input.readString();
  				var boneData = skeletonData.bones[input.readInt(true)];
  				var data = new spine.SlotData(i, slotName, boneData);
  				spine.Color.rgba8888ToColor(data.color, input.readInt32());
  				var darkColor = input.readInt32();
  				if (darkColor != -1)
  					spine.Color.rgb888ToColor(data.darkColor = new spine.Color(), darkColor);
  				data.attachmentName = input.readStringRef();
  				data.blendMode = SkeletonBinary.BlendModeValues[input.readInt(true)];
  				skeletonData.slots.push(data);
  			}
  			n = input.readInt(true);
  			for (var i = 0, nn = void 0; i < n; i++) {
  				var data = new spine.IkConstraintData(input.readString());
  				data.order = input.readInt(true);
  				data.skinRequired = input.readBoolean();
  				nn = input.readInt(true);
  				for (var ii = 0; ii < nn; ii++)
  					data.bones.push(skeletonData.bones[input.readInt(true)]);
  				data.target = skeletonData.bones[input.readInt(true)];
  				data.mix = input.readFloat();
  				data.softness = input.readFloat() * scale;
  				data.bendDirection = input.readByte();
  				data.compress = input.readBoolean();
  				data.stretch = input.readBoolean();
  				data.uniform = input.readBoolean();
  				skeletonData.ikConstraints.push(data);
  			}
  			n = input.readInt(true);
  			for (var i = 0, nn = void 0; i < n; i++) {
  				var data = new spine.TransformConstraintData(input.readString());
  				data.order = input.readInt(true);
  				data.skinRequired = input.readBoolean();
  				nn = input.readInt(true);
  				for (var ii = 0; ii < nn; ii++)
  					data.bones.push(skeletonData.bones[input.readInt(true)]);
  				data.target = skeletonData.bones[input.readInt(true)];
  				data.local = input.readBoolean();
  				data.relative = input.readBoolean();
  				data.offsetRotation = input.readFloat();
  				data.offsetX = input.readFloat() * scale;
  				data.offsetY = input.readFloat() * scale;
  				data.offsetScaleX = input.readFloat();
  				data.offsetScaleY = input.readFloat();
  				data.offsetShearY = input.readFloat();
  				data.rotateMix = input.readFloat();
  				data.translateMix = input.readFloat();
  				data.scaleMix = input.readFloat();
  				data.shearMix = input.readFloat();
  				skeletonData.transformConstraints.push(data);
  			}
  			n = input.readInt(true);
  			for (var i = 0, nn = void 0; i < n; i++) {
  				var data = new spine.PathConstraintData(input.readString());
  				data.order = input.readInt(true);
  				data.skinRequired = input.readBoolean();
  				nn = input.readInt(true);
  				for (var 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.spacingMode = SkeletonBinary.SpacingModeValues[input.readInt(true)];
  				data.rotateMode = SkeletonBinary.RotateModeValues[input.readInt(true)];
  				data.offsetRotation = input.readFloat();
  				data.position = input.readFloat();
  				if (data.positionMode == spine.PositionMode.Fixed)
  					data.position *= scale;
  				data.spacing = input.readFloat();
  				if (data.spacingMode == spine.SpacingMode.Length || data.spacingMode == spine.SpacingMode.Fixed)
  					data.spacing *= scale;
  				data.rotateMix = input.readFloat();
  				data.translateMix = input.readFloat();
  				skeletonData.pathConstraints.push(data);
  			}
  			var defaultSkin = this.readSkin(input, skeletonData, true, nonessential);
  			if (defaultSkin != null) {
  				skeletonData.defaultSkin = defaultSkin;
  				skeletonData.skins.push(defaultSkin);
  			}
  			{
  				var i = skeletonData.skins.length;
  				spine.Utils.setArraySize(skeletonData.skins, n = i + input.readInt(true));
  				for (; i < n; i++)
  					skeletonData.skins[i] = this.readSkin(input, skeletonData, false, nonessential);
  			}
  			n = this.linkedMeshes.length;
  			for (var i = 0; i < n; i++) {
  				var linkedMesh = this.linkedMeshes[i];
  				var skin = linkedMesh.skin == null ? skeletonData.defaultSkin : skeletonData.findSkin(linkedMesh.skin);
  				if (skin == null)
  					throw new Error("Skin not found: " + linkedMesh.skin);
  				var parent_3 = skin.getAttachment(linkedMesh.slotIndex, linkedMesh.parent);
  				if (parent_3 == null)
  					throw new Error("Parent mesh not found: " + linkedMesh.parent);
  				linkedMesh.mesh.deformAttachment = linkedMesh.inheritDeform ? parent_3 : linkedMesh.mesh;
  				linkedMesh.mesh.setParentMesh(parent_3);
  				linkedMesh.mesh.updateUVs();
  			}
  			this.linkedMeshes.length = 0;
  			n = input.readInt(true);
  			for (var i = 0; i < n; i++) {
  				var data = new spine.EventData(input.readStringRef());
  				data.intValue = input.readInt(false);
  				data.floatValue = input.readFloat();
  				data.stringValue = input.readString();
  				data.audioPath = input.readString();
  				if (data.audioPath != null) {
  					data.volume = input.readFloat();
  					data.balance = input.readFloat();
  				}
  				skeletonData.events.push(data);
  			}
  			n = input.readInt(true);
  			for (var i = 0; i < n; i++)
  				skeletonData.animations.push(this.readAnimation(input, input.readString(), skeletonData));
  			return skeletonData;
  		};
  		SkeletonBinary.prototype.readSkin = function (input, skeletonData, defaultSkin, nonessential) {
  			var skin = null;
  			var slotCount = 0;
  			if (defaultSkin) {
  				slotCount = input.readInt(true);
  				if (slotCount == 0)
  					return null;
  				skin = new spine.Skin("default");
  			}
  			else {
  				skin = new spine.Skin(input.readStringRef());
  				skin.bones.length = input.readInt(true);
  				for (var i = 0, n = skin.bones.length; i < n; i++)
  					skin.bones[i] = skeletonData.bones[input.readInt(true)];
  				for (var i = 0, n = input.readInt(true); i < n; i++)
  					skin.constraints.push(skeletonData.ikConstraints[input.readInt(true)]);
  				for (var i = 0, n = input.readInt(true); i < n; i++)
  					skin.constraints.push(skeletonData.transformConstraints[input.readInt(true)]);
  				for (var i = 0, n = input.readInt(true); i < n; i++)
  					skin.constraints.push(skeletonData.pathConstraints[input.readInt(true)]);
  				slotCount = input.readInt(true);
  			}
  			for (var i = 0; i < slotCount; i++) {
  				var slotIndex = input.readInt(true);
  				for (var ii = 0, nn = input.readInt(true); ii < nn; ii++) {
  					var name_3 = input.readStringRef();
  					var attachment = this.readAttachment(input, skeletonData, skin, slotIndex, name_3, nonessential);
  					if (attachment != null)
  						skin.setAttachment(slotIndex, name_3, attachment);
  				}
  			}
  			return skin;
  		};
  		SkeletonBinary.prototype.readAttachment = function (input, skeletonData, skin, slotIndex, attachmentName, nonessential) {
  			var scale = this.scale;
  			var name = input.readStringRef();
  			if (name == null)
  				name = attachmentName;
  			var typeIndex = input.readByte();
  			var type = SkeletonBinary.AttachmentTypeValues[typeIndex];
  			switch (type) {
  				case spine.AttachmentType.Region: {
  					var path = input.readStringRef();
  					var rotation = input.readFloat();
  					var x = input.readFloat();
  					var y = input.readFloat();
  					var scaleX = input.readFloat();
  					var scaleY = input.readFloat();
  					var width = input.readFloat();
  					var height = input.readFloat();
  					var color = input.readInt32();
  					if (path == null)
  						path = name;
  					var region = this.attachmentLoader.newRegionAttachment(skin, name, path);
  					if (region == null)
  						return null;
  					region.path = path;
  					region.x = x * scale;
  					region.y = y * scale;
  					region.scaleX = scaleX;
  					region.scaleY = scaleY;
  					region.rotation = rotation;
  					region.width = width * scale;
  					region.height = height * scale;
  					spine.Color.rgba8888ToColor(region.color, color);
  					region.updateOffset();
  					return region;
  				}
  				case spine.AttachmentType.BoundingBox: {
  					var vertexCount = input.readInt(true);
  					var vertices = this.readVertices(input, vertexCount);
  					var color = nonessential ? input.readInt32() : 0;
  					var box = this.attachmentLoader.newBoundingBoxAttachment(skin, name);
  					if (box == null)
  						return null;
  					box.worldVerticesLength = vertexCount << 1;
  					box.vertices = vertices.vertices;
  					box.bones = vertices.bones;
  					if (nonessential)
  						spine.Color.rgba8888ToColor(box.color, color);
  					return box;
  				}
  				case spine.AttachmentType.Mesh: {
  					var path = input.readStringRef();
  					var color = input.readInt32();
  					var vertexCount = input.readInt(true);
  					var uvs = this.readFloatArray(input, vertexCount << 1, 1);
  					var triangles = this.readShortArray(input);
  					var vertices = this.readVertices(input, vertexCount);
  					var hullLength = input.readInt(true);
  					var edges = null;
  					var width = 0, height = 0;
  					if (nonessential) {
  						edges = this.readShortArray(input);
  						width = input.readFloat();
  						height = input.readFloat();
  					}
  					if (path == null)
  						path = name;
  					var mesh = this.attachmentLoader.newMeshAttachment(skin, name, path);
  					if (mesh == null)
  						return null;
  					mesh.path = path;
  					spine.Color.rgba8888ToColor(mesh.color, color);
  					mesh.bones = vertices.bones;
  					mesh.vertices = vertices.vertices;
  					mesh.worldVerticesLength = vertexCount << 1;
  					mesh.triangles = triangles;
  					mesh.regionUVs = uvs;
  					mesh.updateUVs();
  					mesh.hullLength = hullLength << 1;
  					if (nonessential) {
  						mesh.edges = edges;
  						mesh.width = width * scale;
  						mesh.height = height * scale;
  					}
  					return mesh;
  				}
  				case spine.AttachmentType.LinkedMesh: {
  					var path = input.readStringRef();
  					var color = input.readInt32();
  					var skinName = input.readStringRef();
  					var parent_4 = input.readStringRef();
  					var inheritDeform = input.readBoolean();
  					var width = 0, height = 0;
  					if (nonessential) {
  						width = input.readFloat();
  						height = input.readFloat();
  					}
  					if (path == null)
  						path = name;
  					var mesh = this.attachmentLoader.newMeshAttachment(skin, name, path);
  					if (mesh == null)
  						return null;
  					mesh.path = path;
  					spine.Color.rgba8888ToColor(mesh.color, color);
  					if (nonessential) {
  						mesh.width = width * scale;
  						mesh.height = height * scale;
  					}
  					this.linkedMeshes.push(new LinkedMesh(mesh, skinName, slotIndex, parent_4, inheritDeform));
  					return mesh;
  				}
  				case spine.AttachmentType.Path: {
  					var closed_1 = input.readBoolean();
  					var constantSpeed = input.readBoolean();
  					var vertexCount = input.readInt(true);
  					var vertices = this.readVertices(input, vertexCount);
  					var lengths = spine.Utils.newArray(vertexCount / 3, 0);
  					for (var i = 0, n = lengths.length; i < n; i++)
  						lengths[i] = input.readFloat() * scale;
  					var color = nonessential ? input.readInt32() : 0;
  					var path = this.attachmentLoader.newPathAttachment(skin, name);
  					if (path == null)
  						return null;
  					path.closed = closed_1;
  					path.constantSpeed = constantSpeed;
  					path.worldVerticesLength = vertexCount << 1;
  					path.vertices = vertices.vertices;
  					path.bones = vertices.bones;
  					path.lengths = lengths;
  					if (nonessential)
  						spine.Color.rgba8888ToColor(path.color, color);
  					return path;
  				}
  				case spine.AttachmentType.Point: {
  					var rotation = input.readFloat();
  					var x = input.readFloat();
  					var y = input.readFloat();
  					var color = nonessential ? input.readInt32() : 0;
  					var point = this.attachmentLoader.newPointAttachment(skin, name);
  					if (point == null)
  						return null;
  					point.x = x * scale;
  					point.y = y * scale;
  					point.rotation = rotation;
  					if (nonessential)
  						spine.Color.rgba8888ToColor(point.color, color);
  					return point;
  				}
  				case spine.AttachmentType.Clipping: {
  					var endSlotIndex = input.readInt(true);
  					var vertexCount = input.readInt(true);
  					var vertices = this.readVertices(input, vertexCount);
  					var color = nonessential ? input.readInt32() : 0;
  					var clip = this.attachmentLoader.newClippingAttachment(skin, name);
  					if (clip == null)
  						return null;
  					clip.endSlot = skeletonData.slots[endSlotIndex];
  					clip.worldVerticesLength = vertexCount << 1;
  					clip.vertices = vertices.vertices;
  					clip.bones = vertices.bones;
  					if (nonessential)
  						spine.Color.rgba8888ToColor(clip.color, color);
  					return clip;
  				}
  			}
  			return null;
  		};
  		SkeletonBinary.prototype.readVertices = function (input, vertexCount) {
  			var verticesLength = vertexCount << 1;
  			var vertices = new Vertices();
  			var scale = this.scale;
  			if (!input.readBoolean()) {
  				vertices.vertices = this.readFloatArray(input, verticesLength, scale);
  				return vertices;
  			}
  			var weights = new Array();
  			var bonesArray = new Array();
  			for (var i = 0; i < vertexCount; i++) {
  				var boneCount = input.readInt(true);
  				bonesArray.push(boneCount);
  				for (var ii = 0; ii < boneCount; ii++) {
  					bonesArray.push(input.readInt(true));
  					weights.push(input.readFloat() * scale);
  					weights.push(input.readFloat() * scale);
  					weights.push(input.readFloat());
  				}
  			}
  			vertices.vertices = spine.Utils.toFloatArray(weights);
  			vertices.bones = bonesArray;
  			return vertices;
  		};
  		SkeletonBinary.prototype.readFloatArray = function (input, n, scale) {
  			var array = new Array(n);
  			if (scale == 1) {
  				for (var i = 0; i < n; i++)
  					array[i] = input.readFloat();
  			}
  			else {
  				for (var i = 0; i < n; i++)
  					array[i] = input.readFloat() * scale;
  			}
  			return array;
  		};
  		SkeletonBinary.prototype.readShortArray = function (input) {
  			var n = input.readInt(true);
  			var array = new Array(n);
  			for (var i = 0; i < n; i++)
  				array[i] = input.readShort();
  			return array;
  		};
  		SkeletonBinary.prototype.readAnimation = function (input, name, skeletonData) {
  			var timelines = new Array();
  			var scale = this.scale;
  			var duration = 0;
  			var tempColor1 = new spine.Color();
  			var tempColor2 = new spine.Color();
  			for (var i = 0, n = input.readInt(true); i < n; i++) {
  				var slotIndex = input.readInt(true);
  				for (var ii = 0, nn = input.readInt(true); ii < nn; ii++) {
  					var timelineType = input.readByte();
  					var frameCount = input.readInt(true);
  					switch (timelineType) {
  						case SkeletonBinary.SLOT_ATTACHMENT: {
  							var timeline = new spine.AttachmentTimeline(frameCount);
  							timeline.slotIndex = slotIndex;
  							for (var frameIndex = 0; frameIndex < frameCount; frameIndex++)
  								timeline.setFrame(frameIndex, input.readFloat(), input.readStringRef());
  							timelines.push(timeline);
  							duration = Math.max(duration, timeline.frames[frameCount - 1]);
  							break;
  						}
  						case SkeletonBinary.SLOT_COLOR: {
  							var timeline = new spine.ColorTimeline(frameCount);
  							timeline.slotIndex = slotIndex;
  							for (var frameIndex = 0; frameIndex < frameCount; frameIndex++) {
  								var time = input.readFloat();
  								spine.Color.rgba8888ToColor(tempColor1, input.readInt32());
  								timeline.setFrame(frameIndex, time, tempColor1.r, tempColor1.g, tempColor1.b, tempColor1.a);
  								if (frameIndex < frameCount - 1)
  									this.readCurve(input, frameIndex, timeline);
  							}
  							timelines.push(timeline);
  							duration = Math.max(duration, timeline.frames[(frameCount - 1) * spine.ColorTimeline.ENTRIES]);
  							break;
  						}
  						case SkeletonBinary.SLOT_TWO_COLOR: {
  							var timeline = new spine.TwoColorTimeline(frameCount);
  							timeline.slotIndex = slotIndex;
  							for (var frameIndex = 0; frameIndex < frameCount; frameIndex++) {
  								var time = input.readFloat();
  								spine.Color.rgba8888ToColor(tempColor1, input.readInt32());
  								spine.Color.rgb888ToColor(tempColor2, input.readInt32());
  								timeline.setFrame(frameIndex, time, tempColor1.r, tempColor1.g, tempColor1.b, tempColor1.a, tempColor2.r, tempColor2.g, tempColor2.b);
  								if (frameIndex < frameCount - 1)
  									this.readCurve(input, frameIndex, timeline);
  							}
  							timelines.push(timeline);
  							duration = Math.max(duration, timeline.frames[(frameCount - 1) * spine.TwoColorTimeline.ENTRIES]);
  							break;
  						}
  					}
  				}
  			}
  			for (var i = 0, n = input.readInt(true); i < n; i++) {
  				var boneIndex = input.readInt(true);
  				for (var ii = 0, nn = input.readInt(true); ii < nn; ii++) {
  					var timelineType = input.readByte();
  					var frameCount = input.readInt(true);
  					switch (timelineType) {
  						case SkeletonBinary.BONE_ROTATE: {
  							var timeline = new spine.RotateTimeline(frameCount);
  							timeline.boneIndex = boneIndex;
  							for (var frameIndex = 0; frameIndex < frameCount; frameIndex++) {
  								timeline.setFrame(frameIndex, input.readFloat(), input.readFloat());
  								if (frameIndex < frameCount - 1)
  									this.readCurve(input, frameIndex, timeline);
  							}
  							timelines.push(timeline);
  							duration = Math.max(duration, timeline.frames[(frameCount - 1) * spine.RotateTimeline.ENTRIES]);
  							break;
  						}
  						case SkeletonBinary.BONE_TRANSLATE:
  						case SkeletonBinary.BONE_SCALE:
  						case SkeletonBinary.BONE_SHEAR: {
  							var timeline = void 0;
  							var timelineScale = 1;
  							if (timelineType == SkeletonBinary.BONE_SCALE)
  								timeline = new spine.ScaleTimeline(frameCount);
  							else if (timelineType == SkeletonBinary.BONE_SHEAR)
  								timeline = new spine.ShearTimeline(frameCount);
  							else {
  								timeline = new spine.TranslateTimeline(frameCount);
  								timelineScale = scale;
  							}
  							timeline.boneIndex = boneIndex;
  							for (var frameIndex = 0; frameIndex < frameCount; frameIndex++) {
  								timeline.setFrame(frameIndex, input.readFloat(), input.readFloat() * timelineScale, input.readFloat() * timelineScale);
  								if (frameIndex < frameCount - 1)
  									this.readCurve(input, frameIndex, timeline);
  							}
  							timelines.push(timeline);
  							duration = Math.max(duration, timeline.frames[(frameCount - 1) * spine.TranslateTimeline.ENTRIES]);
  							break;
  						}
  					}
  				}
  			}
  			for (var i = 0, n = input.readInt(true); i < n; i++) {
  				var index = input.readInt(true);
  				var frameCount = input.readInt(true);
  				var timeline = new spine.IkConstraintTimeline(frameCount);
  				timeline.ikConstraintIndex = index;
  				for (var frameIndex = 0; frameIndex < frameCount; frameIndex++) {
  					timeline.setFrame(frameIndex, input.readFloat(), input.readFloat(), input.readFloat() * scale, input.readByte(), input.readBoolean(), input.readBoolean());
  					if (frameIndex < frameCount - 1)
  						this.readCurve(input, frameIndex, timeline);
  				}
  				timelines.push(timeline);
  				duration = Math.max(duration, timeline.frames[(frameCount - 1) * spine.IkConstraintTimeline.ENTRIES]);
  			}
  			for (var i = 0, n = input.readInt(true); i < n; i++) {
  				var index = input.readInt(true);
  				var frameCount = input.readInt(true);
  				var timeline = new spine.TransformConstraintTimeline(frameCount);
  				timeline.transformConstraintIndex = index;
  				for (var frameIndex = 0; frameIndex < frameCount; frameIndex++) {
  					timeline.setFrame(frameIndex, input.readFloat(), input.readFloat(), input.readFloat(), input.readFloat(), input.readFloat());
  					if (frameIndex < frameCount - 1)
  						this.readCurve(input, frameIndex, timeline);
  				}
  				timelines.push(timeline);
  				duration = Math.max(duration, timeline.frames[(frameCount - 1) * spine.TransformConstraintTimeline.ENTRIES]);
  			}
  			for (var i = 0, n = input.readInt(true); i < n; i++) {
  				var index = input.readInt(true);
  				var data = skeletonData.pathConstraints[index];
  				for (var ii = 0, nn = input.readInt(true); ii < nn; ii++) {
  					var timelineType = input.readByte();
  					var frameCount = input.readInt(true);
  					switch (timelineType) {
  						case SkeletonBinary.PATH_POSITION:
  						case SkeletonBinary.PATH_SPACING: {
  							var timeline = void 0;
  							var timelineScale = 1;
  							if (timelineType == SkeletonBinary.PATH_SPACING) {
  								timeline = new spine.PathConstraintSpacingTimeline(frameCount);
  								if (data.spacingMode == spine.SpacingMode.Length || data.spacingMode == spine.SpacingMode.Fixed)
  									timelineScale = scale;
  							}
  							else {
  								timeline = new spine.PathConstraintPositionTimeline(frameCount);
  								if (data.positionMode == spine.PositionMode.Fixed)
  									timelineScale = scale;
  							}
  							timeline.pathConstraintIndex = index;
  							for (var frameIndex = 0; frameIndex < frameCount; frameIndex++) {
  								timeline.setFrame(frameIndex, input.readFloat(), input.readFloat() * timelineScale);
  								if (frameIndex < frameCount - 1)
  									this.readCurve(input, frameIndex, timeline);
  							}
  							timelines.push(timeline);
  							duration = Math.max(duration, timeline.frames[(frameCount - 1) * spine.PathConstraintPositionTimeline.ENTRIES]);
  							break;
  						}
  						case SkeletonBinary.PATH_MIX: {
  							var timeline = new spine.PathConstraintMixTimeline(frameCount);
  							timeline.pathConstraintIndex = index;
  							for (var frameIndex = 0; frameIndex < frameCount; frameIndex++) {
  								timeline.setFrame(frameIndex, input.readFloat(), input.readFloat(), input.readFloat());
  								if (frameIndex < frameCount - 1)
  									this.readCurve(input, frameIndex, timeline);
  							}
  							timelines.push(timeline);
  							duration = Math.max(duration, timeline.frames[(frameCount - 1) * spine.PathConstraintMixTimeline.ENTRIES]);
  							break;
  						}
  					}
  				}
  			}
  			for (var i = 0, n = input.readInt(true); i < n; i++) {
  				var skin = skeletonData.skins[input.readInt(true)];
  				for (var ii = 0, nn = input.readInt(true); ii < nn; ii++) {
  					var slotIndex = input.readInt(true);
  					for (var iii = 0, nnn = input.readInt(true); iii < nnn; iii++) {
  						var attachment = skin.getAttachment(slotIndex, input.readStringRef());
  						var weighted = attachment.bones != null;
  						var vertices = attachment.vertices;
  						var deformLength = weighted ? vertices.length / 3 * 2 : vertices.length;
  						var frameCount = input.readInt(true);
  						var timeline = new spine.DeformTimeline(frameCount);
  						timeline.slotIndex = slotIndex;
  						timeline.attachment = attachment;
  						for (var frameIndex = 0; frameIndex < frameCount; frameIndex++) {
  							var time = input.readFloat();
  							var deform = void 0;
  							var end = input.readInt(true);
  							if (end == 0)
  								deform = weighted ? spine.Utils.newFloatArray(deformLength) : vertices;
  							else {
  								deform = spine.Utils.newFloatArray(deformLength);
  								var start = input.readInt(true);
  								end += start;
  								if (scale == 1) {
  									for (var v = start; v < end; v++)
  										deform[v] = input.readFloat();
  								}
  								else {
  									for (var v = start; v < end; v++)
  										deform[v] = input.readFloat() * scale;
  								}
  								if (!weighted) {
  									for (var v = 0, vn = deform.length; v < vn; v++)
  										deform[v] += vertices[v];
  								}
  							}
  							timeline.setFrame(frameIndex, time, deform);
  							if (frameIndex < frameCount - 1)
  								this.readCurve(input, frameIndex, timeline);
  						}
  						timelines.push(timeline);
  						duration = Math.max(duration, timeline.frames[frameCount - 1]);
  					}
  				}
  			}
  			var drawOrderCount = input.readInt(true);
  			if (drawOrderCount > 0) {
  				var timeline = new spine.DrawOrderTimeline(drawOrderCount);
  				var slotCount = skeletonData.slots.length;
  				for (var i = 0; i < drawOrderCount; i++) {
  					var time = input.readFloat();
  					var offsetCount = input.readInt(true);
  					var drawOrder = spine.Utils.newArray(slotCount, 0);
  					for (var ii = slotCount - 1; ii >= 0; ii--)
  						drawOrder[ii] = -1;
  					var unchanged = spine.Utils.newArray(slotCount - offsetCount, 0);
  					var originalIndex = 0, unchangedIndex = 0;
  					for (var ii = 0; ii < offsetCount; ii++) {
  						var slotIndex = input.readInt(true);
  						while (originalIndex != slotIndex)
  							unchanged[unchangedIndex++] = originalIndex++;
  						drawOrder[originalIndex + input.readInt(true)] = originalIndex++;
  					}
  					while (originalIndex < slotCount)
  						unchanged[unchangedIndex++] = originalIndex++;
  					for (var ii = slotCount - 1; ii >= 0; ii--)
  						if (drawOrder[ii] == -1)
  							drawOrder[ii] = unchanged[--unchangedIndex];
  					timeline.setFrame(i, time, drawOrder);
  				}
  				timelines.push(timeline);
  				duration = Math.max(duration, timeline.frames[drawOrderCount - 1]);
  			}
  			var eventCount = input.readInt(true);
  			if (eventCount > 0) {
  				var timeline = new spine.EventTimeline(eventCount);
  				for (var i = 0; i < eventCount; i++) {
  					var time = input.readFloat();
  					var eventData = skeletonData.events[input.readInt(true)];
  					var event_4 = new spine.Event(time, eventData);
  					event_4.intValue = input.readInt(false);
  					event_4.floatValue = input.readFloat();
  					event_4.stringValue = input.readBoolean() ? input.readString() : eventData.stringValue;
  					if (event_4.data.audioPath != null) {
  						event_4.volume = input.readFloat();
  						event_4.balance = input.readFloat();
  					}
  					timeline.setFrame(i, event_4);
  				}
  				timelines.push(timeline);
  				duration = Math.max(duration, timeline.frames[eventCount - 1]);
  			}
  			return new spine.Animation(name, timelines, duration);
  		};
  		SkeletonBinary.prototype.readCurve = function (input, frameIndex, timeline) {
  			switch (input.readByte()) {
  				case SkeletonBinary.CURVE_STEPPED:
  					timeline.setStepped(frameIndex);
  					break;
  				case SkeletonBinary.CURVE_BEZIER:
  					this.setCurve(timeline, frameIndex, input.readFloat(), input.readFloat(), input.readFloat(), input.readFloat());
  					break;
  			}
  		};
  		SkeletonBinary.prototype.setCurve = function (timeline, frameIndex, cx1, cy1, cx2, cy2) {
  			timeline.setCurve(frameIndex, cx1, cy1, cx2, cy2);
  		};
  		SkeletonBinary.AttachmentTypeValues = [0, 1, 2, 3, 4, 5, 6];
  		SkeletonBinary.TransformModeValues = [spine.TransformMode.Normal, spine.TransformMode.OnlyTranslation, spine.TransformMode.NoRotationOrReflection, spine.TransformMode.NoScale, spine.TransformMode.NoScaleOrReflection];
  		SkeletonBinary.PositionModeValues = [spine.PositionMode.Fixed, spine.PositionMode.Percent];
  		SkeletonBinary.SpacingModeValues = [spine.SpacingMode.Length, spine.SpacingMode.Fixed, spine.SpacingMode.Percent];
  		SkeletonBinary.RotateModeValues = [spine.RotateMode.Tangent, spine.RotateMode.Chain, spine.RotateMode.ChainScale];
  		SkeletonBinary.BlendModeValues = [spine.BlendMode.Normal, spine.BlendMode.Additive, spine.BlendMode.Multiply, spine.BlendMode.Screen];
  		SkeletonBinary.BONE_ROTATE = 0;
  		SkeletonBinary.BONE_TRANSLATE = 1;
  		SkeletonBinary.BONE_SCALE = 2;
  		SkeletonBinary.BONE_SHEAR = 3;
  		SkeletonBinary.SLOT_ATTACHMENT = 0;
  		SkeletonBinary.SLOT_COLOR = 1;
  		SkeletonBinary.SLOT_TWO_COLOR = 2;
  		SkeletonBinary.PATH_POSITION = 0;
  		SkeletonBinary.PATH_SPACING = 1;
  		SkeletonBinary.PATH_MIX = 2;
  		SkeletonBinary.CURVE_LINEAR = 0;
  		SkeletonBinary.CURVE_STEPPED = 1;
  		SkeletonBinary.CURVE_BEZIER = 2;
  		return SkeletonBinary;
  	}());
  	spine.SkeletonBinary = SkeletonBinary;
  	var BinaryInput = (function () {
  		function BinaryInput(data, strings, index, buffer) {
  			if (strings === void 0) { strings = new Array(); }
  			if (index === void 0) { index = 0; }
  			if (buffer === void 0) { buffer = new DataView(data.buffer); }
  			this.strings = strings;
  			this.index = index;
  			this.buffer = buffer;
  		}
  		BinaryInput.prototype.readByte = function () {
  			return this.buffer.getInt8(this.index++);
  		};
  		BinaryInput.prototype.readShort = function () {
  			var value = this.buffer.getInt16(this.index);
  			this.index += 2;
  			return value;
  		};
  		BinaryInput.prototype.readInt32 = function () {
  			var value = this.buffer.getInt32(this.index);
  			this.index += 4;
  			return value;
  		};
  		BinaryInput.prototype.readInt = function (optimizePositive) {
  			var b = this.readByte();
  			var result = b & 0x7F;
  			if ((b & 0x80) != 0) {
  				b = this.readByte();
  				result |= (b & 0x7F) << 7;
  				if ((b & 0x80) != 0) {
  					b = this.readByte();
  					result |= (b & 0x7F) << 14;
  					if ((b & 0x80) != 0) {
  						b = this.readByte();
  						result |= (b & 0x7F) << 21;
  						if ((b & 0x80) != 0) {
  							b = this.readByte();
  							result |= (b & 0x7F) << 28;
  						}
  					}
  				}
  			}
  			return optimizePositive ? result : ((result >>> 1) ^ -(result & 1));
  		};
  		BinaryInput.prototype.readStringRef = function () {
  			var index = this.readInt(true);
  			return index == 0 ? null : this.strings[index - 1];
  		};
  		BinaryInput.prototype.readString = function () {
  			var byteCount = this.readInt(true);
  			switch (byteCount) {
  				case 0:
  					return null;
  				case 1:
  					return "";
  			}
  			byteCount--;
  			var chars = "";
  			var charCount = 0;
  			for (var i = 0; i < byteCount;) {
  				var b = this.readByte();
  				switch (b >> 4) {
  					case 12:
  					case 13:
  						chars += String.fromCharCode(((b & 0x1F) << 6 | this.readByte() & 0x3F));
  						i += 2;
  						break;
  					case 14:
  						chars += String.fromCharCode(((b & 0x0F) << 12 | (this.readByte() & 0x3F) << 6 | this.readByte() & 0x3F));
  						i += 3;
  						break;
  					default:
  						chars += String.fromCharCode(b);
  						i++;
  				}
  			}
  			return chars;
  		};
  		BinaryInput.prototype.readFloat = function () {
  			var value = this.buffer.getFloat32(this.index);
  			this.index += 4;
  			return value;
  		};
  		BinaryInput.prototype.readBoolean = function () {
  			return this.readByte() != 0;
  		};
  		return BinaryInput;
  	}());
  	var LinkedMesh = (function () {
  		function LinkedMesh(mesh, skin, slotIndex, parent, inheritDeform) {
  			this.mesh = mesh;
  			this.skin = skin;
  			this.slotIndex = slotIndex;
  			this.parent = parent;
  			this.inheritDeform = inheritDeform;
  		}
  		return LinkedMesh;
  	}());
  	var Vertices = (function () {
  		function Vertices(bones, vertices) {
  			if (bones === void 0) { bones = null; }
  			if (vertices === void 0) { vertices = null; }
  			this.bones = bones;
  			this.vertices = vertices;
  		}
  		return Vertices;
  	}());
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var SkeletonBounds = (function () {
  		function SkeletonBounds() {
  			this.minX = 0;
  			this.minY = 0;
  			this.maxX = 0;
  			this.maxY = 0;
  			this.boundingBoxes = new Array();
  			this.polygons = new Array();
  			this.polygonPool = new spine.Pool(function () {
  				return spine.Utils.newFloatArray(16);
  			});
  		}
  		SkeletonBounds.prototype.update = function (skeleton, updateAabb) {
  			if (skeleton == null)
  				throw new Error("skeleton cannot be null.");
  			var boundingBoxes = this.boundingBoxes;
  			var polygons = this.polygons;
  			var polygonPool = this.polygonPool;
  			var slots = skeleton.slots;
  			var slotCount = slots.length;
  			boundingBoxes.length = 0;
  			polygonPool.freeAll(polygons);
  			polygons.length = 0;
  			for (var i = 0; i < slotCount; i++) {
  				var slot = slots[i];
  				if (!slot.bone.active)
  					continue;
  				var attachment = slot.getAttachment();
  				if (attachment instanceof spine.BoundingBoxAttachment) {
  					var boundingBox = attachment;
  					boundingBoxes.push(boundingBox);
  					var polygon = polygonPool.obtain();
  					if (polygon.length != boundingBox.worldVerticesLength) {
  						polygon = spine.Utils.newFloatArray(boundingBox.worldVerticesLength);
  					}
  					polygons.push(polygon);
  					boundingBox.computeWorldVertices(slot, 0, boundingBox.worldVerticesLength, polygon, 0, 2);
  				}
  			}
  			if (updateAabb) {
  				this.aabbCompute();
  			}
  			else {
  				this.minX = Number.POSITIVE_INFINITY;
  				this.minY = Number.POSITIVE_INFINITY;
  				this.maxX = Number.NEGATIVE_INFINITY;
  				this.maxY = Number.NEGATIVE_INFINITY;
  			}
  		};
  		SkeletonBounds.prototype.aabbCompute = function () {
  			var minX = Number.POSITIVE_INFINITY, minY = Number.POSITIVE_INFINITY, maxX = Number.NEGATIVE_INFINITY, maxY = Number.NEGATIVE_INFINITY;
  			var polygons = this.polygons;
  			for (var i = 0, n = polygons.length; i < n; i++) {
  				var polygon = polygons[i];
  				var vertices = polygon;
  				for (var ii = 0, nn = polygon.length; ii < nn; ii += 2) {
  					var x = vertices[ii];
  					var y = vertices[ii + 1];
  					minX = Math.min(minX, x);
  					minY = Math.min(minY, y);
  					maxX = Math.max(maxX, x);
  					maxY = Math.max(maxY, y);
  				}
  			}
  			this.minX = minX;
  			this.minY = minY;
  			this.maxX = maxX;
  			this.maxY = maxY;
  		};
  		SkeletonBounds.prototype.aabbContainsPoint = function (x, y) {
  			return x >= this.minX && x <= this.maxX && y >= this.minY && y <= this.maxY;
  		};
  		SkeletonBounds.prototype.aabbIntersectsSegment = function (x1, y1, x2, y2) {
  			var minX = this.minX;
  			var minY = this.minY;
  			var maxX = this.maxX;
  			var maxY = this.maxY;
  			if ((x1 <= minX && x2 <= minX) || (y1 <= minY && y2 <= minY) || (x1 >= maxX && x2 >= maxX) || (y1 >= maxY && y2 >= maxY))
  				return false;
  			var m = (y2 - y1) / (x2 - x1);
  			var y = m * (minX - x1) + y1;
  			if (y > minY && y < maxY)
  				return true;
  			y = m * (maxX - x1) + y1;
  			if (y > minY && y < maxY)
  				return true;
  			var x = (minY - y1) / m + x1;
  			if (x > minX && x < maxX)
  				return true;
  			x = (maxY - y1) / m + x1;
  			if (x > minX && x < maxX)
  				return true;
  			return false;
  		};
  		SkeletonBounds.prototype.aabbIntersectsSkeleton = function (bounds) {
  			return this.minX < bounds.maxX && this.maxX > bounds.minX && this.minY < bounds.maxY && this.maxY > bounds.minY;
  		};
  		SkeletonBounds.prototype.containsPoint = function (x, y) {
  			var polygons = this.polygons;
  			for (var i = 0, n = polygons.length; i < n; i++)
  				if (this.containsPointPolygon(polygons[i], x, y))
  					return this.boundingBoxes[i];
  			return null;
  		};
  		SkeletonBounds.prototype.containsPointPolygon = function (polygon, x, y) {
  			var vertices = polygon;
  			var nn = polygon.length;
  			var prevIndex = nn - 2;
  			var inside = false;
  			for (var ii = 0; ii < nn; ii += 2) {
  				var vertexY = vertices[ii + 1];
  				var prevY = vertices[prevIndex + 1];
  				if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {
  					var vertexX = vertices[ii];
  					if (vertexX + (y - vertexY) / (prevY - vertexY) * (vertices[prevIndex] - vertexX) < x)
  						inside = !inside;
  				}
  				prevIndex = ii;
  			}
  			return inside;
  		};
  		SkeletonBounds.prototype.intersectsSegment = function (x1, y1, x2, y2) {
  			var polygons = this.polygons;
  			for (var i = 0, n = polygons.length; i < n; i++)
  				if (this.intersectsSegmentPolygon(polygons[i], x1, y1, x2, y2))
  					return this.boundingBoxes[i];
  			return null;
  		};
  		SkeletonBounds.prototype.intersectsSegmentPolygon = function (polygon, x1, y1, x2, y2) {
  			var vertices = polygon;
  			var nn = polygon.length;
  			var width12 = x1 - x2, height12 = y1 - y2;
  			var det1 = x1 * y2 - y1 * x2;
  			var x3 = vertices[nn - 2], y3 = vertices[nn - 1];
  			for (var ii = 0; ii < nn; ii += 2) {
  				var x4 = vertices[ii], y4 = vertices[ii + 1];
  				var det2 = x3 * y4 - y3 * x4;
  				var width34 = x3 - x4, height34 = y3 - y4;
  				var det3 = width12 * height34 - height12 * width34;
  				var x = (det1 * width34 - width12 * det2) / det3;
  				if (((x >= x3 && x <= x4) || (x >= x4 && x <= x3)) && ((x >= x1 && x <= x2) || (x >= x2 && x <= x1))) {
  					var y = (det1 * height34 - height12 * det2) / det3;
  					if (((y >= y3 && y <= y4) || (y >= y4 && y <= y3)) && ((y >= y1 && y <= y2) || (y >= y2 && y <= y1)))
  						return true;
  				}
  				x3 = x4;
  				y3 = y4;
  			}
  			return false;
  		};
  		SkeletonBounds.prototype.getPolygon = function (boundingBox) {
  			if (boundingBox == null)
  				throw new Error("boundingBox cannot be null.");
  			var index = this.boundingBoxes.indexOf(boundingBox);
  			return index == -1 ? null : this.polygons[index];
  		};
  		SkeletonBounds.prototype.getWidth = function () {
  			return this.maxX - this.minX;
  		};
  		SkeletonBounds.prototype.getHeight = function () {
  			return this.maxY - this.minY;
  		};
  		return SkeletonBounds;
  	}());
  	spine.SkeletonBounds = SkeletonBounds;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var SkeletonClipping = (function () {
  		function SkeletonClipping() {
  			this.triangulator = new spine.Triangulator();
  			this.clippingPolygon = new Array();
  			this.clipOutput = new Array();
  			this.clippedVertices = new Array();
  			this.clippedTriangles = new Array();
  			this.scratch = new Array();
  		}
  		SkeletonClipping.prototype.clipStart = function (slot, clip) {
  			if (this.clipAttachment != null)
  				return 0;
  			this.clipAttachment = clip;
  			var n = clip.worldVerticesLength;
  			var vertices = spine.Utils.setArraySize(this.clippingPolygon, n);
  			clip.computeWorldVertices(slot, 0, n, vertices, 0, 2);
  			var clippingPolygon = this.clippingPolygon;
  			SkeletonClipping.makeClockwise(clippingPolygon);
  			var clippingPolygons = this.clippingPolygons = this.triangulator.decompose(clippingPolygon, this.triangulator.triangulate(clippingPolygon));
  			for (var i = 0, n_2 = clippingPolygons.length; i < n_2; i++) {
  				var polygon = clippingPolygons[i];
  				SkeletonClipping.makeClockwise(polygon);
  				polygon.push(polygon[0]);
  				polygon.push(polygon[1]);
  			}
  			return clippingPolygons.length;
  		};
  		SkeletonClipping.prototype.clipEndWithSlot = function (slot) {
  			if (this.clipAttachment != null && this.clipAttachment.endSlot == slot.data)
  				this.clipEnd();
  		};
  		SkeletonClipping.prototype.clipEnd = function () {
  			if (this.clipAttachment == null)
  				return;
  			this.clipAttachment = null;
  			this.clippingPolygons = null;
  			this.clippedVertices.length = 0;
  			this.clippedTriangles.length = 0;
  			this.clippingPolygon.length = 0;
  		};
  		SkeletonClipping.prototype.isClipping = function () {
  			return this.clipAttachment != null;
  		};
  		SkeletonClipping.prototype.clipTriangles = function (vertices, verticesLength, triangles, trianglesLength, uvs, light, dark, twoColor) {
  			var clipOutput = this.clipOutput, clippedVertices = this.clippedVertices;
  			var clippedTriangles = this.clippedTriangles;
  			var polygons = this.clippingPolygons;
  			var polygonsCount = this.clippingPolygons.length;
  			var vertexSize = twoColor ? 12 : 8;
  			var index = 0;
  			clippedVertices.length = 0;
  			clippedTriangles.length = 0;
  			outer: for (var i = 0; i < trianglesLength; i += 3) {
  				var vertexOffset = triangles[i] << 1;
  				var x1 = vertices[vertexOffset], y1 = vertices[vertexOffset + 1];
  				var u1 = uvs[vertexOffset], v1 = uvs[vertexOffset + 1];
  				vertexOffset = triangles[i + 1] << 1;
  				var x2 = vertices[vertexOffset], y2 = vertices[vertexOffset + 1];
  				var u2 = uvs[vertexOffset], v2 = uvs[vertexOffset + 1];
  				vertexOffset = triangles[i + 2] << 1;
  				var x3 = vertices[vertexOffset], y3 = vertices[vertexOffset + 1];
  				var u3 = uvs[vertexOffset], v3 = uvs[vertexOffset + 1];
  				for (var p = 0; p < polygonsCount; p++) {
  					var s = clippedVertices.length;
  					if (this.clip(x1, y1, x2, y2, x3, y3, polygons[p], clipOutput)) {
  						var clipOutputLength = clipOutput.length;
  						if (clipOutputLength == 0)
  							continue;
  						var d0 = y2 - y3, d1 = x3 - x2, d2 = x1 - x3, d4 = y3 - y1;
  						var d = 1 / (d0 * d2 + d1 * (y1 - y3));
  						var clipOutputCount = clipOutputLength >> 1;
  						var clipOutputItems = this.clipOutput;
  						var clippedVerticesItems = spine.Utils.setArraySize(clippedVertices, s + clipOutputCount * vertexSize);
  						for (var ii = 0; ii < clipOutputLength; ii += 2) {
  							var x = clipOutputItems[ii], y = clipOutputItems[ii + 1];
  							clippedVerticesItems[s] = x;
  							clippedVerticesItems[s + 1] = y;
  							clippedVerticesItems[s + 2] = light.r;
  							clippedVerticesItems[s + 3] = light.g;
  							clippedVerticesItems[s + 4] = light.b;
  							clippedVerticesItems[s + 5] = light.a;
  							var c0 = x - x3, c1 = y - y3;
  							var a = (d0 * c0 + d1 * c1) * d;
  							var b = (d4 * c0 + d2 * c1) * d;
  							var c = 1 - a - b;
  							clippedVerticesItems[s + 6] = u1 * a + u2 * b + u3 * c;
  							clippedVerticesItems[s + 7] = v1 * a + v2 * b + v3 * c;
  							if (twoColor) {
  								clippedVerticesItems[s + 8] = dark.r;
  								clippedVerticesItems[s + 9] = dark.g;
  								clippedVerticesItems[s + 10] = dark.b;
  								clippedVerticesItems[s + 11] = dark.a;
  							}
  							s += vertexSize;
  						}
  						s = clippedTriangles.length;
  						var clippedTrianglesItems = spine.Utils.setArraySize(clippedTriangles, s + 3 * (clipOutputCount - 2));
  						clipOutputCount--;
  						for (var ii = 1; ii < clipOutputCount; ii++) {
  							clippedTrianglesItems[s] = index;
  							clippedTrianglesItems[s + 1] = (index + ii);
  							clippedTrianglesItems[s + 2] = (index + ii + 1);
  							s += 3;
  						}
  						index += clipOutputCount + 1;
  					}
  					else {
  						var clippedVerticesItems = spine.Utils.setArraySize(clippedVertices, s + 3 * vertexSize);
  						clippedVerticesItems[s] = x1;
  						clippedVerticesItems[s + 1] = y1;
  						clippedVerticesItems[s + 2] = light.r;
  						clippedVerticesItems[s + 3] = light.g;
  						clippedVerticesItems[s + 4] = light.b;
  						clippedVerticesItems[s + 5] = light.a;
  						if (!twoColor) {
  							clippedVerticesItems[s + 6] = u1;
  							clippedVerticesItems[s + 7] = v1;
  							clippedVerticesItems[s + 8] = x2;
  							clippedVerticesItems[s + 9] = y2;
  							clippedVerticesItems[s + 10] = light.r;
  							clippedVerticesItems[s + 11] = light.g;
  							clippedVerticesItems[s + 12] = light.b;
  							clippedVerticesItems[s + 13] = light.a;
  							clippedVerticesItems[s + 14] = u2;
  							clippedVerticesItems[s + 15] = v2;
  							clippedVerticesItems[s + 16] = x3;
  							clippedVerticesItems[s + 17] = y3;
  							clippedVerticesItems[s + 18] = light.r;
  							clippedVerticesItems[s + 19] = light.g;
  							clippedVerticesItems[s + 20] = light.b;
  							clippedVerticesItems[s + 21] = light.a;
  							clippedVerticesItems[s + 22] = u3;
  							clippedVerticesItems[s + 23] = v3;
  						}
  						else {
  							clippedVerticesItems[s + 6] = u1;
  							clippedVerticesItems[s + 7] = v1;
  							clippedVerticesItems[s + 8] = dark.r;
  							clippedVerticesItems[s + 9] = dark.g;
  							clippedVerticesItems[s + 10] = dark.b;
  							clippedVerticesItems[s + 11] = dark.a;
  							clippedVerticesItems[s + 12] = x2;
  							clippedVerticesItems[s + 13] = y2;
  							clippedVerticesItems[s + 14] = light.r;
  							clippedVerticesItems[s + 15] = light.g;
  							clippedVerticesItems[s + 16] = light.b;
  							clippedVerticesItems[s + 17] = light.a;
  							clippedVerticesItems[s + 18] = u2;
  							clippedVerticesItems[s + 19] = v2;
  							clippedVerticesItems[s + 20] = dark.r;
  							clippedVerticesItems[s + 21] = dark.g;
  							clippedVerticesItems[s + 22] = dark.b;
  							clippedVerticesItems[s + 23] = dark.a;
  							clippedVerticesItems[s + 24] = x3;
  							clippedVerticesItems[s + 25] = y3;
  							clippedVerticesItems[s + 26] = light.r;
  							clippedVerticesItems[s + 27] = light.g;
  							clippedVerticesItems[s + 28] = light.b;
  							clippedVerticesItems[s + 29] = light.a;
  							clippedVerticesItems[s + 30] = u3;
  							clippedVerticesItems[s + 31] = v3;
  							clippedVerticesItems[s + 32] = dark.r;
  							clippedVerticesItems[s + 33] = dark.g;
  							clippedVerticesItems[s + 34] = dark.b;
  							clippedVerticesItems[s + 35] = dark.a;
  						}
  						s = clippedTriangles.length;
  						var clippedTrianglesItems = spine.Utils.setArraySize(clippedTriangles, s + 3);
  						clippedTrianglesItems[s] = index;
  						clippedTrianglesItems[s + 1] = (index + 1);
  						clippedTrianglesItems[s + 2] = (index + 2);
  						index += 3;
  						continue outer;
  					}
  				}
  			}
  		};
  		SkeletonClipping.prototype.clip = function (x1, y1, x2, y2, x3, y3, clippingArea, output) {
  			var originalOutput = output;
  			var clipped = false;
  			var input = null;
  			if (clippingArea.length % 4 >= 2) {
  				input = output;
  				output = this.scratch;
  			}
  			else
  				input = this.scratch;
  			input.length = 0;
  			input.push(x1);
  			input.push(y1);
  			input.push(x2);
  			input.push(y2);
  			input.push(x3);
  			input.push(y3);
  			input.push(x1);
  			input.push(y1);
  			output.length = 0;
  			var clippingVertices = clippingArea;
  			var clippingVerticesLast = clippingArea.length - 4;
  			for (var i = 0;; i += 2) {
  				var edgeX = clippingVertices[i], edgeY = clippingVertices[i + 1];
  				var edgeX2 = clippingVertices[i + 2], edgeY2 = clippingVertices[i + 3];
  				var deltaX = edgeX - edgeX2, deltaY = edgeY - edgeY2;
  				var inputVertices = input;
  				var inputVerticesLength = input.length - 2, outputStart = output.length;
  				for (var ii = 0; ii < inputVerticesLength; ii += 2) {
  					var inputX = inputVertices[ii], inputY = inputVertices[ii + 1];
  					var inputX2 = inputVertices[ii + 2], inputY2 = inputVertices[ii + 3];
  					var side2 = deltaX * (inputY2 - edgeY2) - deltaY * (inputX2 - edgeX2) > 0;
  					if (deltaX * (inputY - edgeY2) - deltaY * (inputX - edgeX2) > 0) {
  						if (side2) {
  							output.push(inputX2);
  							output.push(inputY2);
  							continue;
  						}
  						var c0 = inputY2 - inputY, c2 = inputX2 - inputX;
  						var s = c0 * (edgeX2 - edgeX) - c2 * (edgeY2 - edgeY);
  						if (Math.abs(s) > 0.000001) {
  							var ua = (c2 * (edgeY - inputY) - c0 * (edgeX - inputX)) / s;
  							output.push(edgeX + (edgeX2 - edgeX) * ua);
  							output.push(edgeY + (edgeY2 - edgeY) * ua);
  						}
  						else {
  							output.push(edgeX);
  							output.push(edgeY);
  						}
  					}
  					else if (side2) {
  						var c0 = inputY2 - inputY, c2 = inputX2 - inputX;
  						var s = c0 * (edgeX2 - edgeX) - c2 * (edgeY2 - edgeY);
  						if (Math.abs(s) > 0.000001) {
  							var ua = (c2 * (edgeY - inputY) - c0 * (edgeX - inputX)) / s;
  							output.push(edgeX + (edgeX2 - edgeX) * ua);
  							output.push(edgeY + (edgeY2 - edgeY) * ua);
  						}
  						else {
  							output.push(edgeX);
  							output.push(edgeY);
  						}
  						output.push(inputX2);
  						output.push(inputY2);
  					}
  					clipped = true;
  				}
  				if (outputStart == output.length) {
  					originalOutput.length = 0;
  					return true;
  				}
  				output.push(output[0]);
  				output.push(output[1]);
  				if (i == clippingVerticesLast)
  					break;
  				var temp = output;
  				output = input;
  				output.length = 0;
  				input = temp;
  			}
  			if (originalOutput != output) {
  				originalOutput.length = 0;
  				for (var i = 0, n = output.length - 2; i < n; i++)
  					originalOutput[i] = output[i];
  			}
  			else
  				originalOutput.length = originalOutput.length - 2;
  			return clipped;
  		};
  		SkeletonClipping.makeClockwise = function (polygon) {
  			var vertices = polygon;
  			var verticeslength = polygon.length;
  			var area = vertices[verticeslength - 2] * vertices[1] - vertices[0] * vertices[verticeslength - 1], p1x = 0, p1y = 0, p2x = 0, p2y = 0;
  			for (var i = 0, n = verticeslength - 3; i < n; i += 2) {
  				p1x = vertices[i];
  				p1y = vertices[i + 1];
  				p2x = vertices[i + 2];
  				p2y = vertices[i + 3];
  				area += p1x * p2y - p2x * p1y;
  			}
  			if (area < 0)
  				return;
  			for (var i = 0, lastX = verticeslength - 2, n = verticeslength >> 1; i < n; i += 2) {
  				var x = vertices[i], y = vertices[i + 1];
  				var other = lastX - i;
  				vertices[i] = vertices[other];
  				vertices[i + 1] = vertices[other + 1];
  				vertices[other] = x;
  				vertices[other + 1] = y;
  			}
  		};
  		return SkeletonClipping;
  	}());
  	spine.SkeletonClipping = SkeletonClipping;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var SkeletonData = (function () {
  		function SkeletonData() {
  			this.bones = new Array();
  			this.slots = new Array();
  			this.skins = new Array();
  			this.events = new Array();
  			this.animations = new Array();
  			this.ikConstraints = new Array();
  			this.transformConstraints = new Array();
  			this.pathConstraints = new Array();
  			this.fps = 0;
  		}
  		SkeletonData.prototype.findBone = function (boneName) {
  			if (boneName == null)
  				throw new Error("boneName cannot be null.");
  			var bones = this.bones;
  			for (var i = 0, n = bones.length; i < n; i++) {
  				var bone = bones[i];
  				if (bone.name == boneName)
  					return bone;
  			}
  			return null;
  		};
  		SkeletonData.prototype.findBoneIndex = function (boneName) {
  			if (boneName == null)
  				throw new Error("boneName cannot be null.");
  			var bones = this.bones;
  			for (var i = 0, n = bones.length; i < n; i++)
  				if (bones[i].name == boneName)
  					return i;
  			return -1;
  		};
  		SkeletonData.prototype.findSlot = function (slotName) {
  			if (slotName == null)
  				throw new Error("slotName cannot be null.");
  			var slots = this.slots;
  			for (var i = 0, n = slots.length; i < n; i++) {
  				var slot = slots[i];
  				if (slot.name == slotName)
  					return slot;
  			}
  			return null;
  		};
  		SkeletonData.prototype.findSlotIndex = function (slotName) {
  			if (slotName == null)
  				throw new Error("slotName cannot be null.");
  			var slots = this.slots;
  			for (var i = 0, n = slots.length; i < n; i++)
  				if (slots[i].name == slotName)
  					return i;
  			return -1;
  		};
  		SkeletonData.prototype.findSkin = function (skinName) {
  			if (skinName == null)
  				throw new Error("skinName cannot be null.");
  			var skins = this.skins;
  			for (var i = 0, n = skins.length; i < n; i++) {
  				var skin = skins[i];
  				if (skin.name == skinName)
  					return skin;
  			}
  			return null;
  		};
  		SkeletonData.prototype.findEvent = function (eventDataName) {
  			if (eventDataName == null)
  				throw new Error("eventDataName cannot be null.");
  			var events = this.events;
  			for (var i = 0, n = events.length; i < n; i++) {
  				var event_5 = events[i];
  				if (event_5.name == eventDataName)
  					return event_5;
  			}
  			return null;
  		};
  		SkeletonData.prototype.findAnimation = function (animationName) {
  			if (animationName == null)
  				throw new Error("animationName cannot be null.");
  			var animations = this.animations;
  			for (var i = 0, n = animations.length; i < n; i++) {
  				var animation = animations[i];
  				if (animation.name == animationName)
  					return animation;
  			}
  			return null;
  		};
  		SkeletonData.prototype.findIkConstraint = function (constraintName) {
  			if (constraintName == null)
  				throw new Error("constraintName cannot be null.");
  			var ikConstraints = this.ikConstraints;
  			for (var i = 0, n = ikConstraints.length; i < n; i++) {
  				var constraint = ikConstraints[i];
  				if (constraint.name == constraintName)
  					return constraint;
  			}
  			return null;
  		};
  		SkeletonData.prototype.findTransformConstraint = function (constraintName) {
  			if (constraintName == null)
  				throw new Error("constraintName cannot be null.");
  			var transformConstraints = this.transformConstraints;
  			for (var i = 0, n = transformConstraints.length; i < n; i++) {
  				var constraint = transformConstraints[i];
  				if (constraint.name == constraintName)
  					return constraint;
  			}
  			return null;
  		};
  		SkeletonData.prototype.findPathConstraint = function (constraintName) {
  			if (constraintName == null)
  				throw new Error("constraintName cannot be null.");
  			var pathConstraints = this.pathConstraints;
  			for (var i = 0, n = pathConstraints.length; i < n; i++) {
  				var constraint = pathConstraints[i];
  				if (constraint.name == constraintName)
  					return constraint;
  			}
  			return null;
  		};
  		SkeletonData.prototype.findPathConstraintIndex = function (pathConstraintName) {
  			if (pathConstraintName == null)
  				throw new Error("pathConstraintName cannot be null.");
  			var pathConstraints = this.pathConstraints;
  			for (var i = 0, n = pathConstraints.length; i < n; i++)
  				if (pathConstraints[i].name == pathConstraintName)
  					return i;
  			return -1;
  		};
  		return SkeletonData;
  	}());
  	spine.SkeletonData = SkeletonData;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var SkeletonJson = (function () {
  		function SkeletonJson(attachmentLoader) {
  			this.scale = 1;
  			this.linkedMeshes = new Array();
  			this.attachmentLoader = attachmentLoader;
  		}
  		SkeletonJson.prototype.readSkeletonData = function (json) {
  			var scale = this.scale;
  			var skeletonData = new spine.SkeletonData();
  			var root = typeof (json) === "string" ? JSON.parse(json) : json;
  			var skeletonMap = root.skeleton;
  			if (skeletonMap != null) {
  				skeletonData.hash = skeletonMap.hash;
  				skeletonData.version = skeletonMap.spine;
  				if ("3.8.75" == skeletonData.version)
  					throw new Error("Unsupported skeleton data, please export with a newer version of Spine.");
  				skeletonData.x = skeletonMap.x;
  				skeletonData.y = skeletonMap.y;
  				skeletonData.width = skeletonMap.width;
  				skeletonData.height = skeletonMap.height;
  				skeletonData.fps = skeletonMap.fps;
  				skeletonData.imagesPath = skeletonMap.images;
  			}
  			if (root.bones) {
  				for (var i = 0; i < root.bones.length; i++) {
  					var boneMap = root.bones[i];
  					var parent_5 = null;
  					var parentName = this.getValue(boneMap, "parent", null);
  					if (parentName != null) {
  						parent_5 = skeletonData.findBone(parentName);
  						if (parent_5 == null)
  							throw new Error("Parent bone not found: " + parentName);
  					}
  					var data = new spine.BoneData(skeletonData.bones.length, boneMap.name, parent_5);
  					data.length = this.getValue(boneMap, "length", 0) * scale;
  					data.x = this.getValue(boneMap, "x", 0) * scale;
  					data.y = this.getValue(boneMap, "y", 0) * scale;
  					data.rotation = this.getValue(boneMap, "rotation", 0);
  					data.scaleX = this.getValue(boneMap, "scaleX", 1);
  					data.scaleY = this.getValue(boneMap, "scaleY", 1);
  					data.shearX = this.getValue(boneMap, "shearX", 0);
  					data.shearY = this.getValue(boneMap, "shearY", 0);
  					data.transformMode = SkeletonJson.transformModeFromString(this.getValue(boneMap, "transform", "normal"));
  					data.skinRequired = this.getValue(boneMap, "skin", false);
  					skeletonData.bones.push(data);
  				}
  			}
  			if (root.slots) {
  				for (var i = 0; i < root.slots.length; i++) {
  					var slotMap = root.slots[i];
  					var slotName = slotMap.name;
  					var boneName = slotMap.bone;
  					var boneData = skeletonData.findBone(boneName);
  					if (boneData == null)
  						throw new Error("Slot bone not found: " + boneName);
  					var data = new spine.SlotData(skeletonData.slots.length, slotName, boneData);
  					var color = this.getValue(slotMap, "color", null);
  					if (color != null)
  						data.color.setFromString(color);
  					var dark = this.getValue(slotMap, "dark", null);
  					if (dark != null) {
  						data.darkColor = new spine.Color(1, 1, 1, 1);
  						data.darkColor.setFromString(dark);
  					}
  					data.attachmentName = this.getValue(slotMap, "attachment", null);
  					data.blendMode = SkeletonJson.blendModeFromString(this.getValue(slotMap, "blend", "normal"));
  					skeletonData.slots.push(data);
  				}
  			}
  			if (root.ik) {
  				for (var i = 0; i < root.ik.length; i++) {
  					var constraintMap = root.ik[i];
  					var data = new spine.IkConstraintData(constraintMap.name);
  					data.order = this.getValue(constraintMap, "order", 0);
  					data.skinRequired = this.getValue(constraintMap, "skin", false);
  					for (var j = 0; j < constraintMap.bones.length; j++) {
  						var boneName = constraintMap.bones[j];
  						var bone = skeletonData.findBone(boneName);
  						if (bone == null)
  							throw new Error("IK bone not found: " + boneName);
  						data.bones.push(bone);
  					}
  					var targetName = constraintMap.target;
  					data.target = skeletonData.findBone(targetName);
  					if (data.target == null)
  						throw new Error("IK target bone not found: " + targetName);
  					data.mix = this.getValue(constraintMap, "mix", 1);
  					data.softness = this.getValue(constraintMap, "softness", 0) * scale;
  					data.bendDirection = this.getValue(constraintMap, "bendPositive", true) ? 1 : -1;
  					data.compress = this.getValue(constraintMap, "compress", false);
  					data.stretch = this.getValue(constraintMap, "stretch", false);
  					data.uniform = this.getValue(constraintMap, "uniform", false);
  					skeletonData.ikConstraints.push(data);
  				}
  			}
  			if (root.transform) {
  				for (var i = 0; i < root.transform.length; i++) {
  					var constraintMap = root.transform[i];
  					var data = new spine.TransformConstraintData(constraintMap.name);
  					data.order = this.getValue(constraintMap, "order", 0);
  					data.skinRequired = this.getValue(constraintMap, "skin", false);
  					for (var j = 0; j < constraintMap.bones.length; j++) {
  						var boneName = constraintMap.bones[j];
  						var bone = skeletonData.findBone(boneName);
  						if (bone == null)
  							throw new Error("Transform constraint bone not found: " + boneName);
  						data.bones.push(bone);
  					}
  					var targetName = constraintMap.target;
  					data.target = skeletonData.findBone(targetName);
  					if (data.target == null)
  						throw new Error("Transform constraint target bone not found: " + targetName);
  					data.local = this.getValue(constraintMap, "local", false);
  					data.relative = this.getValue(constraintMap, "relative", false);
  					data.offsetRotation = this.getValue(constraintMap, "rotation", 0);
  					data.offsetX = this.getValue(constraintMap, "x", 0) * scale;
  					data.offsetY = this.getValue(constraintMap, "y", 0) * scale;
  					data.offsetScaleX = this.getValue(constraintMap, "scaleX", 0);
  					data.offsetScaleY = this.getValue(constraintMap, "scaleY", 0);
  					data.offsetShearY = this.getValue(constraintMap, "shearY", 0);
  					data.rotateMix = this.getValue(constraintMap, "rotateMix", 1);
  					data.translateMix = this.getValue(constraintMap, "translateMix", 1);
  					data.scaleMix = this.getValue(constraintMap, "scaleMix", 1);
  					data.shearMix = this.getValue(constraintMap, "shearMix", 1);
  					skeletonData.transformConstraints.push(data);
  				}
  			}
  			if (root.path) {
  				for (var i = 0; i < root.path.length; i++) {
  					var constraintMap = root.path[i];
  					var data = new spine.PathConstraintData(constraintMap.name);
  					data.order = this.getValue(constraintMap, "order", 0);
  					data.skinRequired = this.getValue(constraintMap, "skin", false);
  					for (var j = 0; j < constraintMap.bones.length; j++) {
  						var boneName = constraintMap.bones[j];
  						var bone = skeletonData.findBone(boneName);
  						if (bone == null)
  							throw new Error("Transform constraint bone not found: " + boneName);
  						data.bones.push(bone);
  					}
  					var targetName = constraintMap.target;
  					data.target = skeletonData.findSlot(targetName);
  					if (data.target == null)
  						throw new Error("Path target slot not found: " + targetName);
  					data.positionMode = SkeletonJson.positionModeFromString(this.getValue(constraintMap, "positionMode", "percent"));
  					data.spacingMode = SkeletonJson.spacingModeFromString(this.getValue(constraintMap, "spacingMode", "length"));
  					data.rotateMode = SkeletonJson.rotateModeFromString(this.getValue(constraintMap, "rotateMode", "tangent"));
  					data.offsetRotation = this.getValue(constraintMap, "rotation", 0);
  					data.position = this.getValue(constraintMap, "position", 0);
  					if (data.positionMode == spine.PositionMode.Fixed)
  						data.position *= scale;
  					data.spacing = this.getValue(constraintMap, "spacing", 0);
  					if (data.spacingMode == spine.SpacingMode.Length || data.spacingMode == spine.SpacingMode.Fixed)
  						data.spacing *= scale;
  					data.rotateMix = this.getValue(constraintMap, "rotateMix", 1);
  					data.translateMix = this.getValue(constraintMap, "translateMix", 1);
  					skeletonData.pathConstraints.push(data);
  				}
  			}
  			if (root.skins) {
  				for (var i = 0; i < root.skins.length; i++) {
  					var skinMap = root.skins[i];
  					var skin = new spine.Skin(skinMap.name);
  					if (skinMap.bones) {
  						for (var ii = 0; ii < skinMap.bones.length; ii++) {
  							var bone = skeletonData.findBone(skinMap.bones[ii]);
  							if (bone == null)
  								throw new Error("Skin bone not found: " + skinMap.bones[i]);
  							skin.bones.push(bone);
  						}
  					}
  					if (skinMap.ik) {
  						for (var ii = 0; ii < skinMap.ik.length; ii++) {
  							var constraint = skeletonData.findIkConstraint(skinMap.ik[ii]);
  							if (constraint == null)
  								throw new Error("Skin IK constraint not found: " + skinMap.ik[i]);
  							skin.constraints.push(constraint);
  						}
  					}
  					if (skinMap.transform) {
  						for (var ii = 0; ii < skinMap.transform.length; ii++) {
  							var constraint = skeletonData.findTransformConstraint(skinMap.transform[ii]);
  							if (constraint == null)
  								throw new Error("Skin transform constraint not found: " + skinMap.transform[i]);
  							skin.constraints.push(constraint);
  						}
  					}
  					if (skinMap.path) {
  						for (var ii = 0; ii < skinMap.path.length; ii++) {
  							var constraint = skeletonData.findPathConstraint(skinMap.path[ii]);
  							if (constraint == null)
  								throw new Error("Skin path constraint not found: " + skinMap.path[i]);
  							skin.constraints.push(constraint);
  						}
  					}
  					for (var slotName in skinMap.attachments) {
  						var slot = skeletonData.findSlot(slotName);
  						if (slot == null)
  							throw new Error("Slot not found: " + slotName);
  						var slotMap = skinMap.attachments[slotName];
  						for (var entryName in slotMap) {
  							var attachment = this.readAttachment(slotMap[entryName], skin, slot.index, entryName, skeletonData);
  							if (attachment != null)
  								skin.setAttachment(slot.index, entryName, attachment);
  						}
  					}
  					skeletonData.skins.push(skin);
  					if (skin.name == "default")
  						skeletonData.defaultSkin = skin;
  				}
  			}
  			for (var i = 0, n = this.linkedMeshes.length; i < n; i++) {
  				var linkedMesh = this.linkedMeshes[i];
  				var skin = linkedMesh.skin == null ? skeletonData.defaultSkin : skeletonData.findSkin(linkedMesh.skin);
  				if (skin == null)
  					throw new Error("Skin not found: " + linkedMesh.skin);
  				var parent_6 = skin.getAttachment(linkedMesh.slotIndex, linkedMesh.parent);
  				if (parent_6 == null)
  					throw new Error("Parent mesh not found: " + linkedMesh.parent);
  				linkedMesh.mesh.deformAttachment = linkedMesh.inheritDeform ? parent_6 : linkedMesh.mesh;
  				linkedMesh.mesh.setParentMesh(parent_6);
  				linkedMesh.mesh.updateUVs();
  			}
  			this.linkedMeshes.length = 0;
  			if (root.events) {
  				for (var eventName in root.events) {
  					var eventMap = root.events[eventName];
  					var data = new spine.EventData(eventName);
  					data.intValue = this.getValue(eventMap, "int", 0);
  					data.floatValue = this.getValue(eventMap, "float", 0);
  					data.stringValue = this.getValue(eventMap, "string", "");
  					data.audioPath = this.getValue(eventMap, "audio", null);
  					if (data.audioPath != null) {
  						data.volume = this.getValue(eventMap, "volume", 1);
  						data.balance = this.getValue(eventMap, "balance", 0);
  					}
  					skeletonData.events.push(data);
  				}
  			}
  			if (root.animations) {
  				for (var animationName in root.animations) {
  					var animationMap = root.animations[animationName];
  					this.readAnimation(animationMap, animationName, skeletonData);
  				}
  			}
  			return skeletonData;
  		};
  		SkeletonJson.prototype.readAttachment = function (map, skin, slotIndex, name, skeletonData) {
  			var scale = this.scale;
  			name = this.getValue(map, "name", name);
  			var type = this.getValue(map, "type", "region");
  			switch (type) {
  				case "region": {
  					var path = this.getValue(map, "path", name);
  					var region = this.attachmentLoader.newRegionAttachment(skin, name, path);
  					if (region == null)
  						return null;
  					region.path = path;
  					region.x = this.getValue(map, "x", 0) * scale;
  					region.y = this.getValue(map, "y", 0) * scale;
  					region.scaleX = this.getValue(map, "scaleX", 1);
  					region.scaleY = this.getValue(map, "scaleY", 1);
  					region.rotation = this.getValue(map, "rotation", 0);
  					region.width = map.width * scale;
  					region.height = map.height * scale;
  					var color = this.getValue(map, "color", null);
  					if (color != null)
  						region.color.setFromString(color);
  					region.updateOffset();
  					return region;
  				}
  				case "boundingbox": {
  					var box = this.attachmentLoader.newBoundingBoxAttachment(skin, name);
  					if (box == null)
  						return null;
  					this.readVertices(map, box, map.vertexCount << 1);
  					var color = this.getValue(map, "color", null);
  					if (color != null)
  						box.color.setFromString(color);
  					return box;
  				}
  				case "mesh":
  				case "linkedmesh": {
  					var path = this.getValue(map, "path", name);
  					var mesh = this.attachmentLoader.newMeshAttachment(skin, name, path);
  					if (mesh == null)
  						return null;
  					mesh.path = path;
  					var color = this.getValue(map, "color", null);
  					if (color != null)
  						mesh.color.setFromString(color);
  					mesh.width = this.getValue(map, "width", 0) * scale;
  					mesh.height = this.getValue(map, "height", 0) * scale;
  					var parent_7 = this.getValue(map, "parent", null);
  					if (parent_7 != null) {
  						this.linkedMeshes.push(new LinkedMesh(mesh, this.getValue(map, "skin", null), slotIndex, parent_7, this.getValue(map, "deform", true)));
  						return mesh;
  					}
  					var uvs = map.uvs;
  					this.readVertices(map, mesh, uvs.length);
  					mesh.triangles = map.triangles;
  					mesh.regionUVs = uvs;
  					mesh.updateUVs();
  					mesh.edges = this.getValue(map, "edges", null);
  					mesh.hullLength = this.getValue(map, "hull", 0) * 2;
  					return mesh;
  				}
  				case "path": {
  					var path = this.attachmentLoader.newPathAttachment(skin, name);
  					if (path == null)
  						return null;
  					path.closed = this.getValue(map, "closed", false);
  					path.constantSpeed = this.getValue(map, "constantSpeed", true);
  					var vertexCount = map.vertexCount;
  					this.readVertices(map, path, vertexCount << 1);
  					var lengths = spine.Utils.newArray(vertexCount / 3, 0);
  					for (var i = 0; i < map.lengths.length; i++)
  						lengths[i] = map.lengths[i] * scale;
  					path.lengths = lengths;
  					var color = this.getValue(map, "color", null);
  					if (color != null)
  						path.color.setFromString(color);
  					return path;
  				}
  				case "point": {
  					var point = this.attachmentLoader.newPointAttachment(skin, name);
  					if (point == null)
  						return null;
  					point.x = this.getValue(map, "x", 0) * scale;
  					point.y = this.getValue(map, "y", 0) * scale;
  					point.rotation = this.getValue(map, "rotation", 0);
  					var color = this.getValue(map, "color", null);
  					if (color != null)
  						point.color.setFromString(color);
  					return point;
  				}
  				case "clipping": {
  					var clip = this.attachmentLoader.newClippingAttachment(skin, name);
  					if (clip == null)
  						return null;
  					var end = this.getValue(map, "end", null);
  					if (end != null) {
  						var slot = skeletonData.findSlot(end);
  						if (slot == null)
  							throw new Error("Clipping end slot not found: " + end);
  						clip.endSlot = slot;
  					}
  					var vertexCount = map.vertexCount;
  					this.readVertices(map, clip, vertexCount << 1);
  					var color = this.getValue(map, "color", null);
  					if (color != null)
  						clip.color.setFromString(color);
  					return clip;
  				}
  			}
  			return null;
  		};
  		SkeletonJson.prototype.readVertices = function (map, attachment, verticesLength) {
  			var scale = this.scale;
  			attachment.worldVerticesLength = verticesLength;
  			var vertices = map.vertices;
  			if (verticesLength == vertices.length) {
  				var scaledVertices = spine.Utils.toFloatArray(vertices);
  				if (scale != 1) {
  					for (var i = 0, n = vertices.length; i < n; i++)
  						scaledVertices[i] *= scale;
  				}
  				attachment.vertices = scaledVertices;
  				return;
  			}
  			var weights = new Array();
  			var bones = new Array();
  			for (var i = 0, n = vertices.length; i < n;) {
  				var boneCount = vertices[i++];
  				bones.push(boneCount);
  				for (var nn = i + boneCount * 4; i < nn; i += 4) {
  					bones.push(vertices[i]);
  					weights.push(vertices[i + 1] * scale);
  					weights.push(vertices[i + 2] * scale);
  					weights.push(vertices[i + 3]);
  				}
  			}
  			attachment.bones = bones;
  			attachment.vertices = spine.Utils.toFloatArray(weights);
  		};
  		SkeletonJson.prototype.readAnimation = function (map, name, skeletonData) {
  			var scale = this.scale;
  			var timelines = new Array();
  			var duration = 0;
  			if (map.slots) {
  				for (var slotName in map.slots) {
  					var slotMap = map.slots[slotName];
  					var slotIndex = skeletonData.findSlotIndex(slotName);
  					if (slotIndex == -1)
  						throw new Error("Slot not found: " + slotName);
  					for (var timelineName in slotMap) {
  						var timelineMap = slotMap[timelineName];
  						if (timelineName == "attachment") {
  							var timeline = new spine.AttachmentTimeline(timelineMap.length);
  							timeline.slotIndex = slotIndex;
  							var frameIndex = 0;
  							for (var i = 0; i < timelineMap.length; i++) {
  								var valueMap = timelineMap[i];
  								timeline.setFrame(frameIndex++, this.getValue(valueMap, "time", 0), valueMap.name);
  							}
  							timelines.push(timeline);
  							duration = Math.max(duration, timeline.frames[timeline.getFrameCount() - 1]);
  						}
  						else if (timelineName == "color") {
  							var timeline = new spine.ColorTimeline(timelineMap.length);
  							timeline.slotIndex = slotIndex;
  							var frameIndex = 0;
  							for (var i = 0; i < timelineMap.length; i++) {
  								var valueMap = timelineMap[i];
  								var color = new spine.Color();
  								color.setFromString(valueMap.color);
  								timeline.setFrame(frameIndex, this.getValue(valueMap, "time", 0), color.r, color.g, color.b, color.a);
  								this.readCurve(valueMap, timeline, frameIndex);
  								frameIndex++;
  							}
  							timelines.push(timeline);
  							duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.ColorTimeline.ENTRIES]);
  						}
  						else if (timelineName == "twoColor") {
  							var timeline = new spine.TwoColorTimeline(timelineMap.length);
  							timeline.slotIndex = slotIndex;
  							var frameIndex = 0;
  							for (var i = 0; i < timelineMap.length; i++) {
  								var valueMap = timelineMap[i];
  								var light = new spine.Color();
  								var dark = new spine.Color();
  								light.setFromString(valueMap.light);
  								dark.setFromString(valueMap.dark);
  								timeline.setFrame(frameIndex, this.getValue(valueMap, "time", 0), light.r, light.g, light.b, light.a, dark.r, dark.g, dark.b);
  								this.readCurve(valueMap, timeline, frameIndex);
  								frameIndex++;
  							}
  							timelines.push(timeline);
  							duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.TwoColorTimeline.ENTRIES]);
  						}
  						else
  							throw new Error("Invalid timeline type for a slot: " + timelineName + " (" + slotName + ")");
  					}
  				}
  			}
  			if (map.bones) {
  				for (var boneName in map.bones) {
  					var boneMap = map.bones[boneName];
  					var boneIndex = skeletonData.findBoneIndex(boneName);
  					if (boneIndex == -1)
  						throw new Error("Bone not found: " + boneName);
  					for (var timelineName in boneMap) {
  						var timelineMap = boneMap[timelineName];
  						if (timelineName === "rotate") {
  							var timeline = new spine.RotateTimeline(timelineMap.length);
  							timeline.boneIndex = boneIndex;
  							var frameIndex = 0;
  							for (var i = 0; i < timelineMap.length; i++) {
  								var valueMap = timelineMap[i];
  								timeline.setFrame(frameIndex, this.getValue(valueMap, "time", 0), this.getValue(valueMap, "angle", 0));
  								this.readCurve(valueMap, timeline, frameIndex);
  								frameIndex++;
  							}
  							timelines.push(timeline);
  							duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.RotateTimeline.ENTRIES]);
  						}
  						else if (timelineName === "translate" || timelineName === "scale" || timelineName === "shear") {
  							var timeline = null;
  							var timelineScale = 1, defaultValue = 0;
  							if (timelineName === "scale") {
  								timeline = new spine.ScaleTimeline(timelineMap.length);
  								defaultValue = 1;
  							}
  							else if (timelineName === "shear")
  								timeline = new spine.ShearTimeline(timelineMap.length);
  							else {
  								timeline = new spine.TranslateTimeline(timelineMap.length);
  								timelineScale = scale;
  							}
  							timeline.boneIndex = boneIndex;
  							var frameIndex = 0;
  							for (var i = 0; i < timelineMap.length; i++) {
  								var valueMap = timelineMap[i];
  								var x = this.getValue(valueMap, "x", defaultValue), y = this.getValue(valueMap, "y", defaultValue);
  								timeline.setFrame(frameIndex, this.getValue(valueMap, "time", 0), x * timelineScale, y * timelineScale);
  								this.readCurve(valueMap, timeline, frameIndex);
  								frameIndex++;
  							}
  							timelines.push(timeline);
  							duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.TranslateTimeline.ENTRIES]);
  						}
  						else
  							throw new Error("Invalid timeline type for a bone: " + timelineName + " (" + boneName + ")");
  					}
  				}
  			}
  			if (map.ik) {
  				for (var constraintName in map.ik) {
  					var constraintMap = map.ik[constraintName];
  					var constraint = skeletonData.findIkConstraint(constraintName);
  					var timeline = new spine.IkConstraintTimeline(constraintMap.length);
  					timeline.ikConstraintIndex = skeletonData.ikConstraints.indexOf(constraint);
  					var frameIndex = 0;
  					for (var i = 0; i < constraintMap.length; i++) {
  						var valueMap = constraintMap[i];
  						timeline.setFrame(frameIndex, this.getValue(valueMap, "time", 0), this.getValue(valueMap, "mix", 1), this.getValue(valueMap, "softness", 0) * scale, this.getValue(valueMap, "bendPositive", true) ? 1 : -1, this.getValue(valueMap, "compress", false), this.getValue(valueMap, "stretch", false));
  						this.readCurve(valueMap, timeline, frameIndex);
  						frameIndex++;
  					}
  					timelines.push(timeline);
  					duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.IkConstraintTimeline.ENTRIES]);
  				}
  			}
  			if (map.transform) {
  				for (var constraintName in map.transform) {
  					var constraintMap = map.transform[constraintName];
  					var constraint = skeletonData.findTransformConstraint(constraintName);
  					var timeline = new spine.TransformConstraintTimeline(constraintMap.length);
  					timeline.transformConstraintIndex = skeletonData.transformConstraints.indexOf(constraint);
  					var frameIndex = 0;
  					for (var i = 0; i < constraintMap.length; i++) {
  						var valueMap = constraintMap[i];
  						timeline.setFrame(frameIndex, this.getValue(valueMap, "time", 0), this.getValue(valueMap, "rotateMix", 1), this.getValue(valueMap, "translateMix", 1), this.getValue(valueMap, "scaleMix", 1), this.getValue(valueMap, "shearMix", 1));
  						this.readCurve(valueMap, timeline, frameIndex);
  						frameIndex++;
  					}
  					timelines.push(timeline);
  					duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.TransformConstraintTimeline.ENTRIES]);
  				}
  			}
  			if (map.path) {
  				for (var constraintName in map.path) {
  					var constraintMap = map.path[constraintName];
  					var index = skeletonData.findPathConstraintIndex(constraintName);
  					if (index == -1)
  						throw new Error("Path constraint not found: " + constraintName);
  					var data = skeletonData.pathConstraints[index];
  					for (var timelineName in constraintMap) {
  						var timelineMap = constraintMap[timelineName];
  						if (timelineName === "position" || timelineName === "spacing") {
  							var timeline = null;
  							var timelineScale = 1;
  							if (timelineName === "spacing") {
  								timeline = new spine.PathConstraintSpacingTimeline(timelineMap.length);
  								if (data.spacingMode == spine.SpacingMode.Length || data.spacingMode == spine.SpacingMode.Fixed)
  									timelineScale = scale;
  							}
  							else {
  								timeline = new spine.PathConstraintPositionTimeline(timelineMap.length);
  								if (data.positionMode == spine.PositionMode.Fixed)
  									timelineScale = scale;
  							}
  							timeline.pathConstraintIndex = index;
  							var frameIndex = 0;
  							for (var i = 0; i < timelineMap.length; i++) {
  								var valueMap = timelineMap[i];
  								timeline.setFrame(frameIndex, this.getValue(valueMap, "time", 0), this.getValue(valueMap, timelineName, 0) * timelineScale);
  								this.readCurve(valueMap, timeline, frameIndex);
  								frameIndex++;
  							}
  							timelines.push(timeline);
  							duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.PathConstraintPositionTimeline.ENTRIES]);
  						}
  						else if (timelineName === "mix") {
  							var timeline = new spine.PathConstraintMixTimeline(timelineMap.length);
  							timeline.pathConstraintIndex = index;
  							var frameIndex = 0;
  							for (var i = 0; i < timelineMap.length; i++) {
  								var valueMap = timelineMap[i];
  								timeline.setFrame(frameIndex, this.getValue(valueMap, "time", 0), this.getValue(valueMap, "rotateMix", 1), this.getValue(valueMap, "translateMix", 1));
  								this.readCurve(valueMap, timeline, frameIndex);
  								frameIndex++;
  							}
  							timelines.push(timeline);
  							duration = Math.max(duration, timeline.frames[(timeline.getFrameCount() - 1) * spine.PathConstraintMixTimeline.ENTRIES]);
  						}
  					}
  				}
  			}
  			if (map.deform) {
  				for (var deformName in map.deform) {
  					var deformMap = map.deform[deformName];
  					var skin = skeletonData.findSkin(deformName);
  					if (skin == null)
  						throw new Error("Skin not found: " + deformName);
  					for (var slotName in deformMap) {
  						var slotMap = deformMap[slotName];
  						var slotIndex = skeletonData.findSlotIndex(slotName);
  						if (slotIndex == -1)
  							throw new Error("Slot not found: " + slotMap.name);
  						for (var timelineName in slotMap) {
  							var timelineMap = slotMap[timelineName];
  							var attachment = skin.getAttachment(slotIndex, timelineName);
  							if (attachment == null)
  								throw new Error("Deform attachment not found: " + timelineMap.name);
  							var weighted = attachment.bones != null;
  							var vertices = attachment.vertices;
  							var deformLength = weighted ? vertices.length / 3 * 2 : vertices.length;
  							var timeline = new spine.DeformTimeline(timelineMap.length);
  							timeline.slotIndex = slotIndex;
  							timeline.attachment = attachment;
  							var frameIndex = 0;
  							for (var j = 0; j < timelineMap.length; j++) {
  								var valueMap = timelineMap[j];
  								var deform = void 0;
  								var verticesValue = this.getValue(valueMap, "vertices", null);
  								if (verticesValue == null)
  									deform = weighted ? spine.Utils.newFloatArray(deformLength) : vertices;
  								else {
  									deform = spine.Utils.newFloatArray(deformLength);
  									var start = this.getValue(valueMap, "offset", 0);
  									spine.Utils.arrayCopy(verticesValue, 0, deform, start, verticesValue.length);
  									if (scale != 1) {
  										for (var i = start, n = i + verticesValue.length; i < n; i++)
  											deform[i] *= scale;
  									}
  									if (!weighted) {
  										for (var i = 0; i < deformLength; i++)
  											deform[i] += vertices[i];
  									}
  								}
  								timeline.setFrame(frameIndex, this.getValue(valueMap, "time", 0), deform);
  								this.readCurve(valueMap, timeline, frameIndex);
  								frameIndex++;
  							}
  							timelines.push(timeline);
  							duration = Math.max(duration, timeline.frames[timeline.getFrameCount() - 1]);
  						}
  					}
  				}
  			}
  			var drawOrderNode = map.drawOrder;
  			if (drawOrderNode == null)
  				drawOrderNode = map.draworder;
  			if (drawOrderNode != null) {
  				var timeline = new spine.DrawOrderTimeline(drawOrderNode.length);
  				var slotCount = skeletonData.slots.length;
  				var frameIndex = 0;
  				for (var j = 0; j < drawOrderNode.length; j++) {
  					var drawOrderMap = drawOrderNode[j];
  					var drawOrder = null;
  					var offsets = this.getValue(drawOrderMap, "offsets", null);
  					if (offsets != null) {
  						drawOrder = spine.Utils.newArray(slotCount, -1);
  						var unchanged = spine.Utils.newArray(slotCount - offsets.length, 0);
  						var originalIndex = 0, unchangedIndex = 0;
  						for (var i = 0; i < offsets.length; i++) {
  							var offsetMap = offsets[i];
  							var slotIndex = skeletonData.findSlotIndex(offsetMap.slot);
  							if (slotIndex == -1)
  								throw new Error("Slot not found: " + offsetMap.slot);
  							while (originalIndex != slotIndex)
  								unchanged[unchangedIndex++] = originalIndex++;
  							drawOrder[originalIndex + offsetMap.offset] = originalIndex++;
  						}
  						while (originalIndex < slotCount)
  							unchanged[unchangedIndex++] = originalIndex++;
  						for (var i = slotCount - 1; i >= 0; i--)
  							if (drawOrder[i] == -1)
  								drawOrder[i] = unchanged[--unchangedIndex];
  					}
  					timeline.setFrame(frameIndex++, this.getValue(drawOrderMap, "time", 0), drawOrder);
  				}
  				timelines.push(timeline);
  				duration = Math.max(duration, timeline.frames[timeline.getFrameCount() - 1]);
  			}
  			if (map.events) {
  				var timeline = new spine.EventTimeline(map.events.length);
  				var frameIndex = 0;
  				for (var i = 0; i < map.events.length; i++) {
  					var eventMap = map.events[i];
  					var eventData = skeletonData.findEvent(eventMap.name);
  					if (eventData == null)
  						throw new Error("Event not found: " + eventMap.name);
  					var event_6 = new spine.Event(spine.Utils.toSinglePrecision(this.getValue(eventMap, "time", 0)), eventData);
  					event_6.intValue = this.getValue(eventMap, "int", eventData.intValue);
  					event_6.floatValue = this.getValue(eventMap, "float", eventData.floatValue);
  					event_6.stringValue = this.getValue(eventMap, "string", eventData.stringValue);
  					if (event_6.data.audioPath != null) {
  						event_6.volume = this.getValue(eventMap, "volume", 1);
  						event_6.balance = this.getValue(eventMap, "balance", 0);
  					}
  					timeline.setFrame(frameIndex++, event_6);
  				}
  				timelines.push(timeline);
  				duration = Math.max(duration, timeline.frames[timeline.getFrameCount() - 1]);
  			}
  			if (isNaN(duration)) {
  				throw new Error("Error while parsing animation, duration is NaN");
  			}
  			skeletonData.animations.push(new spine.Animation(name, timelines, duration));
  		};
  		SkeletonJson.prototype.readCurve = function (map, timeline, frameIndex) {
  			if (!map.hasOwnProperty("curve"))
  				return;
  			if (map.curve == "stepped")
  				timeline.setStepped(frameIndex);
  			else {
  				var curve = map.curve;
  				timeline.setCurve(frameIndex, curve, this.getValue(map, "c2", 0), this.getValue(map, "c3", 1), this.getValue(map, "c4", 1));
  			}
  		};
  		SkeletonJson.prototype.getValue = function (map, prop, defaultValue) {
  			return map[prop] !== undefined ? map[prop] : defaultValue;
  		};
  		SkeletonJson.blendModeFromString = function (str) {
  			str = str.toLowerCase();
  			if (str == "normal")
  				return spine.BlendMode.Normal;
  			if (str == "additive")
  				return spine.BlendMode.Additive;
  			if (str == "multiply")
  				return spine.BlendMode.Multiply;
  			if (str == "screen")
  				return spine.BlendMode.Screen;
  			throw new Error("Unknown blend mode: " + str);
  		};
  		SkeletonJson.positionModeFromString = function (str) {
  			str = str.toLowerCase();
  			if (str == "fixed")
  				return spine.PositionMode.Fixed;
  			if (str == "percent")
  				return spine.PositionMode.Percent;
  			throw new Error("Unknown position mode: " + str);
  		};
  		SkeletonJson.spacingModeFromString = function (str) {
  			str = str.toLowerCase();
  			if (str == "length")
  				return spine.SpacingMode.Length;
  			if (str == "fixed")
  				return spine.SpacingMode.Fixed;
  			if (str == "percent")
  				return spine.SpacingMode.Percent;
  			throw new Error("Unknown position mode: " + str);
  		};
  		SkeletonJson.rotateModeFromString = function (str) {
  			str = str.toLowerCase();
  			if (str == "tangent")
  				return spine.RotateMode.Tangent;
  			if (str == "chain")
  				return spine.RotateMode.Chain;
  			if (str == "chainscale")
  				return spine.RotateMode.ChainScale;
  			throw new Error("Unknown rotate mode: " + str);
  		};
  		SkeletonJson.transformModeFromString = function (str) {
  			str = str.toLowerCase();
  			if (str == "normal")
  				return spine.TransformMode.Normal;
  			if (str == "onlytranslation")
  				return spine.TransformMode.OnlyTranslation;
  			if (str == "norotationorreflection")
  				return spine.TransformMode.NoRotationOrReflection;
  			if (str == "noscale")
  				return spine.TransformMode.NoScale;
  			if (str == "noscaleorreflection")
  				return spine.TransformMode.NoScaleOrReflection;
  			throw new Error("Unknown transform mode: " + str);
  		};
  		return SkeletonJson;
  	}());
  	spine.SkeletonJson = SkeletonJson;
  	var LinkedMesh = (function () {
  		function LinkedMesh(mesh, skin, slotIndex, parent, inheritDeform) {
  			this.mesh = mesh;
  			this.skin = skin;
  			this.slotIndex = slotIndex;
  			this.parent = parent;
  			this.inheritDeform = inheritDeform;
  		}
  		return LinkedMesh;
  	}());
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var SkinEntry = (function () {
  		function SkinEntry(slotIndex, name, attachment) {
  			this.slotIndex = slotIndex;
  			this.name = name;
  			this.attachment = attachment;
  		}
  		return SkinEntry;
  	}());
  	spine.SkinEntry = SkinEntry;
  	var Skin = (function () {
  		function Skin(name) {
  			this.attachments = new Array();
  			this.bones = Array();
  			this.constraints = new Array();
  			if (name == null)
  				throw new Error("name cannot be null.");
  			this.name = name;
  		}
  		Skin.prototype.setAttachment = function (slotIndex, name, attachment) {
  			if (attachment == null)
  				throw new Error("attachment cannot be null.");
  			var attachments = this.attachments;
  			if (slotIndex >= attachments.length)
  				attachments.length = slotIndex + 1;
  			if (!attachments[slotIndex])
  				attachments[slotIndex] = {};
  			attachments[slotIndex][name] = attachment;
  		};
  		Skin.prototype.addSkin = function (skin) {
  			for (var i = 0; i < skin.bones.length; i++) {
  				var bone = skin.bones[i];
  				var contained = false;
  				for (var j = 0; j < this.bones.length; j++) {
  					if (this.bones[j] == bone) {
  						contained = true;
  						break;
  					}
  				}
  				if (!contained)
  					this.bones.push(bone);
  			}
  			for (var i = 0; i < skin.constraints.length; i++) {
  				var constraint = skin.constraints[i];
  				var contained = false;
  				for (var j = 0; j < this.constraints.length; j++) {
  					if (this.constraints[j] == constraint) {
  						contained = true;
  						break;
  					}
  				}
  				if (!contained)
  					this.constraints.push(constraint);
  			}
  			var attachments = skin.getAttachments();
  			for (var i = 0; i < attachments.length; i++) {
  				var attachment = attachments[i];
  				this.setAttachment(attachment.slotIndex, attachment.name, attachment.attachment);
  			}
  		};
  		Skin.prototype.copySkin = function (skin) {
  			for (var i = 0; i < skin.bones.length; i++) {
  				var bone = skin.bones[i];
  				var contained = false;
  				for (var j = 0; j < this.bones.length; j++) {
  					if (this.bones[j] == bone) {
  						contained = true;
  						break;
  					}
  				}
  				if (!contained)
  					this.bones.push(bone);
  			}
  			for (var i = 0; i < skin.constraints.length; i++) {
  				var constraint = skin.constraints[i];
  				var contained = false;
  				for (var j = 0; j < this.constraints.length; j++) {
  					if (this.constraints[j] == constraint) {
  						contained = true;
  						break;
  					}
  				}
  				if (!contained)
  					this.constraints.push(constraint);
  			}
  			var attachments = skin.getAttachments();
  			for (var i = 0; i < attachments.length; i++) {
  				var attachment = attachments[i];
  				if (attachment.attachment == null)
  					continue;
  				if (attachment.attachment instanceof spine.MeshAttachment) {
  					attachment.attachment = attachment.attachment.newLinkedMesh();
  					this.setAttachment(attachment.slotIndex, attachment.name, attachment.attachment);
  				}
  				else {
  					attachment.attachment = attachment.attachment.copy();
  					this.setAttachment(attachment.slotIndex, attachment.name, attachment.attachment);
  				}
  			}
  		};
  		Skin.prototype.getAttachment = function (slotIndex, name) {
  			var dictionary = this.attachments[slotIndex];
  			return dictionary ? dictionary[name] : null;
  		};
  		Skin.prototype.removeAttachment = function (slotIndex, name) {
  			var dictionary = this.attachments[slotIndex];
  			if (dictionary)
  				dictionary[name] = null;
  		};
  		Skin.prototype.getAttachments = function () {
  			var entries = new Array();
  			for (var i = 0; i < this.attachments.length; i++) {
  				var slotAttachments = this.attachments[i];
  				if (slotAttachments) {
  					for (var name_4 in slotAttachments) {
  						var attachment = slotAttachments[name_4];
  						if (attachment)
  							entries.push(new SkinEntry(i, name_4, attachment));
  					}
  				}
  			}
  			return entries;
  		};
  		Skin.prototype.getAttachmentsForSlot = function (slotIndex, attachments) {
  			var slotAttachments = this.attachments[slotIndex];
  			if (slotAttachments) {
  				for (var name_5 in slotAttachments) {
  					var attachment = slotAttachments[name_5];
  					if (attachment)
  						attachments.push(new SkinEntry(slotIndex, name_5, attachment));
  				}
  			}
  		};
  		Skin.prototype.clear = function () {
  			this.attachments.length = 0;
  			this.bones.length = 0;
  			this.constraints.length = 0;
  		};
  		Skin.prototype.attachAll = function (skeleton, oldSkin) {
  			var slotIndex = 0;
  			for (var i = 0; i < skeleton.slots.length; i++) {
  				var slot = skeleton.slots[i];
  				var slotAttachment = slot.getAttachment();
  				if (slotAttachment && slotIndex < oldSkin.attachments.length) {
  					var dictionary = oldSkin.attachments[slotIndex];
  					for (var key in dictionary) {
  						var skinAttachment = dictionary[key];
  						if (slotAttachment == skinAttachment) {
  							var attachment = this.getAttachment(slotIndex, key);
  							if (attachment != null)
  								slot.setAttachment(attachment);
  							break;
  						}
  					}
  				}
  				slotIndex++;
  			}
  		};
  		return Skin;
  	}());
  	spine.Skin = Skin;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var Slot = (function () {
  		function Slot(data, bone) {
  			this.deform = new Array();
  			if (data == null)
  				throw new Error("data cannot be null.");
  			if (bone == null)
  				throw new Error("bone cannot be null.");
  			this.data = data;
  			this.bone = bone;
  			this.color = new spine.Color();
  			this.darkColor = data.darkColor == null ? null : new spine.Color();
  			this.setToSetupPose();
  		}
  		Slot.prototype.getSkeleton = function () {
  			return this.bone.skeleton;
  		};
  		Slot.prototype.getAttachment = function () {
  			return this.attachment;
  		};
  		Slot.prototype.setAttachment = function (attachment) {
  			if (this.attachment == attachment)
  				return;
  			this.attachment = attachment;
  			this.attachmentTime = this.bone.skeleton.time;
  			this.deform.length = 0;
  		};
  		Slot.prototype.setAttachmentTime = function (time) {
  			this.attachmentTime = this.bone.skeleton.time - time;
  		};
  		Slot.prototype.getAttachmentTime = function () {
  			return this.bone.skeleton.time - this.attachmentTime;
  		};
  		Slot.prototype.setToSetupPose = function () {
  			this.color.setFromColor(this.data.color);
  			if (this.darkColor != null)
  				this.darkColor.setFromColor(this.data.darkColor);
  			if (this.data.attachmentName == null)
  				this.attachment = null;
  			else {
  				this.attachment = null;
  				this.setAttachment(this.bone.skeleton.getAttachment(this.data.index, this.data.attachmentName));
  			}
  		};
  		return Slot;
  	}());
  	spine.Slot = Slot;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var SlotData = (function () {
  		function SlotData(index, name, boneData) {
  			this.color = new spine.Color(1, 1, 1, 1);
  			if (index < 0)
  				throw new Error("index must be >= 0.");
  			if (name == null)
  				throw new Error("name cannot be null.");
  			if (boneData == null)
  				throw new Error("boneData cannot be null.");
  			this.index = index;
  			this.name = name;
  			this.boneData = boneData;
  		}
  		return SlotData;
  	}());
  	spine.SlotData = SlotData;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var Texture = (function () {
  		function Texture(image) {
  			this._image = image;
  		}
  		Texture.prototype.getImage = function () {
  			return this._image;
  		};
  		Texture.filterFromString = function (text) {
  			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);
  			}
  		};
  		Texture.wrapFromString = function (text) {
  			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);
  			}
  		};
  		return Texture;
  	}());
  	spine.Texture = Texture;
  	var TextureFilter;
  	(function (TextureFilter) {
  		TextureFilter[TextureFilter["Nearest"] = 9728] = "Nearest";
  		TextureFilter[TextureFilter["Linear"] = 9729] = "Linear";
  		TextureFilter[TextureFilter["MipMap"] = 9987] = "MipMap";
  		TextureFilter[TextureFilter["MipMapNearestNearest"] = 9984] = "MipMapNearestNearest";
  		TextureFilter[TextureFilter["MipMapLinearNearest"] = 9985] = "MipMapLinearNearest";
  		TextureFilter[TextureFilter["MipMapNearestLinear"] = 9986] = "MipMapNearestLinear";
  		TextureFilter[TextureFilter["MipMapLinearLinear"] = 9987] = "MipMapLinearLinear";
  	})(TextureFilter = spine.TextureFilter || (spine.TextureFilter = {}));
  	var TextureWrap;
  	(function (TextureWrap) {
  		TextureWrap[TextureWrap["MirroredRepeat"] = 33648] = "MirroredRepeat";
  		TextureWrap[TextureWrap["ClampToEdge"] = 33071] = "ClampToEdge";
  		TextureWrap[TextureWrap["Repeat"] = 10497] = "Repeat";
  	})(TextureWrap = spine.TextureWrap || (spine.TextureWrap = {}));
  	var TextureRegion = (function () {
  		function TextureRegion() {
  			this.u = 0;
  			this.v = 0;
  			this.u2 = 0;
  			this.v2 = 0;
  			this.width = 0;
  			this.height = 0;
  			this.rotate = false;
  			this.offsetX = 0;
  			this.offsetY = 0;
  			this.originalWidth = 0;
  			this.originalHeight = 0;
  		}
  		return TextureRegion;
  	}());
  	spine.TextureRegion = TextureRegion;
  	var FakeTexture = (function (_super) {
  		__extends(FakeTexture, _super);
  		function FakeTexture() {
  			return _super !== null && _super.apply(this, arguments) || this;
  		}
  		FakeTexture.prototype.setFilters = function (minFilter, magFilter) { };
  		FakeTexture.prototype.setWraps = function (uWrap, vWrap) { };
  		FakeTexture.prototype.dispose = function () { };
  		return FakeTexture;
  	}(Texture));
  	spine.FakeTexture = FakeTexture;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var TextureAtlas = (function () {
  		function TextureAtlas(atlasText, textureLoader) {
  			this.pages = new Array();
  			this.regions = new Array();
  			this.load(atlasText, textureLoader);
  		}
  		TextureAtlas.prototype.load = function (atlasText, textureLoader) {
  			if (textureLoader == null)
  				throw new Error("textureLoader cannot be null.");
  			var reader = new TextureAtlasReader(atlasText);
  			var tuple = new Array(4);
  			var page = null;
  			while (true) {
  				var line = reader.readLine();
  				if (line == null)
  					break;
  				line = line.trim();
  				if (line.length == 0)
  					page = null;
  				else if (!page) {
  					page = new TextureAtlasPage();
  					page.name = line;
  					if (reader.readTuple(tuple) == 2) {
  						page.width = parseInt(tuple[0]);
  						page.height = parseInt(tuple[1]);
  						reader.readTuple(tuple);
  					}
  					reader.readTuple(tuple);
  					page.minFilter = spine.Texture.filterFromString(tuple[0]);
  					page.magFilter = spine.Texture.filterFromString(tuple[1]);
  					var direction = reader.readValue();
  					page.uWrap = spine.TextureWrap.ClampToEdge;
  					page.vWrap = spine.TextureWrap.ClampToEdge;
  					if (direction == "x")
  						page.uWrap = spine.TextureWrap.Repeat;
  					else if (direction == "y")
  						page.vWrap = spine.TextureWrap.Repeat;
  					else if (direction == "xy")
  						page.uWrap = page.vWrap = spine.TextureWrap.Repeat;
  					page.texture = textureLoader(line);
  					page.texture.setFilters(page.minFilter, page.magFilter);
  					page.texture.setWraps(page.uWrap, page.vWrap);
  					page.width = page.texture.getImage().width;
  					page.height = page.texture.getImage().height;
  					this.pages.push(page);
  				}
  				else {
  					var region = new TextureAtlasRegion();
  					region.name = line;
  					region.page = page;
  					var rotateValue = reader.readValue();
  					if (rotateValue.toLocaleLowerCase() == "true") {
  						region.degrees = 90;
  					}
  					else if (rotateValue.toLocaleLowerCase() == "false") {
  						region.degrees = 0;
  					}
  					else {
  						region.degrees = parseFloat(rotateValue);
  					}
  					region.rotate = region.degrees == 90;
  					reader.readTuple(tuple);
  					var x = parseInt(tuple[0]);
  					var y = parseInt(tuple[1]);
  					reader.readTuple(tuple);
  					var width = parseInt(tuple[0]);
  					var height = parseInt(tuple[1]);
  					region.u = x / page.width;
  					region.v = y / page.height;
  					if (region.rotate) {
  						region.u2 = (x + height) / page.width;
  						region.v2 = (y + width) / page.height;
  					}
  					else {
  						region.u2 = (x + width) / page.width;
  						region.v2 = (y + height) / page.height;
  					}
  					region.x = x;
  					region.y = y;
  					region.width = Math.abs(width);
  					region.height = Math.abs(height);
  					if (reader.readTuple(tuple) == 4) {
  						if (reader.readTuple(tuple) == 4) {
  							reader.readTuple(tuple);
  						}
  					}
  					region.originalWidth = parseInt(tuple[0]);
  					region.originalHeight = parseInt(tuple[1]);
  					reader.readTuple(tuple);
  					region.offsetX = parseInt(tuple[0]);
  					region.offsetY = parseInt(tuple[1]);
  					region.index = parseInt(reader.readValue());
  					region.texture = page.texture;
  					this.regions.push(region);
  				}
  			}
  		};
  		TextureAtlas.prototype.findRegion = function (name) {
  			for (var i = 0; i < this.regions.length; i++) {
  				if (this.regions[i].name == name) {
  					return this.regions[i];
  				}
  			}
  			return null;
  		};
  		TextureAtlas.prototype.dispose = function () {
  			for (var i = 0; i < this.pages.length; i++) {
  				this.pages[i].texture.dispose();
  			}
  		};
  		return TextureAtlas;
  	}());
  	spine.TextureAtlas = TextureAtlas;
  	var TextureAtlasReader = (function () {
  		function TextureAtlasReader(text) {
  			this.index = 0;
  			this.lines = text.split(/\r\n|\r|\n/);
  		}
  		TextureAtlasReader.prototype.readLine = function () {
  			if (this.index >= this.lines.length)
  				return null;
  			return this.lines[this.index++];
  		};
  		TextureAtlasReader.prototype.readValue = function () {
  			var line = this.readLine();
  			var colon = line.indexOf(":");
  			if (colon == -1)
  				throw new Error("Invalid line: " + line);
  			return line.substring(colon + 1).trim();
  		};
  		TextureAtlasReader.prototype.readTuple = function (tuple) {
  			var line = this.readLine();
  			var colon = line.indexOf(":");
  			if (colon == -1)
  				throw new Error("Invalid line: " + line);
  			var i = 0, lastMatch = colon + 1;
  			for (; i < 3; i++) {
  				var comma = line.indexOf(",", lastMatch);
  				if (comma == -1)
  					break;
  				tuple[i] = line.substr(lastMatch, comma - lastMatch).trim();
  				lastMatch = comma + 1;
  			}
  			tuple[i] = line.substring(lastMatch).trim();
  			return i + 1;
  		};
  		return TextureAtlasReader;
  	}());
  	var TextureAtlasPage = (function () {
  		function TextureAtlasPage() {
  		}
  		return TextureAtlasPage;
  	}());
  	spine.TextureAtlasPage = TextureAtlasPage;
  	var TextureAtlasRegion = (function (_super) {
  		__extends(TextureAtlasRegion, _super);
  		function TextureAtlasRegion() {
  			return _super !== null && _super.apply(this, arguments) || this;
  		}
  		return TextureAtlasRegion;
  	}(spine.TextureRegion));
  	spine.TextureAtlasRegion = TextureAtlasRegion;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var TransformConstraint = (function () {
  		function TransformConstraint(data, skeleton) {
  			this.rotateMix = 0;
  			this.translateMix = 0;
  			this.scaleMix = 0;
  			this.shearMix = 0;
  			this.temp = new spine.Vector2();
  			this.active = false;
  			if (data == null)
  				throw new Error("data cannot be null.");
  			if (skeleton == null)
  				throw new Error("skeleton cannot be null.");
  			this.data = data;
  			this.rotateMix = data.rotateMix;
  			this.translateMix = data.translateMix;
  			this.scaleMix = data.scaleMix;
  			this.shearMix = data.shearMix;
  			this.bones = new Array();
  			for (var i = 0; i < data.bones.length; i++)
  				this.bones.push(skeleton.findBone(data.bones[i].name));
  			this.target = skeleton.findBone(data.target.name);
  		}
  		TransformConstraint.prototype.isActive = function () {
  			return this.active;
  		};
  		TransformConstraint.prototype.apply = function () {
  			this.update();
  		};
  		TransformConstraint.prototype.update = function () {
  			if (this.data.local) {
  				if (this.data.relative)
  					this.applyRelativeLocal();
  				else
  					this.applyAbsoluteLocal();
  			}
  			else {
  				if (this.data.relative)
  					this.applyRelativeWorld();
  				else
  					this.applyAbsoluteWorld();
  			}
  		};
  		TransformConstraint.prototype.applyAbsoluteWorld = function () {
  			var rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix;
  			var target = this.target;
  			var ta = target.a, tb = target.b, tc = target.c, td = target.d;
  			var degRadReflect = ta * td - tb * tc > 0 ? spine.MathUtils.degRad : -spine.MathUtils.degRad;
  			var offsetRotation = this.data.offsetRotation * degRadReflect;
  			var offsetShearY = this.data.offsetShearY * degRadReflect;
  			var bones = this.bones;
  			for (var i = 0, n = bones.length; i < n; i++) {
  				var bone = bones[i];
  				var modified = false;
  				if (rotateMix != 0) {
  					var a = bone.a, b = bone.b, c = bone.c, d = bone.d;
  					var r = Math.atan2(tc, ta) - Math.atan2(c, a) + offsetRotation;
  					if (r > spine.MathUtils.PI)
  						r -= spine.MathUtils.PI2;
  					else if (r < -spine.MathUtils.PI)
  						r += spine.MathUtils.PI2;
  					r *= rotateMix;
  					var cos = Math.cos(r), sin = Math.sin(r);
  					bone.a = cos * a - sin * c;
  					bone.b = cos * b - sin * d;
  					bone.c = sin * a + cos * c;
  					bone.d = sin * b + cos * d;
  					modified = true;
  				}
  				if (translateMix != 0) {
  					var temp = this.temp;
  					target.localToWorld(temp.set(this.data.offsetX, this.data.offsetY));
  					bone.worldX += (temp.x - bone.worldX) * translateMix;
  					bone.worldY += (temp.y - bone.worldY) * translateMix;
  					modified = true;
  				}
  				if (scaleMix > 0) {
  					var s = Math.sqrt(bone.a * bone.a + bone.c * bone.c);
  					var ts = Math.sqrt(ta * ta + tc * tc);
  					if (s > 0.00001)
  						s = (s + (ts - s + this.data.offsetScaleX) * scaleMix) / s;
  					bone.a *= s;
  					bone.c *= s;
  					s = Math.sqrt(bone.b * bone.b + bone.d * bone.d);
  					ts = Math.sqrt(tb * tb + td * td);
  					if (s > 0.00001)
  						s = (s + (ts - s + this.data.offsetScaleY) * scaleMix) / s;
  					bone.b *= s;
  					bone.d *= s;
  					modified = true;
  				}
  				if (shearMix > 0) {
  					var b = bone.b, d = bone.d;
  					var by = Math.atan2(d, b);
  					var r = Math.atan2(td, tb) - Math.atan2(tc, ta) - (by - Math.atan2(bone.c, bone.a));
  					if (r > spine.MathUtils.PI)
  						r -= spine.MathUtils.PI2;
  					else if (r < -spine.MathUtils.PI)
  						r += spine.MathUtils.PI2;
  					r = by + (r + offsetShearY) * shearMix;
  					var s = Math.sqrt(b * b + d * d);
  					bone.b = Math.cos(r) * s;
  					bone.d = Math.sin(r) * s;
  					modified = true;
  				}
  				if (modified)
  					bone.appliedValid = false;
  			}
  		};
  		TransformConstraint.prototype.applyRelativeWorld = function () {
  			var rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix;
  			var target = this.target;
  			var ta = target.a, tb = target.b, tc = target.c, td = target.d;
  			var degRadReflect = ta * td - tb * tc > 0 ? spine.MathUtils.degRad : -spine.MathUtils.degRad;
  			var offsetRotation = this.data.offsetRotation * degRadReflect, offsetShearY = this.data.offsetShearY * degRadReflect;
  			var bones = this.bones;
  			for (var i = 0, n = bones.length; i < n; i++) {
  				var bone = bones[i];
  				var modified = false;
  				if (rotateMix != 0) {
  					var a = bone.a, b = bone.b, c = bone.c, d = bone.d;
  					var r = Math.atan2(tc, ta) + offsetRotation;
  					if (r > spine.MathUtils.PI)
  						r -= spine.MathUtils.PI2;
  					else if (r < -spine.MathUtils.PI)
  						r += spine.MathUtils.PI2;
  					r *= rotateMix;
  					var cos = Math.cos(r), sin = Math.sin(r);
  					bone.a = cos * a - sin * c;
  					bone.b = cos * b - sin * d;
  					bone.c = sin * a + cos * c;
  					bone.d = sin * b + cos * d;
  					modified = true;
  				}
  				if (translateMix != 0) {
  					var temp = this.temp;
  					target.localToWorld(temp.set(this.data.offsetX, this.data.offsetY));
  					bone.worldX += temp.x * translateMix;
  					bone.worldY += temp.y * translateMix;
  					modified = true;
  				}
  				if (scaleMix > 0) {
  					var s = (Math.sqrt(ta * ta + tc * tc) - 1 + this.data.offsetScaleX) * scaleMix + 1;
  					bone.a *= s;
  					bone.c *= s;
  					s = (Math.sqrt(tb * tb + td * td) - 1 + this.data.offsetScaleY) * scaleMix + 1;
  					bone.b *= s;
  					bone.d *= s;
  					modified = true;
  				}
  				if (shearMix > 0) {
  					var r = Math.atan2(td, tb) - Math.atan2(tc, ta);
  					if (r > spine.MathUtils.PI)
  						r -= spine.MathUtils.PI2;
  					else if (r < -spine.MathUtils.PI)
  						r += spine.MathUtils.PI2;
  					var b = bone.b, d = bone.d;
  					r = Math.atan2(d, b) + (r - spine.MathUtils.PI / 2 + offsetShearY) * shearMix;
  					var s = Math.sqrt(b * b + d * d);
  					bone.b = Math.cos(r) * s;
  					bone.d = Math.sin(r) * s;
  					modified = true;
  				}
  				if (modified)
  					bone.appliedValid = false;
  			}
  		};
  		TransformConstraint.prototype.applyAbsoluteLocal = function () {
  			var rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix;
  			var target = this.target;
  			if (!target.appliedValid)
  				target.updateAppliedTransform();
  			var bones = this.bones;
  			for (var i = 0, n = bones.length; i < n; i++) {
  				var bone = bones[i];
  				if (!bone.appliedValid)
  					bone.updateAppliedTransform();
  				var rotation = bone.arotation;
  				if (rotateMix != 0) {
  					var r = target.arotation - rotation + this.data.offsetRotation;
  					r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
  					rotation += r * rotateMix;
  				}
  				var x = bone.ax, y = bone.ay;
  				if (translateMix != 0) {
  					x += (target.ax - x + this.data.offsetX) * translateMix;
  					y += (target.ay - y + this.data.offsetY) * translateMix;
  				}
  				var scaleX = bone.ascaleX, scaleY = bone.ascaleY;
  				if (scaleMix != 0) {
  					if (scaleX > 0.00001)
  						scaleX = (scaleX + (target.ascaleX - scaleX + this.data.offsetScaleX) * scaleMix) / scaleX;
  					if (scaleY > 0.00001)
  						scaleY = (scaleY + (target.ascaleY - scaleY + this.data.offsetScaleY) * scaleMix) / scaleY;
  				}
  				var shearY = bone.ashearY;
  				if (shearMix != 0) {
  					var r = target.ashearY - shearY + this.data.offsetShearY;
  					r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
  					bone.shearY += r * shearMix;
  				}
  				bone.updateWorldTransformWith(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
  			}
  		};
  		TransformConstraint.prototype.applyRelativeLocal = function () {
  			var rotateMix = this.rotateMix, translateMix = this.translateMix, scaleMix = this.scaleMix, shearMix = this.shearMix;
  			var target = this.target;
  			if (!target.appliedValid)
  				target.updateAppliedTransform();
  			var bones = this.bones;
  			for (var i = 0, n = bones.length; i < n; i++) {
  				var bone = bones[i];
  				if (!bone.appliedValid)
  					bone.updateAppliedTransform();
  				var rotation = bone.arotation;
  				if (rotateMix != 0)
  					rotation += (target.arotation + this.data.offsetRotation) * rotateMix;
  				var x = bone.ax, y = bone.ay;
  				if (translateMix != 0) {
  					x += (target.ax + this.data.offsetX) * translateMix;
  					y += (target.ay + this.data.offsetY) * translateMix;
  				}
  				var scaleX = bone.ascaleX, scaleY = bone.ascaleY;
  				if (scaleMix != 0) {
  					if (scaleX > 0.00001)
  						scaleX *= ((target.ascaleX - 1 + this.data.offsetScaleX) * scaleMix) + 1;
  					if (scaleY > 0.00001)
  						scaleY *= ((target.ascaleY - 1 + this.data.offsetScaleY) * scaleMix) + 1;
  				}
  				var shearY = bone.ashearY;
  				if (shearMix != 0)
  					shearY += (target.ashearY + this.data.offsetShearY) * shearMix;
  				bone.updateWorldTransformWith(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
  			}
  		};
  		return TransformConstraint;
  	}());
  	spine.TransformConstraint = TransformConstraint;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var TransformConstraintData = (function (_super) {
  		__extends(TransformConstraintData, _super);
  		function TransformConstraintData(name) {
  			var _this = _super.call(this, name, 0, false) || this;
  			_this.bones = new Array();
  			_this.rotateMix = 0;
  			_this.translateMix = 0;
  			_this.scaleMix = 0;
  			_this.shearMix = 0;
  			_this.offsetRotation = 0;
  			_this.offsetX = 0;
  			_this.offsetY = 0;
  			_this.offsetScaleX = 0;
  			_this.offsetScaleY = 0;
  			_this.offsetShearY = 0;
  			_this.relative = false;
  			_this.local = false;
  			return _this;
  		}
  		return TransformConstraintData;
  	}(spine.ConstraintData));
  	spine.TransformConstraintData = TransformConstraintData;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var Triangulator = (function () {
  		function Triangulator() {
  			this.convexPolygons = new Array();
  			this.convexPolygonsIndices = new Array();
  			this.indicesArray = new Array();
  			this.isConcaveArray = new Array();
  			this.triangles = new Array();
  			this.polygonPool = new spine.Pool(function () {
  				return new Array();
  			});
  			this.polygonIndicesPool = new spine.Pool(function () {
  				return new Array();
  			});
  		}
  		Triangulator.prototype.triangulate = function (verticesArray) {
  			var vertices = verticesArray;
  			var vertexCount = verticesArray.length >> 1;
  			var indices = this.indicesArray;
  			indices.length = 0;
  			for (var i = 0; i < vertexCount; i++)
  				indices[i] = i;
  			var isConcave = this.isConcaveArray;
  			isConcave.length = 0;
  			for (var i = 0, n = vertexCount; i < n; ++i)
  				isConcave[i] = Triangulator.isConcave(i, vertexCount, vertices, indices);
  			var triangles = this.triangles;
  			triangles.length = 0;
  			while (vertexCount > 3) {
  				var previous = vertexCount - 1, i = 0, next = 1;
  				while (true) {
  					outer: if (!isConcave[i]) {
  						var p1 = indices[previous] << 1, p2 = indices[i] << 1, p3 = indices[next] << 1;
  						var p1x = vertices[p1], p1y = vertices[p1 + 1];
  						var p2x = vertices[p2], p2y = vertices[p2 + 1];
  						var p3x = vertices[p3], p3y = vertices[p3 + 1];
  						for (var ii = (next + 1) % vertexCount; ii != previous; ii = (ii + 1) % vertexCount) {
  							if (!isConcave[ii])
  								continue;
  							var v = indices[ii] << 1;
  							var vx = vertices[v], vy = vertices[v + 1];
  							if (Triangulator.positiveArea(p3x, p3y, p1x, p1y, vx, vy)) {
  								if (Triangulator.positiveArea(p1x, p1y, p2x, p2y, vx, vy)) {
  									if (Triangulator.positiveArea(p2x, p2y, p3x, p3y, vx, vy))
  										break outer;
  								}
  							}
  						}
  						break;
  					}
  					if (next == 0) {
  						do {
  							if (!isConcave[i])
  								break;
  							i--;
  						} while (i > 0);
  						break;
  					}
  					previous = i;
  					i = next;
  					next = (next + 1) % vertexCount;
  				}
  				triangles.push(indices[(vertexCount + i - 1) % vertexCount]);
  				triangles.push(indices[i]);
  				triangles.push(indices[(i + 1) % vertexCount]);
  				indices.splice(i, 1);
  				isConcave.splice(i, 1);
  				vertexCount--;
  				var previousIndex = (vertexCount + i - 1) % vertexCount;
  				var nextIndex = i == vertexCount ? 0 : i;
  				isConcave[previousIndex] = Triangulator.isConcave(previousIndex, vertexCount, vertices, indices);
  				isConcave[nextIndex] = Triangulator.isConcave(nextIndex, vertexCount, vertices, indices);
  			}
  			if (vertexCount == 3) {
  				triangles.push(indices[2]);
  				triangles.push(indices[0]);
  				triangles.push(indices[1]);
  			}
  			return triangles;
  		};
  		Triangulator.prototype.decompose = function (verticesArray, triangles) {
  			var vertices = verticesArray;
  			var convexPolygons = this.convexPolygons;
  			this.polygonPool.freeAll(convexPolygons);
  			convexPolygons.length = 0;
  			var convexPolygonsIndices = this.convexPolygonsIndices;
  			this.polygonIndicesPool.freeAll(convexPolygonsIndices);
  			convexPolygonsIndices.length = 0;
  			var polygonIndices = this.polygonIndicesPool.obtain();
  			polygonIndices.length = 0;
  			var polygon = this.polygonPool.obtain();
  			polygon.length = 0;
  			var fanBaseIndex = -1, lastWinding = 0;
  			for (var i = 0, n = triangles.length; i < n; i += 3) {
  				var t1 = triangles[i] << 1, t2 = triangles[i + 1] << 1, t3 = triangles[i + 2] << 1;
  				var x1 = vertices[t1], y1 = vertices[t1 + 1];
  				var x2 = vertices[t2], y2 = vertices[t2 + 1];
  				var x3 = vertices[t3], y3 = vertices[t3 + 1];
  				var merged = false;
  				if (fanBaseIndex == t1) {
  					var o = polygon.length - 4;
  					var winding1 = Triangulator.winding(polygon[o], polygon[o + 1], polygon[o + 2], polygon[o + 3], x3, y3);
  					var winding2 = Triangulator.winding(x3, y3, polygon[0], polygon[1], polygon[2], polygon[3]);
  					if (winding1 == lastWinding && winding2 == lastWinding) {
  						polygon.push(x3);
  						polygon.push(y3);
  						polygonIndices.push(t3);
  						merged = true;
  					}
  				}
  				if (!merged) {
  					if (polygon.length > 0) {
  						convexPolygons.push(polygon);
  						convexPolygonsIndices.push(polygonIndices);
  					}
  					else {
  						this.polygonPool.free(polygon);
  						this.polygonIndicesPool.free(polygonIndices);
  					}
  					polygon = this.polygonPool.obtain();
  					polygon.length = 0;
  					polygon.push(x1);
  					polygon.push(y1);
  					polygon.push(x2);
  					polygon.push(y2);
  					polygon.push(x3);
  					polygon.push(y3);
  					polygonIndices = this.polygonIndicesPool.obtain();
  					polygonIndices.length = 0;
  					polygonIndices.push(t1);
  					polygonIndices.push(t2);
  					polygonIndices.push(t3);
  					lastWinding = Triangulator.winding(x1, y1, x2, y2, x3, y3);
  					fanBaseIndex = t1;
  				}
  			}
  			if (polygon.length > 0) {
  				convexPolygons.push(polygon);
  				convexPolygonsIndices.push(polygonIndices);
  			}
  			for (var i = 0, n = convexPolygons.length; i < n; i++) {
  				polygonIndices = convexPolygonsIndices[i];
  				if (polygonIndices.length == 0)
  					continue;
  				var firstIndex = polygonIndices[0];
  				var lastIndex = polygonIndices[polygonIndices.length - 1];
  				polygon = convexPolygons[i];
  				var o = polygon.length - 4;
  				var prevPrevX = polygon[o], prevPrevY = polygon[o + 1];
  				var prevX = polygon[o + 2], prevY = polygon[o + 3];
  				var firstX = polygon[0], firstY = polygon[1];
  				var secondX = polygon[2], secondY = polygon[3];
  				var winding = Triangulator.winding(prevPrevX, prevPrevY, prevX, prevY, firstX, firstY);
  				for (var ii = 0; ii < n; ii++) {
  					if (ii == i)
  						continue;
  					var otherIndices = convexPolygonsIndices[ii];
  					if (otherIndices.length != 3)
  						continue;
  					var otherFirstIndex = otherIndices[0];
  					var otherSecondIndex = otherIndices[1];
  					var otherLastIndex = otherIndices[2];
  					var otherPoly = convexPolygons[ii];
  					var x3 = otherPoly[otherPoly.length - 2], y3 = otherPoly[otherPoly.length - 1];
  					if (otherFirstIndex != firstIndex || otherSecondIndex != lastIndex)
  						continue;
  					var winding1 = Triangulator.winding(prevPrevX, prevPrevY, prevX, prevY, x3, y3);
  					var winding2 = Triangulator.winding(x3, y3, firstX, firstY, secondX, secondY);
  					if (winding1 == winding && winding2 == winding) {
  						otherPoly.length = 0;
  						otherIndices.length = 0;
  						polygon.push(x3);
  						polygon.push(y3);
  						polygonIndices.push(otherLastIndex);
  						prevPrevX = prevX;
  						prevPrevY = prevY;
  						prevX = x3;
  						prevY = y3;
  						ii = 0;
  					}
  				}
  			}
  			for (var i = convexPolygons.length - 1; i >= 0; i--) {
  				polygon = convexPolygons[i];
  				if (polygon.length == 0) {
  					convexPolygons.splice(i, 1);
  					this.polygonPool.free(polygon);
  					polygonIndices = convexPolygonsIndices[i];
  					convexPolygonsIndices.splice(i, 1);
  					this.polygonIndicesPool.free(polygonIndices);
  				}
  			}
  			return convexPolygons;
  		};
  		Triangulator.isConcave = function (index, vertexCount, vertices, indices) {
  			var previous = indices[(vertexCount + index - 1) % vertexCount] << 1;
  			var current = indices[index] << 1;
  			var next = indices[(index + 1) % vertexCount] << 1;
  			return !this.positiveArea(vertices[previous], vertices[previous + 1], vertices[current], vertices[current + 1], vertices[next], vertices[next + 1]);
  		};
  		Triangulator.positiveArea = function (p1x, p1y, p2x, p2y, p3x, p3y) {
  			return p1x * (p3y - p2y) + p2x * (p1y - p3y) + p3x * (p2y - p1y) >= 0;
  		};
  		Triangulator.winding = function (p1x, p1y, p2x, p2y, p3x, p3y) {
  			var px = p2x - p1x, py = p2y - p1y;
  			return p3x * py - p3y * px + px * p1y - p1x * py >= 0 ? 1 : -1;
  		};
  		return Triangulator;
  	}());
  	spine.Triangulator = Triangulator;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var IntSet = (function () {
  		function IntSet() {
  			this.array = new Array();
  		}
  		IntSet.prototype.add = function (value) {
  			var contains = this.contains(value);
  			this.array[value | 0] = value | 0;
  			return !contains;
  		};
  		IntSet.prototype.contains = function (value) {
  			return this.array[value | 0] != undefined;
  		};
  		IntSet.prototype.remove = function (value) {
  			this.array[value | 0] = undefined;
  		};
  		IntSet.prototype.clear = function () {
  			this.array.length = 0;
  		};
  		return IntSet;
  	}());
  	spine.IntSet = IntSet;
  	var Color = (function () {
  		function Color(r, g, b, a) {
  			if (r === void 0) { r = 0; }
  			if (g === void 0) { g = 0; }
  			if (b === void 0) { b = 0; }
  			if (a === void 0) { a = 0; }
  			this.r = r;
  			this.g = g;
  			this.b = b;
  			this.a = a;
  		}
  		Color.prototype.set = function (r, g, b, a) {
  			this.r = r;
  			this.g = g;
  			this.b = b;
  			this.a = a;
  			this.clamp();
  			return this;
  		};
  		Color.prototype.setFromColor = function (c) {
  			this.r = c.r;
  			this.g = c.g;
  			this.b = c.b;
  			this.a = c.a;
  			return this;
  		};
  		Color.prototype.setFromString = function (hex) {
  			hex = hex.charAt(0) == '#' ? hex.substr(1) : hex;
  			this.r = parseInt(hex.substr(0, 2), 16) / 255.0;
  			this.g = parseInt(hex.substr(2, 2), 16) / 255.0;
  			this.b = parseInt(hex.substr(4, 2), 16) / 255.0;
  			this.a = (hex.length != 8 ? 255 : parseInt(hex.substr(6, 2), 16)) / 255.0;
  			return this;
  		};
  		Color.prototype.add = function (r, g, b, a) {
  			this.r += r;
  			this.g += g;
  			this.b += b;
  			this.a += a;
  			this.clamp();
  			return this;
  		};
  		Color.prototype.clamp = function () {
  			if (this.r < 0)
  				this.r = 0;
  			else if (this.r > 1)
  				this.r = 1;
  			if (this.g < 0)
  				this.g = 0;
  			else if (this.g > 1)
  				this.g = 1;
  			if (this.b < 0)
  				this.b = 0;
  			else if (this.b > 1)
  				this.b = 1;
  			if (this.a < 0)
  				this.a = 0;
  			else if (this.a > 1)
  				this.a = 1;
  			return this;
  		};
  		Color.rgba8888ToColor = function (color, value) {
  			color.r = ((value & 0xff000000) >>> 24) / 255;
  			color.g = ((value & 0x00ff0000) >>> 16) / 255;
  			color.b = ((value & 0x0000ff00) >>> 8) / 255;
  			color.a = ((value & 0x000000ff)) / 255;
  		};
  		Color.rgb888ToColor = function (color, value) {
  			color.r = ((value & 0x00ff0000) >>> 16) / 255;
  			color.g = ((value & 0x0000ff00) >>> 8) / 255;
  			color.b = ((value & 0x000000ff)) / 255;
  		};
  		Color.WHITE = new Color(1, 1, 1, 1);
  		Color.RED = new Color(1, 0, 0, 1);
  		Color.GREEN = new Color(0, 1, 0, 1);
  		Color.BLUE = new Color(0, 0, 1, 1);
  		Color.MAGENTA = new Color(1, 0, 1, 1);
  		return Color;
  	}());
  	spine.Color = Color;
  	var MathUtils = (function () {
  		function MathUtils() {
  		}
  		MathUtils.clamp = function (value, min, max) {
  			if (value < min)
  				return min;
  			if (value > max)
  				return max;
  			return value;
  		};
  		MathUtils.cosDeg = function (degrees) {
  			return Math.cos(degrees * MathUtils.degRad);
  		};
  		MathUtils.sinDeg = function (degrees) {
  			return Math.sin(degrees * MathUtils.degRad);
  		};
  		MathUtils.signum = function (value) {
  			return value > 0 ? 1 : value < 0 ? -1 : 0;
  		};
  		MathUtils.toInt = function (x) {
  			return x > 0 ? Math.floor(x) : Math.ceil(x);
  		};
  		MathUtils.cbrt = function (x) {
  			var y = Math.pow(Math.abs(x), 1 / 3);
  			return x < 0 ? -y : y;
  		};
  		MathUtils.randomTriangular = function (min, max) {
  			return MathUtils.randomTriangularWith(min, max, (min + max) * 0.5);
  		};
  		MathUtils.randomTriangularWith = function (min, max, mode) {
  			var u = Math.random();
  			var d = max - min;
  			if (u <= (mode - min) / d)
  				return min + Math.sqrt(u * d * (mode - min));
  			return max - Math.sqrt((1 - u) * d * (max - mode));
  		};
  		MathUtils.PI = 3.1415927;
  		MathUtils.PI2 = MathUtils.PI * 2;
  		MathUtils.radiansToDegrees = 180 / MathUtils.PI;
  		MathUtils.radDeg = MathUtils.radiansToDegrees;
  		MathUtils.degreesToRadians = MathUtils.PI / 180;
  		MathUtils.degRad = MathUtils.degreesToRadians;
  		return MathUtils;
  	}());
  	spine.MathUtils = MathUtils;
  	var Interpolation = (function () {
  		function Interpolation() {
  		}
  		Interpolation.prototype.apply = function (start, end, a) {
  			return start + (end - start) * this.applyInternal(a);
  		};
  		return Interpolation;
  	}());
  	spine.Interpolation = Interpolation;
  	var Pow = (function (_super) {
  		__extends(Pow, _super);
  		function Pow(power) {
  			var _this = _super.call(this) || this;
  			_this.power = 2;
  			_this.power = power;
  			return _this;
  		}
  		Pow.prototype.applyInternal = function (a) {
  			if (a <= 0.5)
  				return Math.pow(a * 2, this.power) / 2;
  			return Math.pow((a - 1) * 2, this.power) / (this.power % 2 == 0 ? -2 : 2) + 1;
  		};
  		return Pow;
  	}(Interpolation));
  	spine.Pow = Pow;
  	var PowOut = (function (_super) {
  		__extends(PowOut, _super);
  		function PowOut(power) {
  			return _super.call(this, power) || this;
  		}
  		PowOut.prototype.applyInternal = function (a) {
  			return Math.pow(a - 1, this.power) * (this.power % 2 == 0 ? -1 : 1) + 1;
  		};
  		return PowOut;
  	}(Pow));
  	spine.PowOut = PowOut;
  	var Utils = (function () {
  		function Utils() {
  		}
  		Utils.arrayCopy = function (source, sourceStart, dest, destStart, numElements) {
  			for (var i = sourceStart, j = destStart; i < sourceStart + numElements; i++, j++) {
  				dest[j] = source[i];
  			}
  		};
  		Utils.setArraySize = function (array, size, value) {
  			if (value === void 0) { value = 0; }
  			var oldSize = array.length;
  			if (oldSize == size)
  				return array;
  			array.length = size;
  			if (oldSize < size) {
  				for (var i = oldSize; i < size; i++)
  					array[i] = value;
  			}
  			return array;
  		};
  		Utils.ensureArrayCapacity = function (array, size, value) {
  			if (value === void 0) { value = 0; }
  			if (array.length >= size)
  				return array;
  			return Utils.setArraySize(array, size, value);
  		};
  		Utils.newArray = function (size, defaultValue) {
  			var array = new Array(size);
  			for (var i = 0; i < size; i++)
  				array[i] = defaultValue;
  			return array;
  		};
  		Utils.newFloatArray = function (size) {
  			if (Utils.SUPPORTS_TYPED_ARRAYS) {
  				return new Float32Array(size);
  			}
  			else {
  				var array = new Array(size);
  				for (var i = 0; i < array.length; i++)
  					array[i] = 0;
  				return array;
  			}
  		};
  		Utils.newShortArray = function (size) {
  			if (Utils.SUPPORTS_TYPED_ARRAYS) {
  				return new Int16Array(size);
  			}
  			else {
  				var array = new Array(size);
  				for (var i = 0; i < array.length; i++)
  					array[i] = 0;
  				return array;
  			}
  		};
  		Utils.toFloatArray = function (array) {
  			return Utils.SUPPORTS_TYPED_ARRAYS ? new Float32Array(array) : array;
  		};
  		Utils.toSinglePrecision = function (value) {
  			return Utils.SUPPORTS_TYPED_ARRAYS ? Math.fround(value) : value;
  		};
  		Utils.webkit602BugfixHelper = function (alpha, blend) {
  		};
  		Utils.contains = function (array, element, identity) {
  			if (identity === void 0) { identity = true; }
  			for (var i = 0; i < array.length; i++) {
  				if (array[i] == element)
  					return true;
  			}
  			return false;
  		};
  		Utils.SUPPORTS_TYPED_ARRAYS = typeof (Float32Array) !== "undefined";
  		return Utils;
  	}());
  	spine.Utils = Utils;
  	var DebugUtils = (function () {
  		function DebugUtils() {
  		}
  		DebugUtils.logBones = function (skeleton) {
  			for (var i = 0; i < skeleton.bones.length; i++) {
  				var bone = skeleton.bones[i];
  				console.log(bone.data.name + ", " + bone.a + ", " + bone.b + ", " + bone.c + ", " + bone.d + ", " + bone.worldX + ", " + bone.worldY);
  			}
  		};
  		return DebugUtils;
  	}());
  	spine.DebugUtils = DebugUtils;
  	var Pool = (function () {
  		function Pool(instantiator) {
  			this.items = new Array();
  			this.instantiator = instantiator;
  		}
  		Pool.prototype.obtain = function () {
  			return this.items.length > 0 ? this.items.pop() : this.instantiator();
  		};
  		Pool.prototype.free = function (item) {
  			if (item.reset)
  				item.reset();
  			this.items.push(item);
  		};
  		Pool.prototype.freeAll = function (items) {
  			for (var i = 0; i < items.length; i++) {
  				if (items[i].reset)
  					items[i].reset();
  				this.items[i] = items[i];
  			}
  		};
  		Pool.prototype.clear = function () {
  			this.items.length = 0;
  		};
  		return Pool;
  	}());
  	spine.Pool = Pool;
  	var Vector2 = (function () {
  		function Vector2(x, y) {
  			if (x === void 0) { x = 0; }
  			if (y === void 0) { y = 0; }
  			this.x = x;
  			this.y = y;
  		}
  		Vector2.prototype.set = function (x, y) {
  			this.x = x;
  			this.y = y;
  			return this;
  		};
  		Vector2.prototype.length = function () {
  			var x = this.x;
  			var y = this.y;
  			return Math.sqrt(x * x + y * y);
  		};
  		Vector2.prototype.normalize = function () {
  			var len = this.length();
  			if (len != 0) {
  				this.x /= len;
  				this.y /= len;
  			}
  			return this;
  		};
  		return Vector2;
  	}());
  	spine.Vector2 = Vector2;
  	var TimeKeeper = (function () {
  		function TimeKeeper() {
  			this.maxDelta = 0.064;
  			this.framesPerSecond = 0;
  			this.delta = 0;
  			this.totalTime = 0;
  			this.lastTime = Date.now() / 1000;
  			this.frameCount = 0;
  			this.frameTime = 0;
  		}
  		TimeKeeper.prototype.update = function () {
  			var now = Date.now() / 1000;
  			this.delta = now - this.lastTime;
  			this.frameTime += this.delta;
  			this.totalTime += this.delta;
  			if (this.delta > this.maxDelta)
  				this.delta = this.maxDelta;
  			this.lastTime = now;
  			this.frameCount++;
  			if (this.frameTime > 1) {
  				this.framesPerSecond = this.frameCount / this.frameTime;
  				this.frameTime = 0;
  				this.frameCount = 0;
  			}
  		};
  		return TimeKeeper;
  	}());
  	spine.TimeKeeper = TimeKeeper;
  	var WindowedMean = (function () {
  		function WindowedMean(windowSize) {
  			if (windowSize === void 0) { windowSize = 32; }
  			this.addedValues = 0;
  			this.lastValue = 0;
  			this.mean = 0;
  			this.dirty = true;
  			this.values = new Array(windowSize);
  		}
  		WindowedMean.prototype.hasEnoughData = function () {
  			return this.addedValues >= this.values.length;
  		};
  		WindowedMean.prototype.addValue = function (value) {
  			if (this.addedValues < this.values.length)
  				this.addedValues++;
  			this.values[this.lastValue++] = value;
  			if (this.lastValue > this.values.length - 1)
  				this.lastValue = 0;
  			this.dirty = true;
  		};
  		WindowedMean.prototype.getMean = function () {
  			if (this.hasEnoughData()) {
  				if (this.dirty) {
  					var mean = 0;
  					for (var i = 0; i < this.values.length; i++) {
  						mean += this.values[i];
  					}
  					this.mean = mean / this.values.length;
  					this.dirty = false;
  				}
  				return this.mean;
  			}
  			else {
  				return 0;
  			}
  		};
  		return WindowedMean;
  	}());
  	spine.WindowedMean = WindowedMean;
  })(spine || (spine = {}));
  (function () {
  	if (!Math.fround) {
  		Math.fround = (function (array) {
  			return function (x) {
  				return array[0] = x, array[0];
  			};
  		})(new Float32Array(1));
  	}
  })();
  var spine;
  (function (spine) {
  	var Attachment = (function () {
  		function Attachment(name) {
  			if (name == null)
  				throw new Error("name cannot be null.");
  			this.name = name;
  		}
  		return Attachment;
  	}());
  	spine.Attachment = Attachment;
  	var VertexAttachment = (function (_super) {
  		__extends(VertexAttachment, _super);
  		function VertexAttachment(name) {
  			var _this = _super.call(this, name) || this;
  			_this.id = (VertexAttachment.nextID++ & 65535) << 11;
  			_this.worldVerticesLength = 0;
  			_this.deformAttachment = _this;
  			return _this;
  		}
  		VertexAttachment.prototype.computeWorldVertices = function (slot, start, count, worldVertices, offset, stride) {
  			count = offset + (count >> 1) * stride;
  			var skeleton = slot.bone.skeleton;
  			var deformArray = slot.deform;
  			var vertices = this.vertices;
  			var bones = this.bones;
  			if (bones == null) {
  				if (deformArray.length > 0)
  					vertices = deformArray;
  				var bone = slot.bone;
  				var x = bone.worldX;
  				var y = bone.worldY;
  				var a = bone.a, b = bone.b, c = bone.c, d = bone.d;
  				for (var v_1 = start, w = offset; w < count; v_1 += 2, w += stride) {
  					var vx = vertices[v_1], vy = vertices[v_1 + 1];
  					worldVertices[w] = vx * a + vy * b + x;
  					worldVertices[w + 1] = vx * c + vy * d + y;
  				}
  				return;
  			}
  			var v = 0, skip = 0;
  			for (var i = 0; i < start; i += 2) {
  				var n = bones[v];
  				v += n + 1;
  				skip += n;
  			}
  			var skeletonBones = skeleton.bones;
  			if (deformArray.length == 0) {
  				for (var w = offset, b = skip * 3; w < count; w += stride) {
  					var wx = 0, wy = 0;
  					var n = bones[v++];
  					n += v;
  					for (; v < n; v++, b += 3) {
  						var bone = skeletonBones[bones[v]];
  						var vx = vertices[b], vy = vertices[b + 1], weight = vertices[b + 2];
  						wx += (vx * bone.a + vy * bone.b + bone.worldX) * weight;
  						wy += (vx * bone.c + vy * bone.d + bone.worldY) * weight;
  					}
  					worldVertices[w] = wx;
  					worldVertices[w + 1] = wy;
  				}
  			}
  			else {
  				var deform = deformArray;
  				for (var w = offset, b = skip * 3, f = skip << 1; w < count; w += stride) {
  					var wx = 0, wy = 0;
  					var n = bones[v++];
  					n += v;
  					for (; v < n; v++, b += 3, f += 2) {
  						var bone = skeletonBones[bones[v]];
  						var vx = vertices[b] + deform[f], vy = vertices[b + 1] + deform[f + 1], weight = vertices[b + 2];
  						wx += (vx * bone.a + vy * bone.b + bone.worldX) * weight;
  						wy += (vx * bone.c + vy * bone.d + bone.worldY) * weight;
  					}
  					worldVertices[w] = wx;
  					worldVertices[w + 1] = wy;
  				}
  			}
  		};
  		VertexAttachment.prototype.copyTo = function (attachment) {
  			if (this.bones != null) {
  				attachment.bones = new Array(this.bones.length);
  				spine.Utils.arrayCopy(this.bones, 0, attachment.bones, 0, this.bones.length);
  			}
  			else
  				attachment.bones = null;
  			if (this.vertices != null) {
  				attachment.vertices = spine.Utils.newFloatArray(this.vertices.length);
  				spine.Utils.arrayCopy(this.vertices, 0, attachment.vertices, 0, this.vertices.length);
  			}
  			else
  				attachment.vertices = null;
  			attachment.worldVerticesLength = this.worldVerticesLength;
  			attachment.deformAttachment = this.deformAttachment;
  		};
  		VertexAttachment.nextID = 0;
  		return VertexAttachment;
  	}(Attachment));
  	spine.VertexAttachment = VertexAttachment;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var AttachmentType;
  	(function (AttachmentType) {
  		AttachmentType[AttachmentType["Region"] = 0] = "Region";
  		AttachmentType[AttachmentType["BoundingBox"] = 1] = "BoundingBox";
  		AttachmentType[AttachmentType["Mesh"] = 2] = "Mesh";
  		AttachmentType[AttachmentType["LinkedMesh"] = 3] = "LinkedMesh";
  		AttachmentType[AttachmentType["Path"] = 4] = "Path";
  		AttachmentType[AttachmentType["Point"] = 5] = "Point";
  		AttachmentType[AttachmentType["Clipping"] = 6] = "Clipping";
  	})(AttachmentType = spine.AttachmentType || (spine.AttachmentType = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var BoundingBoxAttachment = (function (_super) {
  		__extends(BoundingBoxAttachment, _super);
  		function BoundingBoxAttachment(name) {
  			var _this = _super.call(this, name) || this;
  			_this.color = new spine.Color(1, 1, 1, 1);
  			return _this;
  		}
  		BoundingBoxAttachment.prototype.copy = function () {
  			var copy = new BoundingBoxAttachment(name);
  			this.copyTo(copy);
  			copy.color.setFromColor(this.color);
  			return copy;
  		};
  		return BoundingBoxAttachment;
  	}(spine.VertexAttachment));
  	spine.BoundingBoxAttachment = BoundingBoxAttachment;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var ClippingAttachment = (function (_super) {
  		__extends(ClippingAttachment, _super);
  		function ClippingAttachment(name) {
  			var _this = _super.call(this, name) || this;
  			_this.color = new spine.Color(0.2275, 0.2275, 0.8078, 1);
  			return _this;
  		}
  		ClippingAttachment.prototype.copy = function () {
  			var copy = new ClippingAttachment(name);
  			this.copyTo(copy);
  			copy.endSlot = this.endSlot;
  			copy.color.setFromColor(this.color);
  			return copy;
  		};
  		return ClippingAttachment;
  	}(spine.VertexAttachment));
  	spine.ClippingAttachment = ClippingAttachment;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var MeshAttachment = (function (_super) {
  		__extends(MeshAttachment, _super);
  		function MeshAttachment(name) {
  			var _this = _super.call(this, name) || this;
  			_this.color = new spine.Color(1, 1, 1, 1);
  			_this.tempColor = new spine.Color(0, 0, 0, 0);
  			return _this;
  		}
  		MeshAttachment.prototype.updateUVs = function () {
  			var regionUVs = this.regionUVs;
  			if (this.uvs == null || this.uvs.length != regionUVs.length)
  				this.uvs = spine.Utils.newFloatArray(regionUVs.length);
  			var uvs = this.uvs;
  			var n = this.uvs.length;
  			var u = this.region.u, v = this.region.v, width = 0, height = 0;
  			if (this.region instanceof spine.TextureAtlasRegion) {
  				var region = this.region;
  				var textureWidth = region.texture.getImage().width, textureHeight = region.texture.getImage().height;
  				switch (region.degrees) {
  					case 90:
  						u -= (region.originalHeight - region.offsetY - region.height) / textureWidth;
  						v -= (region.originalWidth - region.offsetX - region.width) / textureHeight;
  						width = region.originalHeight / textureWidth;
  						height = region.originalWidth / textureHeight;
  						for (var i = 0; i < n; i += 2) {
  							uvs[i] = u + regionUVs[i + 1] * width;
  							uvs[i + 1] = v + (1 - regionUVs[i]) * height;
  						}
  						return;
  					case 180:
  						u -= (region.originalWidth - region.offsetX - region.width) / textureWidth;
  						v -= region.offsetY / textureHeight;
  						width = region.originalWidth / textureWidth;
  						height = region.originalHeight / textureHeight;
  						for (var i = 0; i < n; i += 2) {
  							uvs[i] = u + (1 - regionUVs[i]) * width;
  							uvs[i + 1] = v + (1 - regionUVs[i + 1]) * height;
  						}
  						return;
  					case 270:
  						u -= region.offsetY / textureWidth;
  						v -= region.offsetX / textureHeight;
  						width = region.originalHeight / textureWidth;
  						height = region.originalWidth / textureHeight;
  						for (var i = 0; i < n; i += 2) {
  							uvs[i] = u + (1 - regionUVs[i + 1]) * width;
  							uvs[i + 1] = v + regionUVs[i] * height;
  						}
  						return;
  				}
  				u -= region.offsetX / textureWidth;
  				v -= (region.originalHeight - region.offsetY - region.height) / textureHeight;
  				width = region.originalWidth / textureWidth;
  				height = region.originalHeight / textureHeight;
  			}
  			else if (this.region == null) {
  				u = v = 0;
  				width = height = 1;
  			}
  			else {
  				width = this.region.u2 - u;
  				height = this.region.v2 - v;
  			}
  			for (var i = 0; i < n; i += 2) {
  				uvs[i] = u + regionUVs[i] * width;
  				uvs[i + 1] = v + regionUVs[i + 1] * height;
  			}
  		};
  		MeshAttachment.prototype.getParentMesh = function () {
  			return this.parentMesh;
  		};
  		MeshAttachment.prototype.setParentMesh = function (parentMesh) {
  			this.parentMesh = parentMesh;
  			if (parentMesh != null) {
  				this.bones = parentMesh.bones;
  				this.vertices = parentMesh.vertices;
  				this.worldVerticesLength = parentMesh.worldVerticesLength;
  				this.regionUVs = parentMesh.regionUVs;
  				this.triangles = parentMesh.triangles;
  				this.hullLength = parentMesh.hullLength;
  				this.worldVerticesLength = parentMesh.worldVerticesLength;
  			}
  		};
  		MeshAttachment.prototype.copy = function () {
  			if (this.parentMesh != null)
  				return this.newLinkedMesh();
  			var copy = new MeshAttachment(this.name);
  			copy.region = this.region;
  			copy.path = this.path;
  			copy.color.setFromColor(this.color);
  			this.copyTo(copy);
  			copy.regionUVs = new Array(this.regionUVs.length);
  			spine.Utils.arrayCopy(this.regionUVs, 0, copy.regionUVs, 0, this.regionUVs.length);
  			copy.uvs = new Array(this.uvs.length);
  			spine.Utils.arrayCopy(this.uvs, 0, copy.uvs, 0, this.uvs.length);
  			copy.triangles = new Array(this.triangles.length);
  			spine.Utils.arrayCopy(this.triangles, 0, copy.triangles, 0, this.triangles.length);
  			copy.hullLength = this.hullLength;
  			if (this.edges != null) {
  				copy.edges = new Array(this.edges.length);
  				spine.Utils.arrayCopy(this.edges, 0, copy.edges, 0, this.edges.length);
  			}
  			copy.width = this.width;
  			copy.height = this.height;
  			return copy;
  		};
  		MeshAttachment.prototype.newLinkedMesh = function () {
  			var copy = new MeshAttachment(this.name);
  			copy.region = this.region;
  			copy.path = this.path;
  			copy.color.setFromColor(this.color);
  			copy.deformAttachment = this.deformAttachment;
  			copy.setParentMesh(this.parentMesh != null ? this.parentMesh : this);
  			copy.updateUVs();
  			return copy;
  		};
  		return MeshAttachment;
  	}(spine.VertexAttachment));
  	spine.MeshAttachment = MeshAttachment;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var PathAttachment = (function (_super) {
  		__extends(PathAttachment, _super);
  		function PathAttachment(name) {
  			var _this = _super.call(this, name) || this;
  			_this.closed = false;
  			_this.constantSpeed = false;
  			_this.color = new spine.Color(1, 1, 1, 1);
  			return _this;
  		}
  		PathAttachment.prototype.copy = function () {
  			var copy = new PathAttachment(name);
  			this.copyTo(copy);
  			copy.lengths = new Array(this.lengths.length);
  			spine.Utils.arrayCopy(this.lengths, 0, copy.lengths, 0, this.lengths.length);
  			copy.closed = closed;
  			copy.constantSpeed = this.constantSpeed;
  			copy.color.setFromColor(this.color);
  			return copy;
  		};
  		return PathAttachment;
  	}(spine.VertexAttachment));
  	spine.PathAttachment = PathAttachment;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var PointAttachment = (function (_super) {
  		__extends(PointAttachment, _super);
  		function PointAttachment(name) {
  			var _this = _super.call(this, name) || this;
  			_this.color = new spine.Color(0.38, 0.94, 0, 1);
  			return _this;
  		}
  		PointAttachment.prototype.computeWorldPosition = function (bone, point) {
  			point.x = this.x * bone.a + this.y * bone.b + bone.worldX;
  			point.y = this.x * bone.c + this.y * bone.d + bone.worldY;
  			return point;
  		};
  		PointAttachment.prototype.computeWorldRotation = function (bone) {
  			var cos = spine.MathUtils.cosDeg(this.rotation), sin = spine.MathUtils.sinDeg(this.rotation);
  			var x = cos * bone.a + sin * bone.b;
  			var y = cos * bone.c + sin * bone.d;
  			return Math.atan2(y, x) * spine.MathUtils.radDeg;
  		};
  		PointAttachment.prototype.copy = function () {
  			var copy = new PointAttachment(name);
  			copy.x = this.x;
  			copy.y = this.y;
  			copy.rotation = this.rotation;
  			copy.color.setFromColor(this.color);
  			return copy;
  		};
  		return PointAttachment;
  	}(spine.VertexAttachment));
  	spine.PointAttachment = PointAttachment;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var RegionAttachment = (function (_super) {
  		__extends(RegionAttachment, _super);
  		function RegionAttachment(name) {
  			var _this = _super.call(this, name) || this;
  			_this.x = 0;
  			_this.y = 0;
  			_this.scaleX = 1;
  			_this.scaleY = 1;
  			_this.rotation = 0;
  			_this.width = 0;
  			_this.height = 0;
  			_this.color = new spine.Color(1, 1, 1, 1);
  			_this.offset = spine.Utils.newFloatArray(8);
  			_this.uvs = spine.Utils.newFloatArray(8);
  			_this.tempColor = new spine.Color(1, 1, 1, 1);
  			return _this;
  		}
  		RegionAttachment.prototype.updateOffset = function () {
  			var regionScaleX = this.width / this.region.originalWidth * this.scaleX;
  			var regionScaleY = this.height / this.region.originalHeight * this.scaleY;
  			var localX = -this.width / 2 * this.scaleX + this.region.offsetX * regionScaleX;
  			var localY = -this.height / 2 * this.scaleY + this.region.offsetY * regionScaleY;
  			var localX2 = localX + this.region.width * regionScaleX;
  			var localY2 = localY + this.region.height * regionScaleY;
  			var radians = this.rotation * Math.PI / 180;
  			var cos = Math.cos(radians);
  			var sin = Math.sin(radians);
  			var localXCos = localX * cos + this.x;
  			var localXSin = localX * sin;
  			var localYCos = localY * cos + this.y;
  			var localYSin = localY * sin;
  			var localX2Cos = localX2 * cos + this.x;
  			var localX2Sin = localX2 * sin;
  			var localY2Cos = localY2 * cos + this.y;
  			var localY2Sin = localY2 * sin;
  			var offset = this.offset;
  			offset[RegionAttachment.OX1] = localXCos - localYSin;
  			offset[RegionAttachment.OY1] = localYCos + localXSin;
  			offset[RegionAttachment.OX2] = localXCos - localY2Sin;
  			offset[RegionAttachment.OY2] = localY2Cos + localXSin;
  			offset[RegionAttachment.OX3] = localX2Cos - localY2Sin;
  			offset[RegionAttachment.OY3] = localY2Cos + localX2Sin;
  			offset[RegionAttachment.OX4] = localX2Cos - localYSin;
  			offset[RegionAttachment.OY4] = localYCos + localX2Sin;
  		};
  		RegionAttachment.prototype.setRegion = function (region) {
  			this.region = region;
  			var uvs = this.uvs;
  			if (region.rotate) {
  				uvs[2] = region.u;
  				uvs[3] = region.v2;
  				uvs[4] = region.u;
  				uvs[5] = region.v;
  				uvs[6] = region.u2;
  				uvs[7] = region.v;
  				uvs[0] = region.u2;
  				uvs[1] = region.v2;
  			}
  			else {
  				uvs[0] = region.u;
  				uvs[1] = region.v2;
  				uvs[2] = region.u;
  				uvs[3] = region.v;
  				uvs[4] = region.u2;
  				uvs[5] = region.v;
  				uvs[6] = region.u2;
  				uvs[7] = region.v2;
  			}
  		};
  		RegionAttachment.prototype.computeWorldVertices = function (bone, worldVertices, offset, stride) {
  			var vertexOffset = this.offset;
  			var x = bone.worldX, y = bone.worldY;
  			var a = bone.a, b = bone.b, c = bone.c, d = bone.d;
  			var offsetX = 0, offsetY = 0;
  			offsetX = vertexOffset[RegionAttachment.OX1];
  			offsetY = vertexOffset[RegionAttachment.OY1];
  			worldVertices[offset] = offsetX * a + offsetY * b + x;
  			worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
  			offset += stride;
  			offsetX = vertexOffset[RegionAttachment.OX2];
  			offsetY = vertexOffset[RegionAttachment.OY2];
  			worldVertices[offset] = offsetX * a + offsetY * b + x;
  			worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
  			offset += stride;
  			offsetX = vertexOffset[RegionAttachment.OX3];
  			offsetY = vertexOffset[RegionAttachment.OY3];
  			worldVertices[offset] = offsetX * a + offsetY * b + x;
  			worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
  			offset += stride;
  			offsetX = vertexOffset[RegionAttachment.OX4];
  			offsetY = vertexOffset[RegionAttachment.OY4];
  			worldVertices[offset] = offsetX * a + offsetY * b + x;
  			worldVertices[offset + 1] = offsetX * c + offsetY * d + y;
  		};
  		RegionAttachment.prototype.copy = function () {
  			var copy = new RegionAttachment(name);
  			copy.region = this.region;
  			copy.rendererObject = this.rendererObject;
  			copy.path = this.path;
  			copy.x = this.x;
  			copy.y = this.y;
  			copy.scaleX = this.scaleX;
  			copy.scaleY = this.scaleY;
  			copy.rotation = this.rotation;
  			copy.width = this.width;
  			copy.height = this.height;
  			spine.Utils.arrayCopy(this.uvs, 0, copy.uvs, 0, 8);
  			spine.Utils.arrayCopy(this.offset, 0, copy.offset, 0, 8);
  			copy.color.setFromColor(this.color);
  			return copy;
  		};
  		RegionAttachment.OX1 = 0;
  		RegionAttachment.OY1 = 1;
  		RegionAttachment.OX2 = 2;
  		RegionAttachment.OY2 = 3;
  		RegionAttachment.OX3 = 4;
  		RegionAttachment.OY3 = 5;
  		RegionAttachment.OX4 = 6;
  		RegionAttachment.OY4 = 7;
  		RegionAttachment.X1 = 0;
  		RegionAttachment.Y1 = 1;
  		RegionAttachment.C1R = 2;
  		RegionAttachment.C1G = 3;
  		RegionAttachment.C1B = 4;
  		RegionAttachment.C1A = 5;
  		RegionAttachment.U1 = 6;
  		RegionAttachment.V1 = 7;
  		RegionAttachment.X2 = 8;
  		RegionAttachment.Y2 = 9;
  		RegionAttachment.C2R = 10;
  		RegionAttachment.C2G = 11;
  		RegionAttachment.C2B = 12;
  		RegionAttachment.C2A = 13;
  		RegionAttachment.U2 = 14;
  		RegionAttachment.V2 = 15;
  		RegionAttachment.X3 = 16;
  		RegionAttachment.Y3 = 17;
  		RegionAttachment.C3R = 18;
  		RegionAttachment.C3G = 19;
  		RegionAttachment.C3B = 20;
  		RegionAttachment.C3A = 21;
  		RegionAttachment.U3 = 22;
  		RegionAttachment.V3 = 23;
  		RegionAttachment.X4 = 24;
  		RegionAttachment.Y4 = 25;
  		RegionAttachment.C4R = 26;
  		RegionAttachment.C4G = 27;
  		RegionAttachment.C4B = 28;
  		RegionAttachment.C4A = 29;
  		RegionAttachment.U4 = 30;
  		RegionAttachment.V4 = 31;
  		return RegionAttachment;
  	}(spine.Attachment));
  	spine.RegionAttachment = RegionAttachment;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var JitterEffect = (function () {
  		function JitterEffect(jitterX, jitterY) {
  			this.jitterX = 0;
  			this.jitterY = 0;
  			this.jitterX = jitterX;
  			this.jitterY = jitterY;
  		}
  		JitterEffect.prototype.begin = function (skeleton) {
  		};
  		JitterEffect.prototype.transform = function (position, uv, light, dark) {
  			position.x += spine.MathUtils.randomTriangular(-this.jitterX, this.jitterY);
  			position.y += spine.MathUtils.randomTriangular(-this.jitterX, this.jitterY);
  		};
  		JitterEffect.prototype.end = function () {
  		};
  		return JitterEffect;
  	}());
  	spine.JitterEffect = JitterEffect;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var SwirlEffect = (function () {
  		function SwirlEffect(radius) {
  			this.centerX = 0;
  			this.centerY = 0;
  			this.radius = 0;
  			this.angle = 0;
  			this.worldX = 0;
  			this.worldY = 0;
  			this.radius = radius;
  		}
  		SwirlEffect.prototype.begin = function (skeleton) {
  			this.worldX = skeleton.x + this.centerX;
  			this.worldY = skeleton.y + this.centerY;
  		};
  		SwirlEffect.prototype.transform = function (position, uv, light, dark) {
  			var radAngle = this.angle * spine.MathUtils.degreesToRadians;
  			var x = position.x - this.worldX;
  			var y = position.y - this.worldY;
  			var dist = Math.sqrt(x * x + y * y);
  			if (dist < this.radius) {
  				var theta = SwirlEffect.interpolation.apply(0, radAngle, (this.radius - dist) / this.radius);
  				var cos = Math.cos(theta);
  				var sin = Math.sin(theta);
  				position.x = cos * x - sin * y + this.worldX;
  				position.y = sin * x + cos * y + this.worldY;
  			}
  		};
  		SwirlEffect.prototype.end = function () {
  		};
  		SwirlEffect.interpolation = new spine.PowOut(2);
  		return SwirlEffect;
  	}());
  	spine.SwirlEffect = SwirlEffect;
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var webgl;
  	(function (webgl) {
  		var AssetManager = (function (_super) {
  			__extends(AssetManager, _super);
  			function AssetManager(context, pathPrefix) {
  				if (pathPrefix === void 0) { pathPrefix = ""; }
  				return _super.call(this, function (image) {
  					return new spine.webgl.GLTexture(context, image);
  				}, pathPrefix) || this;
  			}
  			return AssetManager;
  		}(spine.AssetManager));
  		webgl.AssetManager = AssetManager;
  	})(webgl = spine.webgl || (spine.webgl = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var webgl;
  	(function (webgl) {
  		var OrthoCamera = (function () {
  			function OrthoCamera(viewportWidth, viewportHeight) {
  				this.position = new webgl.Vector3(0, 0, 0);
  				this.direction = new webgl.Vector3(0, 0, -1);
  				this.up = new webgl.Vector3(0, 1, 0);
  				this.near = 0;
  				this.far = 100;
  				this.zoom = 1;
  				this.viewportWidth = 0;
  				this.viewportHeight = 0;
  				this.projectionView = new webgl.Matrix4();
  				this.inverseProjectionView = new webgl.Matrix4();
  				this.projection = new webgl.Matrix4();
  				this.view = new webgl.Matrix4();
  				this.tmp = new webgl.Vector3();
  				this.viewportWidth = viewportWidth;
  				this.viewportHeight = viewportHeight;
  				this.update();
  			}
  			OrthoCamera.prototype.update = function () {
  				var projection = this.projection;
  				var view = this.view;
  				var projectionView = this.projectionView;
  				var inverseProjectionView = this.inverseProjectionView;
  				var zoom = this.zoom, viewportWidth = this.viewportWidth, viewportHeight = this.viewportHeight;
  				projection.ortho(zoom * (-viewportWidth / 2), zoom * (viewportWidth / 2), zoom * (-viewportHeight / 2), zoom * (viewportHeight / 2), this.near, this.far);
  				view.lookAt(this.position, this.direction, this.up);
  				projectionView.set(projection.values);
  				projectionView.multiply(view);
  				inverseProjectionView.set(projectionView.values).invert();
  			};
  			OrthoCamera.prototype.screenToWorld = function (screenCoords, screenWidth, screenHeight) {
  				var x = screenCoords.x, y = screenHeight - screenCoords.y - 1;
  				var tmp = this.tmp;
  				tmp.x = (2 * x) / screenWidth - 1;
  				tmp.y = (2 * y) / screenHeight - 1;
  				tmp.z = (2 * screenCoords.z) - 1;
  				tmp.project(this.inverseProjectionView);
  				screenCoords.set(tmp.x, tmp.y, tmp.z);
  				return screenCoords;
  			};
  			OrthoCamera.prototype.setViewport = function (viewportWidth, viewportHeight) {
  				this.viewportWidth = viewportWidth;
  				this.viewportHeight = viewportHeight;
  			};
  			return OrthoCamera;
  		}());
  		webgl.OrthoCamera = OrthoCamera;
  	})(webgl = spine.webgl || (spine.webgl = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var webgl;
  	(function (webgl) {
  		var GLTexture = (function (_super) {
  			__extends(GLTexture, _super);
  			function GLTexture(context, image, useMipMaps) {
  				if (useMipMaps === void 0) { useMipMaps = false; }
  				var _this = _super.call(this, image) || this;
  				_this.texture = null;
  				_this.boundUnit = 0;
  				_this.useMipMaps = false;
  				_this.context = context instanceof webgl.ManagedWebGLRenderingContext ? context : new webgl.ManagedWebGLRenderingContext(context);
  				_this.useMipMaps = useMipMaps;
  				_this.restore();
  				_this.context.addRestorable(_this);
  				return _this;
  			}
  			GLTexture.prototype.setFilters = function (minFilter, magFilter) {
  				var gl = this.context.gl;
  				this.bind();
  				gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, minFilter);
  				gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, GLTexture.validateMagFilter(magFilter));
  			};
  			GLTexture.validateMagFilter = function (magFilter) {
  				switch (magFilter) {
  					case spine.TextureFilter.MipMap:
  					case spine.TextureFilter.MipMapLinearLinear:
  					case spine.TextureFilter.MipMapLinearNearest:
  					case spine.TextureFilter.MipMapNearestLinear:
  					case spine.TextureFilter.MipMapNearestNearest:
  						return spine.TextureFilter.Linear;
  					default:
  						return magFilter;
  				}
  			};
  			GLTexture.prototype.setWraps = function (uWrap, vWrap) {
  				var gl = this.context.gl;
  				this.bind();
  				gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, uWrap);
  				gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, vWrap);
  			};
  			GLTexture.prototype.update = function (useMipMaps) {
  				var gl = this.context.gl;
  				if (!this.texture) {
  					this.texture = this.context.gl.createTexture();
  				}
  				this.bind();
  				if (GLTexture.DISABLE_UNPACK_PREMULTIPLIED_ALPHA_WEBGL)
  					gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, false);
  				gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this._image);
  				gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
  				gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, useMipMaps ? gl.LINEAR_MIPMAP_LINEAR : gl.LINEAR);
  				gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
  				gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
  				if (useMipMaps)
  					gl.generateMipmap(gl.TEXTURE_2D);
  			};
  			GLTexture.prototype.restore = function () {
  				this.texture = null;
  				this.update(this.useMipMaps);
  			};
  			GLTexture.prototype.bind = function (unit) {
  				if (unit === void 0) { unit = 0; }
  				var gl = this.context.gl;
  				this.boundUnit = unit;
  				gl.activeTexture(gl.TEXTURE0 + unit);
  				gl.bindTexture(gl.TEXTURE_2D, this.texture);
  			};
  			GLTexture.prototype.unbind = function () {
  				var gl = this.context.gl;
  				gl.activeTexture(gl.TEXTURE0 + this.boundUnit);
  				gl.bindTexture(gl.TEXTURE_2D, null);
  			};
  			GLTexture.prototype.dispose = function () {
  				this.context.removeRestorable(this);
  				var gl = this.context.gl;
  				gl.deleteTexture(this.texture);
  			};
  			GLTexture.DISABLE_UNPACK_PREMULTIPLIED_ALPHA_WEBGL = false;
  			return GLTexture;
  		}(spine.Texture));
  		webgl.GLTexture = GLTexture;
  	})(webgl = spine.webgl || (spine.webgl = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var webgl;
  	(function (webgl) {
  		var Input = (function () {
  			function Input(element) {
  				this.lastX = 0;
  				this.lastY = 0;
  				this.buttonDown = false;
  				this.currTouch = null;
  				this.touchesPool = new spine.Pool(function () {
  					return new spine.webgl.Touch(0, 0, 0);
  				});
  				this.listeners = new Array();
  				this.element = element;
  				this.setupCallbacks(element);
  			}
  			Input.prototype.setupCallbacks = function (element) {
  				var _this = this;
  				var mouseDown = function (ev) {
  					if (ev instanceof MouseEvent) {
  						var rect = element.getBoundingClientRect();
  						var x = ev.clientX - rect.left;
  						var y = ev.clientY - rect.top;
  						var listeners = _this.listeners;
  						for (var i = 0; i < listeners.length; i++) {
  							if (listeners[i].down)
  								listeners[i].down(x, y);
  						}
  						_this.lastX = x;
  						_this.lastY = y;
  						_this.buttonDown = true;
  						document.addEventListener("mousemove", mouseMove);
  						document.addEventListener("mouseup", mouseUp);
  					}
  				};
  				var mouseMove = function (ev) {
  					if (ev instanceof MouseEvent) {
  						var rect = element.getBoundingClientRect();
  						var x = ev.clientX - rect.left;
  						var y = ev.clientY - rect.top;
  						var listeners = _this.listeners;
  						for (var i = 0; i < listeners.length; i++) {
  							if (_this.buttonDown) {
  								if (listeners[i].dragged)
  									listeners[i].dragged(x, y);
  							}
  							else {
  								if (listeners[i].moved)
  									listeners[i].moved(x, y);
  							}
  						}
  						_this.lastX = x;
  						_this.lastY = y;
  					}
  				};
  				var mouseUp = function (ev) {
  					if (ev instanceof MouseEvent) {
  						var rect = element.getBoundingClientRect();
  						var x = ev.clientX - rect.left;
  						var y = ev.clientY - rect.top;
  						var listeners = _this.listeners;
  						for (var i = 0; i < listeners.length; i++) {
  							if (listeners[i].up)
  								listeners[i].up(x, y);
  						}
  						_this.lastX = x;
  						_this.lastY = y;
  						_this.buttonDown = false;
  						document.removeEventListener("mousemove", mouseMove);
  						document.removeEventListener("mouseup", mouseUp);
  					}
  				};
  				element.addEventListener("mousedown", mouseDown, true);
  				element.addEventListener("mousemove", mouseMove, true);
  				element.addEventListener("mouseup", mouseUp, true);
  				element.addEventListener("touchstart", function (ev) {
  					if (_this.currTouch != null)
  						return;
  					var touches = ev.changedTouches;
  					for (var i = 0; i < touches.length; i++) {
  						var touch = touches[i];
  						var rect = element.getBoundingClientRect();
  						var x = touch.clientX - rect.left;
  						var y = touch.clientY - rect.top;
  						_this.currTouch = _this.touchesPool.obtain();
  						_this.currTouch.identifier = touch.identifier;
  						_this.currTouch.x = x;
  						_this.currTouch.y = y;
  						break;
  					}
  					var listeners = _this.listeners;
  					for (var i_17 = 0; i_17 < listeners.length; i_17++) {
  						if (listeners[i_17].down)
  							listeners[i_17].down(_this.currTouch.x, _this.currTouch.y);
  					}
  					_this.lastX = _this.currTouch.x;
  					_this.lastY = _this.currTouch.y;
  					_this.buttonDown = true;
  					ev.preventDefault();
  				}, false);
  				element.addEventListener("touchend", function (ev) {
  					var touches = ev.changedTouches;
  					for (var i = 0; i < touches.length; i++) {
  						var touch = touches[i];
  						if (_this.currTouch.identifier === touch.identifier) {
  							var rect = element.getBoundingClientRect();
  							var x = _this.currTouch.x = touch.clientX - rect.left;
  							var y = _this.currTouch.y = touch.clientY - rect.top;
  							_this.touchesPool.free(_this.currTouch);
  							var listeners = _this.listeners;
  							for (var i_18 = 0; i_18 < listeners.length; i_18++) {
  								if (listeners[i_18].up)
  									listeners[i_18].up(x, y);
  							}
  							_this.lastX = x;
  							_this.lastY = y;
  							_this.buttonDown = false;
  							_this.currTouch = null;
  							break;
  						}
  					}
  					ev.preventDefault();
  				}, false);
  				element.addEventListener("touchcancel", function (ev) {
  					var touches = ev.changedTouches;
  					for (var i = 0; i < touches.length; i++) {
  						var touch = touches[i];
  						if (_this.currTouch.identifier === touch.identifier) {
  							var rect = element.getBoundingClientRect();
  							var x = _this.currTouch.x = touch.clientX - rect.left;
  							var y = _this.currTouch.y = touch.clientY - rect.top;
  							_this.touchesPool.free(_this.currTouch);
  							var listeners = _this.listeners;
  							for (var i_19 = 0; i_19 < listeners.length; i_19++) {
  								if (listeners[i_19].up)
  									listeners[i_19].up(x, y);
  							}
  							_this.lastX = x;
  							_this.lastY = y;
  							_this.buttonDown = false;
  							_this.currTouch = null;
  							break;
  						}
  					}
  					ev.preventDefault();
  				}, false);
  				element.addEventListener("touchmove", function (ev) {
  					if (_this.currTouch == null)
  						return;
  					var touches = ev.changedTouches;
  					for (var i = 0; i < touches.length; i++) {
  						var touch = touches[i];
  						if (_this.currTouch.identifier === touch.identifier) {
  							var rect = element.getBoundingClientRect();
  							var x = touch.clientX - rect.left;
  							var y = touch.clientY - rect.top;
  							var listeners = _this.listeners;
  							for (var i_20 = 0; i_20 < listeners.length; i_20++) {
  								if (listeners[i_20].dragged)
  									listeners[i_20].dragged(x, y);
  							}
  							_this.lastX = _this.currTouch.x = x;
  							_this.lastY = _this.currTouch.y = y;
  							break;
  						}
  					}
  					ev.preventDefault();
  				}, false);
  			};
  			Input.prototype.addListener = function (listener) {
  				this.listeners.push(listener);
  			};
  			Input.prototype.removeListener = function (listener) {
  				var idx = this.listeners.indexOf(listener);
  				if (idx > -1) {
  					this.listeners.splice(idx, 1);
  				}
  			};
  			return Input;
  		}());
  		webgl.Input = Input;
  		var Touch = (function () {
  			function Touch(identifier, x, y) {
  				this.identifier = identifier;
  				this.x = x;
  				this.y = y;
  			}
  			return Touch;
  		}());
  		webgl.Touch = Touch;
  	})(webgl = spine.webgl || (spine.webgl = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var webgl;
  	(function (webgl) {
  		var LoadingScreen = (function () {
  			function LoadingScreen(renderer) {
  				this.logo = null;
  				this.spinner = null;
  				this.angle = 0;
  				this.fadeOut = 0;
  				this.timeKeeper = new spine.TimeKeeper();
  				this.backgroundColor = new spine.Color(0.135, 0.135, 0.135, 1);
  				this.tempColor = new spine.Color();
  				this.firstDraw = 0;
  				this.renderer = renderer;
  				this.timeKeeper.maxDelta = 9;
  				if (LoadingScreen.logoImg === null) {
  					var isSafari = navigator.userAgent.indexOf("Safari") > -1;
  					LoadingScreen.logoImg = new Image();
  					LoadingScreen.logoImg.src = LoadingScreen.SPINE_LOGO_DATA;
  					if (!isSafari)
  						LoadingScreen.logoImg.crossOrigin = "anonymous";
  					LoadingScreen.logoImg.onload = function (ev) {
  						LoadingScreen.loaded++;
  					};
  					LoadingScreen.spinnerImg = new Image();
  					LoadingScreen.spinnerImg.src = LoadingScreen.SPINNER_DATA;
  					if (!isSafari)
  						LoadingScreen.spinnerImg.crossOrigin = "anonymous";
  					LoadingScreen.spinnerImg.onload = function (ev) {
  						LoadingScreen.loaded++;
  					};
  				}
  			}
  			LoadingScreen.prototype.draw = function (complete) {
  				if (complete === void 0) { complete = false; }
  				if (complete && this.fadeOut > LoadingScreen.FADE_SECONDS)
  					return;
  				this.timeKeeper.update();
  				var a = Math.abs(Math.sin(this.timeKeeper.totalTime + 0.75));
  				this.angle -= this.timeKeeper.delta / 1.4 * 360 * (1 + 1.5 * Math.pow(a, 5));
  				var renderer = this.renderer;
  				var canvas = renderer.canvas;
  				var gl = renderer.context.gl;
  				renderer.resize(webgl.ResizeMode.Stretch);
  				var oldX = renderer.camera.position.x, oldY = renderer.camera.position.y;
  				renderer.camera.position.set(canvas.width / 2, canvas.height / 2, 0);
  				renderer.camera.viewportWidth = canvas.width;
  				renderer.camera.viewportHeight = canvas.height;
  				if (!complete) {
  					gl.clearColor(this.backgroundColor.r, this.backgroundColor.g, this.backgroundColor.b, this.backgroundColor.a);
  					gl.clear(gl.COLOR_BUFFER_BIT);
  					this.tempColor.a = 1;
  				}
  				else {
  					this.fadeOut += this.timeKeeper.delta * (this.timeKeeper.totalTime < 1 ? 2 : 1);
  					if (this.fadeOut > LoadingScreen.FADE_SECONDS) {
  						renderer.camera.position.set(oldX, oldY, 0);
  						return;
  					}
  					a = 1 - this.fadeOut / LoadingScreen.FADE_SECONDS;
  					this.tempColor.setFromColor(this.backgroundColor);
  					this.tempColor.a = 1 - (a - 1) * (a - 1);
  					renderer.begin();
  					renderer.quad(true, 0, 0, canvas.width, 0, canvas.width, canvas.height, 0, canvas.height, this.tempColor, this.tempColor, this.tempColor, this.tempColor);
  					renderer.end();
  				}
  				this.tempColor.set(1, 1, 1, this.tempColor.a);
  				if (LoadingScreen.loaded != 2)
  					return;
  				if (this.logo === null) {
  					this.logo = new webgl.GLTexture(renderer.context, LoadingScreen.logoImg);
  					this.spinner = new webgl.GLTexture(renderer.context, LoadingScreen.spinnerImg);
  				}
  				this.logo.update(false);
  				this.spinner.update(false);
  				var logoWidth = this.logo.getImage().width;
  				var logoHeight = this.logo.getImage().height;
  				var spinnerWidth = this.spinner.getImage().width;
  				var spinnerHeight = this.spinner.getImage().height;
  				renderer.batcher.setBlendMode(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA);
  				renderer.begin();
  				renderer.drawTexture(this.logo, (canvas.width - logoWidth) / 2, (canvas.height - logoHeight) / 2, logoWidth, logoHeight, this.tempColor);
  				renderer.drawTextureRotated(this.spinner, (canvas.width - spinnerWidth) / 2, (canvas.height - spinnerHeight) / 2, spinnerWidth, spinnerHeight, spinnerWidth / 2, spinnerHeight / 2, this.angle, this.tempColor);
  				renderer.end();
  				renderer.camera.position.set(oldX, oldY, 0);
  			};
  			LoadingScreen.FADE_SECONDS = 1;
  			LoadingScreen.loaded = 0;
  			LoadingScreen.spinnerImg = null;
  			LoadingScreen.logoImg = null;
  			LoadingScreen.SPINNER_DATA = "data:image/png;base64,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";
  			LoadingScreen.SPINE_LOGO_DATA = "data:image/png;base64,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";
  			return LoadingScreen;
  		}());
  		webgl.LoadingScreen = LoadingScreen;
  	})(webgl = spine.webgl || (spine.webgl = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var webgl;
  	(function (webgl) {
  		webgl.M00 = 0;
  		webgl.M01 = 4;
  		webgl.M02 = 8;
  		webgl.M03 = 12;
  		webgl.M10 = 1;
  		webgl.M11 = 5;
  		webgl.M12 = 9;
  		webgl.M13 = 13;
  		webgl.M20 = 2;
  		webgl.M21 = 6;
  		webgl.M22 = 10;
  		webgl.M23 = 14;
  		webgl.M30 = 3;
  		webgl.M31 = 7;
  		webgl.M32 = 11;
  		webgl.M33 = 15;
  		var Matrix4 = (function () {
  			function Matrix4() {
  				this.temp = new Float32Array(16);
  				this.values = new Float32Array(16);
  				var v = this.values;
  				v[webgl.M00] = 1;
  				v[webgl.M11] = 1;
  				v[webgl.M22] = 1;
  				v[webgl.M33] = 1;
  			}
  			Matrix4.prototype.set = function (values) {
  				this.values.set(values);
  				return this;
  			};
  			Matrix4.prototype.transpose = function () {
  				var t = this.temp;
  				var v = this.values;
  				t[webgl.M00] = v[webgl.M00];
  				t[webgl.M01] = v[webgl.M10];
  				t[webgl.M02] = v[webgl.M20];
  				t[webgl.M03] = v[webgl.M30];
  				t[webgl.M10] = v[webgl.M01];
  				t[webgl.M11] = v[webgl.M11];
  				t[webgl.M12] = v[webgl.M21];
  				t[webgl.M13] = v[webgl.M31];
  				t[webgl.M20] = v[webgl.M02];
  				t[webgl.M21] = v[webgl.M12];
  				t[webgl.M22] = v[webgl.M22];
  				t[webgl.M23] = v[webgl.M32];
  				t[webgl.M30] = v[webgl.M03];
  				t[webgl.M31] = v[webgl.M13];
  				t[webgl.M32] = v[webgl.M23];
  				t[webgl.M33] = v[webgl.M33];
  				return this.set(t);
  			};
  			Matrix4.prototype.identity = function () {
  				var v = this.values;
  				v[webgl.M00] = 1;
  				v[webgl.M01] = 0;
  				v[webgl.M02] = 0;
  				v[webgl.M03] = 0;
  				v[webgl.M10] = 0;
  				v[webgl.M11] = 1;
  				v[webgl.M12] = 0;
  				v[webgl.M13] = 0;
  				v[webgl.M20] = 0;
  				v[webgl.M21] = 0;
  				v[webgl.M22] = 1;
  				v[webgl.M23] = 0;
  				v[webgl.M30] = 0;
  				v[webgl.M31] = 0;
  				v[webgl.M32] = 0;
  				v[webgl.M33] = 1;
  				return this;
  			};
  			Matrix4.prototype.invert = function () {
  				var v = this.values;
  				var t = this.temp;
  				var l_det = v[webgl.M30] * v[webgl.M21] * v[webgl.M12] * v[webgl.M03] - v[webgl.M20] * v[webgl.M31] * v[webgl.M12] * v[webgl.M03] - v[webgl.M30] * v[webgl.M11] * v[webgl.M22] * v[webgl.M03]
  					+ v[webgl.M10] * v[webgl.M31] * v[webgl.M22] * v[webgl.M03] + v[webgl.M20] * v[webgl.M11] * v[webgl.M32] * v[webgl.M03] - v[webgl.M10] * v[webgl.M21] * v[webgl.M32] * v[webgl.M03]
  					- v[webgl.M30] * v[webgl.M21] * v[webgl.M02] * v[webgl.M13] + v[webgl.M20] * v[webgl.M31] * v[webgl.M02] * v[webgl.M13] + v[webgl.M30] * v[webgl.M01] * v[webgl.M22] * v[webgl.M13]
  					- v[webgl.M00] * v[webgl.M31] * v[webgl.M22] * v[webgl.M13] - v[webgl.M20] * v[webgl.M01] * v[webgl.M32] * v[webgl.M13] + v[webgl.M00] * v[webgl.M21] * v[webgl.M32] * v[webgl.M13]
  					+ v[webgl.M30] * v[webgl.M11] * v[webgl.M02] * v[webgl.M23] - v[webgl.M10] * v[webgl.M31] * v[webgl.M02] * v[webgl.M23] - v[webgl.M30] * v[webgl.M01] * v[webgl.M12] * v[webgl.M23]
  					+ v[webgl.M00] * v[webgl.M31] * v[webgl.M12] * v[webgl.M23] + v[webgl.M10] * v[webgl.M01] * v[webgl.M32] * v[webgl.M23] - v[webgl.M00] * v[webgl.M11] * v[webgl.M32] * v[webgl.M23]
  					- v[webgl.M20] * v[webgl.M11] * v[webgl.M02] * v[webgl.M33] + v[webgl.M10] * v[webgl.M21] * v[webgl.M02] * v[webgl.M33] + v[webgl.M20] * v[webgl.M01] * v[webgl.M12] * v[webgl.M33]
  					- v[webgl.M00] * v[webgl.M21] * v[webgl.M12] * v[webgl.M33] - v[webgl.M10] * v[webgl.M01] * v[webgl.M22] * v[webgl.M33] + v[webgl.M00] * v[webgl.M11] * v[webgl.M22] * v[webgl.M33];
  				if (l_det == 0)
  					throw new Error("non-invertible matrix");
  				var inv_det = 1.0 / l_det;
  				t[webgl.M00] = v[webgl.M12] * v[webgl.M23] * v[webgl.M31] - v[webgl.M13] * v[webgl.M22] * v[webgl.M31] + v[webgl.M13] * v[webgl.M21] * v[webgl.M32]
  					- v[webgl.M11] * v[webgl.M23] * v[webgl.M32] - v[webgl.M12] * v[webgl.M21] * v[webgl.M33] + v[webgl.M11] * v[webgl.M22] * v[webgl.M33];
  				t[webgl.M01] = v[webgl.M03] * v[webgl.M22] * v[webgl.M31] - v[webgl.M02] * v[webgl.M23] * v[webgl.M31] - v[webgl.M03] * v[webgl.M21] * v[webgl.M32]
  					+ v[webgl.M01] * v[webgl.M23] * v[webgl.M32] + v[webgl.M02] * v[webgl.M21] * v[webgl.M33] - v[webgl.M01] * v[webgl.M22] * v[webgl.M33];
  				t[webgl.M02] = v[webgl.M02] * v[webgl.M13] * v[webgl.M31] - v[webgl.M03] * v[webgl.M12] * v[webgl.M31] + v[webgl.M03] * v[webgl.M11] * v[webgl.M32]
  					- v[webgl.M01] * v[webgl.M13] * v[webgl.M32] - v[webgl.M02] * v[webgl.M11] * v[webgl.M33] + v[webgl.M01] * v[webgl.M12] * v[webgl.M33];
  				t[webgl.M03] = v[webgl.M03] * v[webgl.M12] * v[webgl.M21] - v[webgl.M02] * v[webgl.M13] * v[webgl.M21] - v[webgl.M03] * v[webgl.M11] * v[webgl.M22]
  					+ v[webgl.M01] * v[webgl.M13] * v[webgl.M22] + v[webgl.M02] * v[webgl.M11] * v[webgl.M23] - v[webgl.M01] * v[webgl.M12] * v[webgl.M23];
  				t[webgl.M10] = v[webgl.M13] * v[webgl.M22] * v[webgl.M30] - v[webgl.M12] * v[webgl.M23] * v[webgl.M30] - v[webgl.M13] * v[webgl.M20] * v[webgl.M32]
  					+ v[webgl.M10] * v[webgl.M23] * v[webgl.M32] + v[webgl.M12] * v[webgl.M20] * v[webgl.M33] - v[webgl.M10] * v[webgl.M22] * v[webgl.M33];
  				t[webgl.M11] = v[webgl.M02] * v[webgl.M23] * v[webgl.M30] - v[webgl.M03] * v[webgl.M22] * v[webgl.M30] + v[webgl.M03] * v[webgl.M20] * v[webgl.M32]
  					- v[webgl.M00] * v[webgl.M23] * v[webgl.M32] - v[webgl.M02] * v[webgl.M20] * v[webgl.M33] + v[webgl.M00] * v[webgl.M22] * v[webgl.M33];
  				t[webgl.M12] = v[webgl.M03] * v[webgl.M12] * v[webgl.M30] - v[webgl.M02] * v[webgl.M13] * v[webgl.M30] - v[webgl.M03] * v[webgl.M10] * v[webgl.M32]
  					+ v[webgl.M00] * v[webgl.M13] * v[webgl.M32] + v[webgl.M02] * v[webgl.M10] * v[webgl.M33] - v[webgl.M00] * v[webgl.M12] * v[webgl.M33];
  				t[webgl.M13] = v[webgl.M02] * v[webgl.M13] * v[webgl.M20] - v[webgl.M03] * v[webgl.M12] * v[webgl.M20] + v[webgl.M03] * v[webgl.M10] * v[webgl.M22]
  					- v[webgl.M00] * v[webgl.M13] * v[webgl.M22] - v[webgl.M02] * v[webgl.M10] * v[webgl.M23] + v[webgl.M00] * v[webgl.M12] * v[webgl.M23];
  				t[webgl.M20] = v[webgl.M11] * v[webgl.M23] * v[webgl.M30] - v[webgl.M13] * v[webgl.M21] * v[webgl.M30] + v[webgl.M13] * v[webgl.M20] * v[webgl.M31]
  					- v[webgl.M10] * v[webgl.M23] * v[webgl.M31] - v[webgl.M11] * v[webgl.M20] * v[webgl.M33] + v[webgl.M10] * v[webgl.M21] * v[webgl.M33];
  				t[webgl.M21] = v[webgl.M03] * v[webgl.M21] * v[webgl.M30] - v[webgl.M01] * v[webgl.M23] * v[webgl.M30] - v[webgl.M03] * v[webgl.M20] * v[webgl.M31]
  					+ v[webgl.M00] * v[webgl.M23] * v[webgl.M31] + v[webgl.M01] * v[webgl.M20] * v[webgl.M33] - v[webgl.M00] * v[webgl.M21] * v[webgl.M33];
  				t[webgl.M22] = v[webgl.M01] * v[webgl.M13] * v[webgl.M30] - v[webgl.M03] * v[webgl.M11] * v[webgl.M30] + v[webgl.M03] * v[webgl.M10] * v[webgl.M31]
  					- v[webgl.M00] * v[webgl.M13] * v[webgl.M31] - v[webgl.M01] * v[webgl.M10] * v[webgl.M33] + v[webgl.M00] * v[webgl.M11] * v[webgl.M33];
  				t[webgl.M23] = v[webgl.M03] * v[webgl.M11] * v[webgl.M20] - v[webgl.M01] * v[webgl.M13] * v[webgl.M20] - v[webgl.M03] * v[webgl.M10] * v[webgl.M21]
  					+ v[webgl.M00] * v[webgl.M13] * v[webgl.M21] + v[webgl.M01] * v[webgl.M10] * v[webgl.M23] - v[webgl.M00] * v[webgl.M11] * v[webgl.M23];
  				t[webgl.M30] = v[webgl.M12] * v[webgl.M21] * v[webgl.M30] - v[webgl.M11] * v[webgl.M22] * v[webgl.M30] - v[webgl.M12] * v[webgl.M20] * v[webgl.M31]
  					+ v[webgl.M10] * v[webgl.M22] * v[webgl.M31] + v[webgl.M11] * v[webgl.M20] * v[webgl.M32] - v[webgl.M10] * v[webgl.M21] * v[webgl.M32];
  				t[webgl.M31] = v[webgl.M01] * v[webgl.M22] * v[webgl.M30] - v[webgl.M02] * v[webgl.M21] * v[webgl.M30] + v[webgl.M02] * v[webgl.M20] * v[webgl.M31]
  					- v[webgl.M00] * v[webgl.M22] * v[webgl.M31] - v[webgl.M01] * v[webgl.M20] * v[webgl.M32] + v[webgl.M00] * v[webgl.M21] * v[webgl.M32];
  				t[webgl.M32] = v[webgl.M02] * v[webgl.M11] * v[webgl.M30] - v[webgl.M01] * v[webgl.M12] * v[webgl.M30] - v[webgl.M02] * v[webgl.M10] * v[webgl.M31]
  					+ v[webgl.M00] * v[webgl.M12] * v[webgl.M31] + v[webgl.M01] * v[webgl.M10] * v[webgl.M32] - v[webgl.M00] * v[webgl.M11] * v[webgl.M32];
  				t[webgl.M33] = v[webgl.M01] * v[webgl.M12] * v[webgl.M20] - v[webgl.M02] * v[webgl.M11] * v[webgl.M20] + v[webgl.M02] * v[webgl.M10] * v[webgl.M21]
  					- v[webgl.M00] * v[webgl.M12] * v[webgl.M21] - v[webgl.M01] * v[webgl.M10] * v[webgl.M22] + v[webgl.M00] * v[webgl.M11] * v[webgl.M22];
  				v[webgl.M00] = t[webgl.M00] * inv_det;
  				v[webgl.M01] = t[webgl.M01] * inv_det;
  				v[webgl.M02] = t[webgl.M02] * inv_det;
  				v[webgl.M03] = t[webgl.M03] * inv_det;
  				v[webgl.M10] = t[webgl.M10] * inv_det;
  				v[webgl.M11] = t[webgl.M11] * inv_det;
  				v[webgl.M12] = t[webgl.M12] * inv_det;
  				v[webgl.M13] = t[webgl.M13] * inv_det;
  				v[webgl.M20] = t[webgl.M20] * inv_det;
  				v[webgl.M21] = t[webgl.M21] * inv_det;
  				v[webgl.M22] = t[webgl.M22] * inv_det;
  				v[webgl.M23] = t[webgl.M23] * inv_det;
  				v[webgl.M30] = t[webgl.M30] * inv_det;
  				v[webgl.M31] = t[webgl.M31] * inv_det;
  				v[webgl.M32] = t[webgl.M32] * inv_det;
  				v[webgl.M33] = t[webgl.M33] * inv_det;
  				return this;
  			};
  			Matrix4.prototype.determinant = function () {
  				var v = this.values;
  				return v[webgl.M30] * v[webgl.M21] * v[webgl.M12] * v[webgl.M03] - v[webgl.M20] * v[webgl.M31] * v[webgl.M12] * v[webgl.M03] - v[webgl.M30] * v[webgl.M11] * v[webgl.M22] * v[webgl.M03]
  					+ v[webgl.M10] * v[webgl.M31] * v[webgl.M22] * v[webgl.M03] + v[webgl.M20] * v[webgl.M11] * v[webgl.M32] * v[webgl.M03] - v[webgl.M10] * v[webgl.M21] * v[webgl.M32] * v[webgl.M03]
  					- v[webgl.M30] * v[webgl.M21] * v[webgl.M02] * v[webgl.M13] + v[webgl.M20] * v[webgl.M31] * v[webgl.M02] * v[webgl.M13] + v[webgl.M30] * v[webgl.M01] * v[webgl.M22] * v[webgl.M13]
  					- v[webgl.M00] * v[webgl.M31] * v[webgl.M22] * v[webgl.M13] - v[webgl.M20] * v[webgl.M01] * v[webgl.M32] * v[webgl.M13] + v[webgl.M00] * v[webgl.M21] * v[webgl.M32] * v[webgl.M13]
  					+ v[webgl.M30] * v[webgl.M11] * v[webgl.M02] * v[webgl.M23] - v[webgl.M10] * v[webgl.M31] * v[webgl.M02] * v[webgl.M23] - v[webgl.M30] * v[webgl.M01] * v[webgl.M12] * v[webgl.M23]
  					+ v[webgl.M00] * v[webgl.M31] * v[webgl.M12] * v[webgl.M23] + v[webgl.M10] * v[webgl.M01] * v[webgl.M32] * v[webgl.M23] - v[webgl.M00] * v[webgl.M11] * v[webgl.M32] * v[webgl.M23]
  					- v[webgl.M20] * v[webgl.M11] * v[webgl.M02] * v[webgl.M33] + v[webgl.M10] * v[webgl.M21] * v[webgl.M02] * v[webgl.M33] + v[webgl.M20] * v[webgl.M01] * v[webgl.M12] * v[webgl.M33]
  					- v[webgl.M00] * v[webgl.M21] * v[webgl.M12] * v[webgl.M33] - v[webgl.M10] * v[webgl.M01] * v[webgl.M22] * v[webgl.M33] + v[webgl.M00] * v[webgl.M11] * v[webgl.M22] * v[webgl.M33];
  			};
  			Matrix4.prototype.translate = function (x, y, z) {
  				var v = this.values;
  				v[webgl.M03] += x;
  				v[webgl.M13] += y;
  				v[webgl.M23] += z;
  				return this;
  			};
  			Matrix4.prototype.copy = function () {
  				return new Matrix4().set(this.values);
  			};
  			Matrix4.prototype.projection = function (near, far, fovy, aspectRatio) {
  				this.identity();
  				var l_fd = (1.0 / Math.tan((fovy * (Math.PI / 180)) / 2.0));
  				var l_a1 = (far + near) / (near - far);
  				var l_a2 = (2 * far * near) / (near - far);
  				var v = this.values;
  				v[webgl.M00] = l_fd / aspectRatio;
  				v[webgl.M10] = 0;
  				v[webgl.M20] = 0;
  				v[webgl.M30] = 0;
  				v[webgl.M01] = 0;
  				v[webgl.M11] = l_fd;
  				v[webgl.M21] = 0;
  				v[webgl.M31] = 0;
  				v[webgl.M02] = 0;
  				v[webgl.M12] = 0;
  				v[webgl.M22] = l_a1;
  				v[webgl.M32] = -1;
  				v[webgl.M03] = 0;
  				v[webgl.M13] = 0;
  				v[webgl.M23] = l_a2;
  				v[webgl.M33] = 0;
  				return this;
  			};
  			Matrix4.prototype.ortho2d = function (x, y, width, height) {
  				return this.ortho(x, x + width, y, y + height, 0, 1);
  			};
  			Matrix4.prototype.ortho = function (left, right, bottom, top, near, far) {
  				this.identity();
  				var x_orth = 2 / (right - left);
  				var y_orth = 2 / (top - bottom);
  				var z_orth = -2 / (far - near);
  				var tx = -(right + left) / (right - left);
  				var ty = -(top + bottom) / (top - bottom);
  				var tz = -(far + near) / (far - near);
  				var v = this.values;
  				v[webgl.M00] = x_orth;
  				v[webgl.M10] = 0;
  				v[webgl.M20] = 0;
  				v[webgl.M30] = 0;
  				v[webgl.M01] = 0;
  				v[webgl.M11] = y_orth;
  				v[webgl.M21] = 0;
  				v[webgl.M31] = 0;
  				v[webgl.M02] = 0;
  				v[webgl.M12] = 0;
  				v[webgl.M22] = z_orth;
  				v[webgl.M32] = 0;
  				v[webgl.M03] = tx;
  				v[webgl.M13] = ty;
  				v[webgl.M23] = tz;
  				v[webgl.M33] = 1;
  				return this;
  			};
  			Matrix4.prototype.multiply = function (matrix) {
  				var t = this.temp;
  				var v = this.values;
  				var m = matrix.values;
  				t[webgl.M00] = v[webgl.M00] * m[webgl.M00] + v[webgl.M01] * m[webgl.M10] + v[webgl.M02] * m[webgl.M20] + v[webgl.M03] * m[webgl.M30];
  				t[webgl.M01] = v[webgl.M00] * m[webgl.M01] + v[webgl.M01] * m[webgl.M11] + v[webgl.M02] * m[webgl.M21] + v[webgl.M03] * m[webgl.M31];
  				t[webgl.M02] = v[webgl.M00] * m[webgl.M02] + v[webgl.M01] * m[webgl.M12] + v[webgl.M02] * m[webgl.M22] + v[webgl.M03] * m[webgl.M32];
  				t[webgl.M03] = v[webgl.M00] * m[webgl.M03] + v[webgl.M01] * m[webgl.M13] + v[webgl.M02] * m[webgl.M23] + v[webgl.M03] * m[webgl.M33];
  				t[webgl.M10] = v[webgl.M10] * m[webgl.M00] + v[webgl.M11] * m[webgl.M10] + v[webgl.M12] * m[webgl.M20] + v[webgl.M13] * m[webgl.M30];
  				t[webgl.M11] = v[webgl.M10] * m[webgl.M01] + v[webgl.M11] * m[webgl.M11] + v[webgl.M12] * m[webgl.M21] + v[webgl.M13] * m[webgl.M31];
  				t[webgl.M12] = v[webgl.M10] * m[webgl.M02] + v[webgl.M11] * m[webgl.M12] + v[webgl.M12] * m[webgl.M22] + v[webgl.M13] * m[webgl.M32];
  				t[webgl.M13] = v[webgl.M10] * m[webgl.M03] + v[webgl.M11] * m[webgl.M13] + v[webgl.M12] * m[webgl.M23] + v[webgl.M13] * m[webgl.M33];
  				t[webgl.M20] = v[webgl.M20] * m[webgl.M00] + v[webgl.M21] * m[webgl.M10] + v[webgl.M22] * m[webgl.M20] + v[webgl.M23] * m[webgl.M30];
  				t[webgl.M21] = v[webgl.M20] * m[webgl.M01] + v[webgl.M21] * m[webgl.M11] + v[webgl.M22] * m[webgl.M21] + v[webgl.M23] * m[webgl.M31];
  				t[webgl.M22] = v[webgl.M20] * m[webgl.M02] + v[webgl.M21] * m[webgl.M12] + v[webgl.M22] * m[webgl.M22] + v[webgl.M23] * m[webgl.M32];
  				t[webgl.M23] = v[webgl.M20] * m[webgl.M03] + v[webgl.M21] * m[webgl.M13] + v[webgl.M22] * m[webgl.M23] + v[webgl.M23] * m[webgl.M33];
  				t[webgl.M30] = v[webgl.M30] * m[webgl.M00] + v[webgl.M31] * m[webgl.M10] + v[webgl.M32] * m[webgl.M20] + v[webgl.M33] * m[webgl.M30];
  				t[webgl.M31] = v[webgl.M30] * m[webgl.M01] + v[webgl.M31] * m[webgl.M11] + v[webgl.M32] * m[webgl.M21] + v[webgl.M33] * m[webgl.M31];
  				t[webgl.M32] = v[webgl.M30] * m[webgl.M02] + v[webgl.M31] * m[webgl.M12] + v[webgl.M32] * m[webgl.M22] + v[webgl.M33] * m[webgl.M32];
  				t[webgl.M33] = v[webgl.M30] * m[webgl.M03] + v[webgl.M31] * m[webgl.M13] + v[webgl.M32] * m[webgl.M23] + v[webgl.M33] * m[webgl.M33];
  				return this.set(this.temp);
  			};
  			Matrix4.prototype.multiplyLeft = function (matrix) {
  				var t = this.temp;
  				var v = this.values;
  				var m = matrix.values;
  				t[webgl.M00] = m[webgl.M00] * v[webgl.M00] + m[webgl.M01] * v[webgl.M10] + m[webgl.M02] * v[webgl.M20] + m[webgl.M03] * v[webgl.M30];
  				t[webgl.M01] = m[webgl.M00] * v[webgl.M01] + m[webgl.M01] * v[webgl.M11] + m[webgl.M02] * v[webgl.M21] + m[webgl.M03] * v[webgl.M31];
  				t[webgl.M02] = m[webgl.M00] * v[webgl.M02] + m[webgl.M01] * v[webgl.M12] + m[webgl.M02] * v[webgl.M22] + m[webgl.M03] * v[webgl.M32];
  				t[webgl.M03] = m[webgl.M00] * v[webgl.M03] + m[webgl.M01] * v[webgl.M13] + m[webgl.M02] * v[webgl.M23] + m[webgl.M03] * v[webgl.M33];
  				t[webgl.M10] = m[webgl.M10] * v[webgl.M00] + m[webgl.M11] * v[webgl.M10] + m[webgl.M12] * v[webgl.M20] + m[webgl.M13] * v[webgl.M30];
  				t[webgl.M11] = m[webgl.M10] * v[webgl.M01] + m[webgl.M11] * v[webgl.M11] + m[webgl.M12] * v[webgl.M21] + m[webgl.M13] * v[webgl.M31];
  				t[webgl.M12] = m[webgl.M10] * v[webgl.M02] + m[webgl.M11] * v[webgl.M12] + m[webgl.M12] * v[webgl.M22] + m[webgl.M13] * v[webgl.M32];
  				t[webgl.M13] = m[webgl.M10] * v[webgl.M03] + m[webgl.M11] * v[webgl.M13] + m[webgl.M12] * v[webgl.M23] + m[webgl.M13] * v[webgl.M33];
  				t[webgl.M20] = m[webgl.M20] * v[webgl.M00] + m[webgl.M21] * v[webgl.M10] + m[webgl.M22] * v[webgl.M20] + m[webgl.M23] * v[webgl.M30];
  				t[webgl.M21] = m[webgl.M20] * v[webgl.M01] + m[webgl.M21] * v[webgl.M11] + m[webgl.M22] * v[webgl.M21] + m[webgl.M23] * v[webgl.M31];
  				t[webgl.M22] = m[webgl.M20] * v[webgl.M02] + m[webgl.M21] * v[webgl.M12] + m[webgl.M22] * v[webgl.M22] + m[webgl.M23] * v[webgl.M32];
  				t[webgl.M23] = m[webgl.M20] * v[webgl.M03] + m[webgl.M21] * v[webgl.M13] + m[webgl.M22] * v[webgl.M23] + m[webgl.M23] * v[webgl.M33];
  				t[webgl.M30] = m[webgl.M30] * v[webgl.M00] + m[webgl.M31] * v[webgl.M10] + m[webgl.M32] * v[webgl.M20] + m[webgl.M33] * v[webgl.M30];
  				t[webgl.M31] = m[webgl.M30] * v[webgl.M01] + m[webgl.M31] * v[webgl.M11] + m[webgl.M32] * v[webgl.M21] + m[webgl.M33] * v[webgl.M31];
  				t[webgl.M32] = m[webgl.M30] * v[webgl.M02] + m[webgl.M31] * v[webgl.M12] + m[webgl.M32] * v[webgl.M22] + m[webgl.M33] * v[webgl.M32];
  				t[webgl.M33] = m[webgl.M30] * v[webgl.M03] + m[webgl.M31] * v[webgl.M13] + m[webgl.M32] * v[webgl.M23] + m[webgl.M33] * v[webgl.M33];
  				return this.set(this.temp);
  			};
  			Matrix4.prototype.lookAt = function (position, direction, up) {
  				Matrix4.initTemps();
  				var xAxis = Matrix4.xAxis, yAxis = Matrix4.yAxis, zAxis = Matrix4.zAxis;
  				zAxis.setFrom(direction).normalize();
  				xAxis.setFrom(direction).normalize();
  				xAxis.cross(up).normalize();
  				yAxis.setFrom(xAxis).cross(zAxis).normalize();
  				this.identity();
  				var val = this.values;
  				val[webgl.M00] = xAxis.x;
  				val[webgl.M01] = xAxis.y;
  				val[webgl.M02] = xAxis.z;
  				val[webgl.M10] = yAxis.x;
  				val[webgl.M11] = yAxis.y;
  				val[webgl.M12] = yAxis.z;
  				val[webgl.M20] = -zAxis.x;
  				val[webgl.M21] = -zAxis.y;
  				val[webgl.M22] = -zAxis.z;
  				Matrix4.tmpMatrix.identity();
  				Matrix4.tmpMatrix.values[webgl.M03] = -position.x;
  				Matrix4.tmpMatrix.values[webgl.M13] = -position.y;
  				Matrix4.tmpMatrix.values[webgl.M23] = -position.z;
  				this.multiply(Matrix4.tmpMatrix);
  				return this;
  			};
  			Matrix4.initTemps = function () {
  				if (Matrix4.xAxis === null)
  					Matrix4.xAxis = new webgl.Vector3();
  				if (Matrix4.yAxis === null)
  					Matrix4.yAxis = new webgl.Vector3();
  				if (Matrix4.zAxis === null)
  					Matrix4.zAxis = new webgl.Vector3();
  			};
  			Matrix4.xAxis = null;
  			Matrix4.yAxis = null;
  			Matrix4.zAxis = null;
  			Matrix4.tmpMatrix = new Matrix4();
  			return Matrix4;
  		}());
  		webgl.Matrix4 = Matrix4;
  	})(webgl = spine.webgl || (spine.webgl = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var webgl;
  	(function (webgl) {
  		var Mesh = (function () {
  			function Mesh(context, attributes, maxVertices, maxIndices) {
  				this.attributes = attributes;
  				this.verticesLength = 0;
  				this.dirtyVertices = false;
  				this.indicesLength = 0;
  				this.dirtyIndices = false;
  				this.elementsPerVertex = 0;
  				this.context = context instanceof webgl.ManagedWebGLRenderingContext ? context : new webgl.ManagedWebGLRenderingContext(context);
  				this.elementsPerVertex = 0;
  				for (var i = 0; i < attributes.length; i++) {
  					this.elementsPerVertex += attributes[i].numElements;
  				}
  				this.vertices = new Float32Array(maxVertices * this.elementsPerVertex);
  				this.indices = new Uint16Array(maxIndices);
  				this.context.addRestorable(this);
  			}
  			Mesh.prototype.getAttributes = function () { return this.attributes; };
  			Mesh.prototype.maxVertices = function () { return this.vertices.length / this.elementsPerVertex; };
  			Mesh.prototype.numVertices = function () { return this.verticesLength / this.elementsPerVertex; };
  			Mesh.prototype.setVerticesLength = function (length) {
  				this.dirtyVertices = true;
  				this.verticesLength = length;
  			};
  			Mesh.prototype.getVertices = function () { return this.vertices; };
  			Mesh.prototype.maxIndices = function () { return this.indices.length; };
  			Mesh.prototype.numIndices = function () { return this.indicesLength; };
  			Mesh.prototype.setIndicesLength = function (length) {
  				this.dirtyIndices = true;
  				this.indicesLength = length;
  			};
  			Mesh.prototype.getIndices = function () { return this.indices; };
  			;
  			Mesh.prototype.getVertexSizeInFloats = function () {
  				var size = 0;
  				for (var i = 0; i < this.attributes.length; i++) {
  					var attribute = this.attributes[i];
  					size += attribute.numElements;
  				}
  				return size;
  			};
  			Mesh.prototype.setVertices = function (vertices) {
  				this.dirtyVertices = true;
  				if (vertices.length > this.vertices.length)
  					throw Error("Mesh can't store more than " + this.maxVertices() + " vertices");
  				this.vertices.set(vertices, 0);
  				this.verticesLength = vertices.length;
  			};
  			Mesh.prototype.setIndices = function (indices) {
  				this.dirtyIndices = true;
  				if (indices.length > this.indices.length)
  					throw Error("Mesh can't store more than " + this.maxIndices() + " indices");
  				this.indices.set(indices, 0);
  				this.indicesLength = indices.length;
  			};
  			Mesh.prototype.draw = function (shader, primitiveType) {
  				this.drawWithOffset(shader, primitiveType, 0, this.indicesLength > 0 ? this.indicesLength : this.verticesLength / this.elementsPerVertex);
  			};
  			Mesh.prototype.drawWithOffset = function (shader, primitiveType, offset, count) {
  				var gl = this.context.gl;
  				if (this.dirtyVertices || this.dirtyIndices)
  					this.update();
  				this.bind(shader);
  				if (this.indicesLength > 0) {
  					gl.drawElements(primitiveType, count, gl.UNSIGNED_SHORT, offset * 2);
  				}
  				else {
  					gl.drawArrays(primitiveType, offset, count);
  				}
  				this.unbind(shader);
  			};
  			Mesh.prototype.bind = function (shader) {
  				var gl = this.context.gl;
  				gl.bindBuffer(gl.ARRAY_BUFFER, this.verticesBuffer);
  				var offset = 0;
  				for (var i = 0; i < this.attributes.length; i++) {
  					var attrib = this.attributes[i];
  					var location_1 = shader.getAttributeLocation(attrib.name);
  					gl.enableVertexAttribArray(location_1);
  					gl.vertexAttribPointer(location_1, attrib.numElements, gl.FLOAT, false, this.elementsPerVertex * 4, offset * 4);
  					offset += attrib.numElements;
  				}
  				if (this.indicesLength > 0)
  					gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indicesBuffer);
  			};
  			Mesh.prototype.unbind = function (shader) {
  				var gl = this.context.gl;
  				for (var i = 0; i < this.attributes.length; i++) {
  					var attrib = this.attributes[i];
  					var location_2 = shader.getAttributeLocation(attrib.name);
  					gl.disableVertexAttribArray(location_2);
  				}
  				gl.bindBuffer(gl.ARRAY_BUFFER, null);
  				if (this.indicesLength > 0)
  					gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
  			};
  			Mesh.prototype.update = function () {
  				var gl = this.context.gl;
  				if (this.dirtyVertices) {
  					if (!this.verticesBuffer) {
  						this.verticesBuffer = gl.createBuffer();
  					}
  					gl.bindBuffer(gl.ARRAY_BUFFER, this.verticesBuffer);
  					gl.bufferData(gl.ARRAY_BUFFER, this.vertices.subarray(0, this.verticesLength), gl.DYNAMIC_DRAW);
  					this.dirtyVertices = false;
  				}
  				if (this.dirtyIndices) {
  					if (!this.indicesBuffer) {
  						this.indicesBuffer = gl.createBuffer();
  					}
  					gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indicesBuffer);
  					gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, this.indices.subarray(0, this.indicesLength), gl.DYNAMIC_DRAW);
  					this.dirtyIndices = false;
  				}
  			};
  			Mesh.prototype.restore = function () {
  				this.verticesBuffer = null;
  				this.indicesBuffer = null;
  				this.update();
  			};
  			Mesh.prototype.dispose = function () {
  				this.context.removeRestorable(this);
  				var gl = this.context.gl;
  				gl.deleteBuffer(this.verticesBuffer);
  				gl.deleteBuffer(this.indicesBuffer);
  			};
  			return Mesh;
  		}());
  		webgl.Mesh = Mesh;
  		var VertexAttribute = (function () {
  			function VertexAttribute(name, type, numElements) {
  				this.name = name;
  				this.type = type;
  				this.numElements = numElements;
  			}
  			return VertexAttribute;
  		}());
  		webgl.VertexAttribute = VertexAttribute;
  		var Position2Attribute = (function (_super) {
  			__extends(Position2Attribute, _super);
  			function Position2Attribute() {
  				return _super.call(this, webgl.Shader.POSITION, VertexAttributeType.Float, 2) || this;
  			}
  			return Position2Attribute;
  		}(VertexAttribute));
  		webgl.Position2Attribute = Position2Attribute;
  		var Position3Attribute = (function (_super) {
  			__extends(Position3Attribute, _super);
  			function Position3Attribute() {
  				return _super.call(this, webgl.Shader.POSITION, VertexAttributeType.Float, 3) || this;
  			}
  			return Position3Attribute;
  		}(VertexAttribute));
  		webgl.Position3Attribute = Position3Attribute;
  		var TexCoordAttribute = (function (_super) {
  			__extends(TexCoordAttribute, _super);
  			function TexCoordAttribute(unit) {
  				if (unit === void 0) { unit = 0; }
  				return _super.call(this, webgl.Shader.TEXCOORDS + (unit == 0 ? "" : unit), VertexAttributeType.Float, 2) || this;
  			}
  			return TexCoordAttribute;
  		}(VertexAttribute));
  		webgl.TexCoordAttribute = TexCoordAttribute;
  		var ColorAttribute = (function (_super) {
  			__extends(ColorAttribute, _super);
  			function ColorAttribute() {
  				return _super.call(this, webgl.Shader.COLOR, VertexAttributeType.Float, 4) || this;
  			}
  			return ColorAttribute;
  		}(VertexAttribute));
  		webgl.ColorAttribute = ColorAttribute;
  		var Color2Attribute = (function (_super) {
  			__extends(Color2Attribute, _super);
  			function Color2Attribute() {
  				return _super.call(this, webgl.Shader.COLOR2, VertexAttributeType.Float, 4) || this;
  			}
  			return Color2Attribute;
  		}(VertexAttribute));
  		webgl.Color2Attribute = Color2Attribute;
  		var VertexAttributeType;
  		(function (VertexAttributeType) {
  			VertexAttributeType[VertexAttributeType["Float"] = 0] = "Float";
  		})(VertexAttributeType = webgl.VertexAttributeType || (webgl.VertexAttributeType = {}));
  	})(webgl = spine.webgl || (spine.webgl = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var webgl;
  	(function (webgl) {
  		var PolygonBatcher = (function () {
  			function PolygonBatcher(context, twoColorTint, maxVertices) {
  				if (twoColorTint === void 0) { twoColorTint = true; }
  				if (maxVertices === void 0) { maxVertices = 10920; }
  				this.isDrawing = false;
  				this.shader = null;
  				this.lastTexture = null;
  				this.verticesLength = 0;
  				this.indicesLength = 0;
  				if (maxVertices > 10920)
  					throw new Error("Can't have more than 10920 triangles per batch: " + maxVertices);
  				this.context = context instanceof webgl.ManagedWebGLRenderingContext ? context : new webgl.ManagedWebGLRenderingContext(context);
  				var attributes = twoColorTint ?
  					[new webgl.Position2Attribute(), new webgl.ColorAttribute(), new webgl.TexCoordAttribute(), new webgl.Color2Attribute()] :
  					[new webgl.Position2Attribute(), new webgl.ColorAttribute(), new webgl.TexCoordAttribute()];
  				this.mesh = new webgl.Mesh(context, attributes, maxVertices, maxVertices * 3);
  				this.srcBlend = this.context.gl.SRC_ALPHA;
  				this.dstBlend = this.context.gl.ONE_MINUS_SRC_ALPHA;
  			}
  			PolygonBatcher.prototype.begin = function (shader) {
  				var gl = this.context.gl;
  				if (this.isDrawing)
  					throw new Error("PolygonBatch is already drawing. Call PolygonBatch.end() before calling PolygonBatch.begin()");
  				this.drawCalls = 0;
  				this.shader = shader;
  				this.lastTexture = null;
  				this.isDrawing = true;
  				gl.enable(gl.BLEND);
  				gl.blendFunc(this.srcBlend, this.dstBlend);
  			};
  			PolygonBatcher.prototype.setBlendMode = function (srcBlend, dstBlend) {
  				var gl = this.context.gl;
  				this.srcBlend = srcBlend;
  				this.dstBlend = dstBlend;
  				if (this.isDrawing) {
  					this.flush();
  					gl.blendFunc(this.srcBlend, this.dstBlend);
  				}
  			};
  			PolygonBatcher.prototype.draw = function (texture, vertices, indices) {
  				if (texture != this.lastTexture) {
  					this.flush();
  					this.lastTexture = texture;
  				}
  				else if (this.verticesLength + vertices.length > this.mesh.getVertices().length ||
  					this.indicesLength + indices.length > this.mesh.getIndices().length) {
  					this.flush();
  				}
  				var indexStart = this.mesh.numVertices();
  				this.mesh.getVertices().set(vertices, this.verticesLength);
  				this.verticesLength += vertices.length;
  				this.mesh.setVerticesLength(this.verticesLength);
  				var indicesArray = this.mesh.getIndices();
  				for (var i = this.indicesLength, j = 0; j < indices.length; i++, j++)
  					indicesArray[i] = indices[j] + indexStart;
  				this.indicesLength += indices.length;
  				this.mesh.setIndicesLength(this.indicesLength);
  			};
  			PolygonBatcher.prototype.flush = function () {
  				var gl = this.context.gl;
  				if (this.verticesLength == 0)
  					return;
  				this.lastTexture.bind();
  				this.mesh.draw(this.shader, gl.TRIANGLES);
  				this.verticesLength = 0;
  				this.indicesLength = 0;
  				this.mesh.setVerticesLength(0);
  				this.mesh.setIndicesLength(0);
  				this.drawCalls++;
  			};
  			PolygonBatcher.prototype.end = function () {
  				var gl = this.context.gl;
  				if (!this.isDrawing)
  					throw new Error("PolygonBatch is not drawing. Call PolygonBatch.begin() before calling PolygonBatch.end()");
  				if (this.verticesLength > 0 || this.indicesLength > 0)
  					this.flush();
  				this.shader = null;
  				this.lastTexture = null;
  				this.isDrawing = false;
  				gl.disable(gl.BLEND);
  			};
  			PolygonBatcher.prototype.getDrawCalls = function () { return this.drawCalls; };
  			PolygonBatcher.prototype.dispose = function () {
  				this.mesh.dispose();
  			};
  			return PolygonBatcher;
  		}());
  		webgl.PolygonBatcher = PolygonBatcher;
  	})(webgl = spine.webgl || (spine.webgl = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var webgl;
  	(function (webgl) {
  		var SceneRenderer = (function () {
  			function SceneRenderer(canvas, context, twoColorTint) {
  				if (twoColorTint === void 0) { twoColorTint = true; }
  				this.twoColorTint = false;
  				this.activeRenderer = null;
  				this.QUAD = [
  					0, 0, 1, 1, 1, 1, 0, 0,
  					0, 0, 1, 1, 1, 1, 0, 0,
  					0, 0, 1, 1, 1, 1, 0, 0,
  					0, 0, 1, 1, 1, 1, 0, 0,
  				];
  				this.QUAD_TRIANGLES = [0, 1, 2, 2, 3, 0];
  				this.WHITE = new spine.Color(1, 1, 1, 1);
  				this.canvas = canvas;
  				this.context = context instanceof webgl.ManagedWebGLRenderingContext ? context : new webgl.ManagedWebGLRenderingContext(context);
  				this.twoColorTint = twoColorTint;
  				this.camera = new webgl.OrthoCamera(canvas.width, canvas.height);
  				this.batcherShader = twoColorTint ? webgl.Shader.newTwoColoredTextured(this.context) : webgl.Shader.newColoredTextured(this.context);
  				this.batcher = new webgl.PolygonBatcher(this.context, twoColorTint);
  				this.shapesShader = webgl.Shader.newColored(this.context);
  				this.shapes = new webgl.ShapeRenderer(this.context);
  				this.skeletonRenderer = new webgl.SkeletonRenderer(this.context, twoColorTint);
  				this.skeletonDebugRenderer = new webgl.SkeletonDebugRenderer(this.context);
  			}
  			SceneRenderer.prototype.begin = function () {
  				this.camera.update();
  				this.enableRenderer(this.batcher);
  			};
  			SceneRenderer.prototype.drawSkeleton = function (skeleton, premultipliedAlpha, slotRangeStart, slotRangeEnd) {
  				if (premultipliedAlpha === void 0) { premultipliedAlpha = false; }
  				if (slotRangeStart === void 0) { slotRangeStart = -1; }
  				if (slotRangeEnd === void 0) { slotRangeEnd = -1; }
  				this.enableRenderer(this.batcher);
  				this.skeletonRenderer.premultipliedAlpha = premultipliedAlpha;
  				this.skeletonRenderer.draw(this.batcher, skeleton, slotRangeStart, slotRangeEnd);
  			};
  			SceneRenderer.prototype.drawSkeletonDebug = function (skeleton, premultipliedAlpha, ignoredBones) {
  				if (premultipliedAlpha === void 0) { premultipliedAlpha = false; }
  				if (ignoredBones === void 0) { ignoredBones = null; }
  				this.enableRenderer(this.shapes);
  				this.skeletonDebugRenderer.premultipliedAlpha = premultipliedAlpha;
  				this.skeletonDebugRenderer.draw(this.shapes, skeleton, ignoredBones);
  			};
  			SceneRenderer.prototype.drawTexture = function (texture, x, y, width, height, color) {
  				if (color === void 0) { color = null; }
  				this.enableRenderer(this.batcher);
  				if (color === null)
  					color = this.WHITE;
  				var quad = this.QUAD;
  				var i = 0;
  				quad[i++] = x;
  				quad[i++] = y;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = 0;
  				quad[i++] = 1;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				quad[i++] = x + width;
  				quad[i++] = y;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = 1;
  				quad[i++] = 1;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				quad[i++] = x + width;
  				quad[i++] = y + height;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = 1;
  				quad[i++] = 0;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				quad[i++] = x;
  				quad[i++] = y + height;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = 0;
  				quad[i++] = 0;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				this.batcher.draw(texture, quad, this.QUAD_TRIANGLES);
  			};
  			SceneRenderer.prototype.drawTextureUV = function (texture, x, y, width, height, u, v, u2, v2, color) {
  				if (color === void 0) { color = null; }
  				this.enableRenderer(this.batcher);
  				if (color === null)
  					color = this.WHITE;
  				var quad = this.QUAD;
  				var i = 0;
  				quad[i++] = x;
  				quad[i++] = y;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = u;
  				quad[i++] = v;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				quad[i++] = x + width;
  				quad[i++] = y;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = u2;
  				quad[i++] = v;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				quad[i++] = x + width;
  				quad[i++] = y + height;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = u2;
  				quad[i++] = v2;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				quad[i++] = x;
  				quad[i++] = y + height;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = u;
  				quad[i++] = v2;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				this.batcher.draw(texture, quad, this.QUAD_TRIANGLES);
  			};
  			SceneRenderer.prototype.drawTextureRotated = function (texture, x, y, width, height, pivotX, pivotY, angle, color, premultipliedAlpha) {
  				if (color === void 0) { color = null; }
  				if (premultipliedAlpha === void 0) { premultipliedAlpha = false; }
  				this.enableRenderer(this.batcher);
  				if (color === null)
  					color = this.WHITE;
  				var quad = this.QUAD;
  				var worldOriginX = x + pivotX;
  				var worldOriginY = y + pivotY;
  				var fx = -pivotX;
  				var fy = -pivotY;
  				var fx2 = width - pivotX;
  				var fy2 = height - pivotY;
  				var p1x = fx;
  				var p1y = fy;
  				var p2x = fx;
  				var p2y = fy2;
  				var p3x = fx2;
  				var p3y = fy2;
  				var p4x = fx2;
  				var p4y = fy;
  				var x1 = 0;
  				var y1 = 0;
  				var x2 = 0;
  				var y2 = 0;
  				var x3 = 0;
  				var y3 = 0;
  				var x4 = 0;
  				var y4 = 0;
  				if (angle != 0) {
  					var cos = spine.MathUtils.cosDeg(angle);
  					var sin = spine.MathUtils.sinDeg(angle);
  					x1 = cos * p1x - sin * p1y;
  					y1 = sin * p1x + cos * p1y;
  					x4 = cos * p2x - sin * p2y;
  					y4 = sin * p2x + cos * p2y;
  					x3 = cos * p3x - sin * p3y;
  					y3 = sin * p3x + cos * p3y;
  					x2 = x3 + (x1 - x4);
  					y2 = y3 + (y1 - y4);
  				}
  				else {
  					x1 = p1x;
  					y1 = p1y;
  					x4 = p2x;
  					y4 = p2y;
  					x3 = p3x;
  					y3 = p3y;
  					x2 = p4x;
  					y2 = p4y;
  				}
  				x1 += worldOriginX;
  				y1 += worldOriginY;
  				x2 += worldOriginX;
  				y2 += worldOriginY;
  				x3 += worldOriginX;
  				y3 += worldOriginY;
  				x4 += worldOriginX;
  				y4 += worldOriginY;
  				var i = 0;
  				quad[i++] = x1;
  				quad[i++] = y1;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = 0;
  				quad[i++] = 1;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				quad[i++] = x2;
  				quad[i++] = y2;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = 1;
  				quad[i++] = 1;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				quad[i++] = x3;
  				quad[i++] = y3;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = 1;
  				quad[i++] = 0;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				quad[i++] = x4;
  				quad[i++] = y4;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = 0;
  				quad[i++] = 0;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				this.batcher.draw(texture, quad, this.QUAD_TRIANGLES);
  			};
  			SceneRenderer.prototype.drawRegion = function (region, x, y, width, height, color, premultipliedAlpha) {
  				if (color === void 0) { color = null; }
  				if (premultipliedAlpha === void 0) { premultipliedAlpha = false; }
  				this.enableRenderer(this.batcher);
  				if (color === null)
  					color = this.WHITE;
  				var quad = this.QUAD;
  				var i = 0;
  				quad[i++] = x;
  				quad[i++] = y;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = region.u;
  				quad[i++] = region.v2;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				quad[i++] = x + width;
  				quad[i++] = y;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = region.u2;
  				quad[i++] = region.v2;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				quad[i++] = x + width;
  				quad[i++] = y + height;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = region.u2;
  				quad[i++] = region.v;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				quad[i++] = x;
  				quad[i++] = y + height;
  				quad[i++] = color.r;
  				quad[i++] = color.g;
  				quad[i++] = color.b;
  				quad[i++] = color.a;
  				quad[i++] = region.u;
  				quad[i++] = region.v;
  				if (this.twoColorTint) {
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  					quad[i++] = 0;
  				}
  				this.batcher.draw(region.texture, quad, this.QUAD_TRIANGLES);
  			};
  			SceneRenderer.prototype.line = function (x, y, x2, y2, color, color2) {
  				if (color === void 0) { color = null; }
  				if (color2 === void 0) { color2 = null; }
  				this.enableRenderer(this.shapes);
  				this.shapes.line(x, y, x2, y2, color);
  			};
  			SceneRenderer.prototype.triangle = function (filled, x, y, x2, y2, x3, y3, color, color2, color3) {
  				if (color === void 0) { color = null; }
  				if (color2 === void 0) { color2 = null; }
  				if (color3 === void 0) { color3 = null; }
  				this.enableRenderer(this.shapes);
  				this.shapes.triangle(filled, x, y, x2, y2, x3, y3, color, color2, color3);
  			};
  			SceneRenderer.prototype.quad = function (filled, x, y, x2, y2, x3, y3, x4, y4, color, color2, color3, color4) {
  				if (color === void 0) { color = null; }
  				if (color2 === void 0) { color2 = null; }
  				if (color3 === void 0) { color3 = null; }
  				if (color4 === void 0) { color4 = null; }
  				this.enableRenderer(this.shapes);
  				this.shapes.quad(filled, x, y, x2, y2, x3, y3, x4, y4, color, color2, color3, color4);
  			};
  			SceneRenderer.prototype.rect = function (filled, x, y, width, height, color) {
  				if (color === void 0) { color = null; }
  				this.enableRenderer(this.shapes);
  				this.shapes.rect(filled, x, y, width, height, color);
  			};
  			SceneRenderer.prototype.rectLine = function (filled, x1, y1, x2, y2, width, color) {
  				if (color === void 0) { color = null; }
  				this.enableRenderer(this.shapes);
  				this.shapes.rectLine(filled, x1, y1, x2, y2, width, color);
  			};
  			SceneRenderer.prototype.polygon = function (polygonVertices, offset, count, color) {
  				if (color === void 0) { color = null; }
  				this.enableRenderer(this.shapes);
  				this.shapes.polygon(polygonVertices, offset, count, color);
  			};
  			SceneRenderer.prototype.circle = function (filled, x, y, radius, color, segments) {
  				if (color === void 0) { color = null; }
  				if (segments === void 0) { segments = 0; }
  				this.enableRenderer(this.shapes);
  				this.shapes.circle(filled, x, y, radius, color, segments);
  			};
  			SceneRenderer.prototype.curve = function (x1, y1, cx1, cy1, cx2, cy2, x2, y2, segments, color) {
  				if (color === void 0) { color = null; }
  				this.enableRenderer(this.shapes);
  				this.shapes.curve(x1, y1, cx1, cy1, cx2, cy2, x2, y2, segments, color);
  			};
  			SceneRenderer.prototype.end = function () {
  				if (this.activeRenderer === this.batcher)
  					this.batcher.end();
  				else if (this.activeRenderer === this.shapes)
  					this.shapes.end();
  				this.activeRenderer = null;
  			};
  			SceneRenderer.prototype.resize = function (resizeMode) {
  				var canvas = this.canvas;
  				var w = canvas.clientWidth;
  				var h = canvas.clientHeight;
  				if (canvas.width != w || canvas.height != h) {
  					canvas.width = w;
  					canvas.height = h;
  				}
  				this.context.gl.viewport(0, 0, canvas.width, canvas.height);
  				if (resizeMode === ResizeMode.Stretch) {
  				}
  				else if (resizeMode === ResizeMode.Expand) {
  					this.camera.setViewport(w, h);
  				}
  				else if (resizeMode === ResizeMode.Fit) {
  					var sourceWidth = canvas.width, sourceHeight = canvas.height;
  					var targetWidth = this.camera.viewportWidth, targetHeight = this.camera.viewportHeight;
  					var targetRatio = targetHeight / targetWidth;
  					var sourceRatio = sourceHeight / sourceWidth;
  					var scale = targetRatio < sourceRatio ? targetWidth / sourceWidth : targetHeight / sourceHeight;
  					this.camera.viewportWidth = sourceWidth * scale;
  					this.camera.viewportHeight = sourceHeight * scale;
  				}
  				this.camera.update();
  			};
  			SceneRenderer.prototype.enableRenderer = function (renderer) {
  				if (this.activeRenderer === renderer)
  					return;
  				this.end();
  				if (renderer instanceof webgl.PolygonBatcher) {
  					this.batcherShader.bind();
  					this.batcherShader.setUniform4x4f(webgl.Shader.MVP_MATRIX, this.camera.projectionView.values);
  					this.batcherShader.setUniformi("u_texture", 0);
  					this.batcher.begin(this.batcherShader);
  					this.activeRenderer = this.batcher;
  				}
  				else if (renderer instanceof webgl.ShapeRenderer) {
  					this.shapesShader.bind();
  					this.shapesShader.setUniform4x4f(webgl.Shader.MVP_MATRIX, this.camera.projectionView.values);
  					this.shapes.begin(this.shapesShader);
  					this.activeRenderer = this.shapes;
  				}
  				else {
  					this.activeRenderer = this.skeletonDebugRenderer;
  				}
  			};
  			SceneRenderer.prototype.dispose = function () {
  				this.batcher.dispose();
  				this.batcherShader.dispose();
  				this.shapes.dispose();
  				this.shapesShader.dispose();
  				this.skeletonDebugRenderer.dispose();
  			};
  			return SceneRenderer;
  		}());
  		webgl.SceneRenderer = SceneRenderer;
  		var ResizeMode;
  		(function (ResizeMode) {
  			ResizeMode[ResizeMode["Stretch"] = 0] = "Stretch";
  			ResizeMode[ResizeMode["Expand"] = 1] = "Expand";
  			ResizeMode[ResizeMode["Fit"] = 2] = "Fit";
  		})(ResizeMode = webgl.ResizeMode || (webgl.ResizeMode = {}));
  	})(webgl = spine.webgl || (spine.webgl = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var webgl;
  	(function (webgl) {
  		var Shader = (function () {
  			function Shader(context, vertexShader, fragmentShader) {
  				this.vertexShader = vertexShader;
  				this.fragmentShader = fragmentShader;
  				this.vs = null;
  				this.fs = null;
  				this.program = null;
  				this.tmp2x2 = new Float32Array(2 * 2);
  				this.tmp3x3 = new Float32Array(3 * 3);
  				this.tmp4x4 = new Float32Array(4 * 4);
  				this.vsSource = vertexShader;
  				this.fsSource = fragmentShader;
  				this.context = context instanceof webgl.ManagedWebGLRenderingContext ? context : new webgl.ManagedWebGLRenderingContext(context);
  				this.context.addRestorable(this);
  				this.compile();
  			}
  			Shader.prototype.getProgram = function () { return this.program; };
  			Shader.prototype.getVertexShader = function () { return this.vertexShader; };
  			Shader.prototype.getFragmentShader = function () { return this.fragmentShader; };
  			Shader.prototype.getVertexShaderSource = function () { return this.vsSource; };
  			Shader.prototype.getFragmentSource = function () { return this.fsSource; };
  			Shader.prototype.compile = function () {
  				var gl = this.context.gl;
  				try {
  					this.vs = this.compileShader(gl.VERTEX_SHADER, this.vertexShader);
  					this.fs = this.compileShader(gl.FRAGMENT_SHADER, this.fragmentShader);
  					this.program = this.compileProgram(this.vs, this.fs);
  				}
  				catch (e) {
  					this.dispose();
  					throw e;
  				}
  			};
  			Shader.prototype.compileShader = function (type, source) {
  				var gl = this.context.gl;
  				var shader = gl.createShader(type);
  				gl.shaderSource(shader, source);
  				gl.compileShader(shader);
  				if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
  					var error = "Couldn't compile shader: " + gl.getShaderInfoLog(shader);
  					gl.deleteShader(shader);
  					if (!gl.isContextLost())
  						throw new Error(error);
  				}
  				return shader;
  			};
  			Shader.prototype.compileProgram = function (vs, fs) {
  				var gl = this.context.gl;
  				var program = gl.createProgram();
  				gl.attachShader(program, vs);
  				gl.attachShader(program, fs);
  				gl.linkProgram(program);
  				if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
  					var error = "Couldn't compile shader program: " + gl.getProgramInfoLog(program);
  					gl.deleteProgram(program);
  					if (!gl.isContextLost())
  						throw new Error(error);
  				}
  				return program;
  			};
  			Shader.prototype.restore = function () {
  				this.compile();
  			};
  			Shader.prototype.bind = function () {
  				this.context.gl.useProgram(this.program);
  			};
  			Shader.prototype.unbind = function () {
  				this.context.gl.useProgram(null);
  			};
  			Shader.prototype.setUniformi = function (uniform, value) {
  				this.context.gl.uniform1i(this.getUniformLocation(uniform), value);
  			};
  			Shader.prototype.setUniformf = function (uniform, value) {
  				this.context.gl.uniform1f(this.getUniformLocation(uniform), value);
  			};
  			Shader.prototype.setUniform2f = function (uniform, value, value2) {
  				this.context.gl.uniform2f(this.getUniformLocation(uniform), value, value2);
  			};
  			Shader.prototype.setUniform3f = function (uniform, value, value2, value3) {
  				this.context.gl.uniform3f(this.getUniformLocation(uniform), value, value2, value3);
  			};
  			Shader.prototype.setUniform4f = function (uniform, value, value2, value3, value4) {
  				this.context.gl.uniform4f(this.getUniformLocation(uniform), value, value2, value3, value4);
  			};
  			Shader.prototype.setUniform2x2f = function (uniform, value) {
  				var gl = this.context.gl;
  				this.tmp2x2.set(value);
  				gl.uniformMatrix2fv(this.getUniformLocation(uniform), false, this.tmp2x2);
  			};
  			Shader.prototype.setUniform3x3f = function (uniform, value) {
  				var gl = this.context.gl;
  				this.tmp3x3.set(value);
  				gl.uniformMatrix3fv(this.getUniformLocation(uniform), false, this.tmp3x3);
  			};
  			Shader.prototype.setUniform4x4f = function (uniform, value) {
  				var gl = this.context.gl;
  				this.tmp4x4.set(value);
  				gl.uniformMatrix4fv(this.getUniformLocation(uniform), false, this.tmp4x4);
  			};
  			Shader.prototype.getUniformLocation = function (uniform) {
  				var gl = this.context.gl;
  				var location = gl.getUniformLocation(this.program, uniform);
  				if (!location && !gl.isContextLost())
  					throw new Error("Couldn't find location for uniform " + uniform);
  				return location;
  			};
  			Shader.prototype.getAttributeLocation = function (attribute) {
  				var gl = this.context.gl;
  				var location = gl.getAttribLocation(this.program, attribute);
  				if (location == -1 && !gl.isContextLost())
  					throw new Error("Couldn't find location for attribute " + attribute);
  				return location;
  			};
  			Shader.prototype.dispose = function () {
  				this.context.removeRestorable(this);
  				var gl = this.context.gl;
  				if (this.vs) {
  					gl.deleteShader(this.vs);
  					this.vs = null;
  				}
  				if (this.fs) {
  					gl.deleteShader(this.fs);
  					this.fs = null;
  				}
  				if (this.program) {
  					gl.deleteProgram(this.program);
  					this.program = null;
  				}
  			};
  			Shader.newColoredTextured = function (context) {
  				var vs = "\n\t\t\t\tattribute vec4 " + Shader.POSITION + ";\n\t\t\t\tattribute vec4 " + Shader.COLOR + ";\n\t\t\t\tattribute vec2 " + Shader.TEXCOORDS + ";\n\t\t\t\tuniform mat4 " + Shader.MVP_MATRIX + ";\n\t\t\t\tvarying vec4 v_color;\n\t\t\t\tvarying vec2 v_texCoords;\n\n\t\t\t\tvoid main () {\n\t\t\t\t\tv_color = " + Shader.COLOR + ";\n\t\t\t\t\tv_texCoords = " + Shader.TEXCOORDS + ";\n\t\t\t\t\tgl_Position = " + Shader.MVP_MATRIX + " * " + Shader.POSITION + ";\n\t\t\t\t}\n\t\t\t";
  				var fs = "\n\t\t\t\t#ifdef GL_ES\n\t\t\t\t\t#define LOWP lowp\n\t\t\t\t\tprecision mediump float;\n\t\t\t\t#else\n\t\t\t\t\t#define LOWP\n\t\t\t\t#endif\n\t\t\t\tvarying LOWP vec4 v_color;\n\t\t\t\tvarying vec2 v_texCoords;\n\t\t\t\tuniform sampler2D u_texture;\n\n\t\t\t\tvoid main () {\n\t\t\t\t\tgl_FragColor = v_color * texture2D(u_texture, v_texCoords);\n\t\t\t\t}\n\t\t\t";
  				return new Shader(context, vs, fs);
  			};
  			Shader.newTwoColoredTextured = function (context) {
  				var vs = "\n\t\t\t\tattribute vec4 " + Shader.POSITION + ";\n\t\t\t\tattribute vec4 " + Shader.COLOR + ";\n\t\t\t\tattribute vec4 " + Shader.COLOR2 + ";\n\t\t\t\tattribute vec2 " + Shader.TEXCOORDS + ";\n\t\t\t\tuniform mat4 " + Shader.MVP_MATRIX + ";\n\t\t\t\tvarying vec4 v_light;\n\t\t\t\tvarying vec4 v_dark;\n\t\t\t\tvarying vec2 v_texCoords;\n\n\t\t\t\tvoid main () {\n\t\t\t\t\tv_light = " + Shader.COLOR + ";\n\t\t\t\t\tv_dark = " + Shader.COLOR2 + ";\n\t\t\t\t\tv_texCoords = " + Shader.TEXCOORDS + ";\n\t\t\t\t\tgl_Position = " + Shader.MVP_MATRIX + " * " + Shader.POSITION + ";\n\t\t\t\t}\n\t\t\t";
  				var fs = "\n\t\t\t\t#ifdef GL_ES\n\t\t\t\t\t#define LOWP lowp\n\t\t\t\t\tprecision mediump float;\n\t\t\t\t#else\n\t\t\t\t\t#define LOWP\n\t\t\t\t#endif\n\t\t\t\tvarying LOWP vec4 v_light;\n\t\t\t\tvarying LOWP vec4 v_dark;\n\t\t\t\tvarying vec2 v_texCoords;\n\t\t\t\tuniform sampler2D u_texture;\n\n\t\t\t\tvoid main () {\n\t\t\t\t\tvec4 texColor = texture2D(u_texture, v_texCoords);\n\t\t\t\t\tgl_FragColor.a = texColor.a * v_light.a;\n\t\t\t\t\tgl_FragColor.rgb = ((texColor.a - 1.0) * v_dark.a + 1.0 - texColor.rgb) * v_dark.rgb + texColor.rgb * v_light.rgb;\n\t\t\t\t}\n\t\t\t";
  				return new Shader(context, vs, fs);
  			};
  			Shader.newColored = function (context) {
  				var vs = "\n\t\t\t\tattribute vec4 " + Shader.POSITION + ";\n\t\t\t\tattribute vec4 " + Shader.COLOR + ";\n\t\t\t\tuniform mat4 " + Shader.MVP_MATRIX + ";\n\t\t\t\tvarying vec4 v_color;\n\n\t\t\t\tvoid main () {\n\t\t\t\t\tv_color = " + Shader.COLOR + ";\n\t\t\t\t\tgl_Position = " + Shader.MVP_MATRIX + " * " + Shader.POSITION + ";\n\t\t\t\t}\n\t\t\t";
  				var fs = "\n\t\t\t\t#ifdef GL_ES\n\t\t\t\t\t#define LOWP lowp\n\t\t\t\t\tprecision mediump float;\n\t\t\t\t#else\n\t\t\t\t\t#define LOWP\n\t\t\t\t#endif\n\t\t\t\tvarying LOWP vec4 v_color;\n\n\t\t\t\tvoid main () {\n\t\t\t\t\tgl_FragColor = v_color;\n\t\t\t\t}\n\t\t\t";
  				return new Shader(context, vs, fs);
  			};
  			Shader.MVP_MATRIX = "u_projTrans";
  			Shader.POSITION = "a_position";
  			Shader.COLOR = "a_color";
  			Shader.COLOR2 = "a_color2";
  			Shader.TEXCOORDS = "a_texCoords";
  			Shader.SAMPLER = "u_texture";
  			return Shader;
  		}());
  		webgl.Shader = Shader;
  	})(webgl = spine.webgl || (spine.webgl = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var webgl;
  	(function (webgl) {
  		var ShapeRenderer = (function () {
  			function ShapeRenderer(context, maxVertices) {
  				if (maxVertices === void 0) { maxVertices = 10920; }
  				this.isDrawing = false;
  				this.shapeType = ShapeType.Filled;
  				this.color = new spine.Color(1, 1, 1, 1);
  				this.vertexIndex = 0;
  				this.tmp = new spine.Vector2();
  				if (maxVertices > 10920)
  					throw new Error("Can't have more than 10920 triangles per batch: " + maxVertices);
  				this.context = context instanceof webgl.ManagedWebGLRenderingContext ? context : new webgl.ManagedWebGLRenderingContext(context);
  				this.mesh = new webgl.Mesh(context, [new webgl.Position2Attribute(), new webgl.ColorAttribute()], maxVertices, 0);
  				this.srcBlend = this.context.gl.SRC_ALPHA;
  				this.dstBlend = this.context.gl.ONE_MINUS_SRC_ALPHA;
  			}
  			ShapeRenderer.prototype.begin = function (shader) {
  				if (this.isDrawing)
  					throw new Error("ShapeRenderer.begin() has already been called");
  				this.shader = shader;
  				this.vertexIndex = 0;
  				this.isDrawing = true;
  				var gl = this.context.gl;
  				gl.enable(gl.BLEND);
  				gl.blendFunc(this.srcBlend, this.dstBlend);
  			};
  			ShapeRenderer.prototype.setBlendMode = function (srcBlend, dstBlend) {
  				var gl = this.context.gl;
  				this.srcBlend = srcBlend;
  				this.dstBlend = dstBlend;
  				if (this.isDrawing) {
  					this.flush();
  					gl.blendFunc(this.srcBlend, this.dstBlend);
  				}
  			};
  			ShapeRenderer.prototype.setColor = function (color) {
  				this.color.setFromColor(color);
  			};
  			ShapeRenderer.prototype.setColorWith = function (r, g, b, a) {
  				this.color.set(r, g, b, a);
  			};
  			ShapeRenderer.prototype.point = function (x, y, color) {
  				if (color === void 0) { color = null; }
  				this.check(ShapeType.Point, 1);
  				if (color === null)
  					color = this.color;
  				this.vertex(x, y, color);
  			};
  			ShapeRenderer.prototype.line = function (x, y, x2, y2, color) {
  				if (color === void 0) { color = null; }
  				this.check(ShapeType.Line, 2);
  				var vertices = this.mesh.getVertices();
  				var idx = this.vertexIndex;
  				if (color === null)
  					color = this.color;
  				this.vertex(x, y, color);
  				this.vertex(x2, y2, color);
  			};
  			ShapeRenderer.prototype.triangle = function (filled, x, y, x2, y2, x3, y3, color, color2, color3) {
  				if (color === void 0) { color = null; }
  				if (color2 === void 0) { color2 = null; }
  				if (color3 === void 0) { color3 = null; }
  				this.check(filled ? ShapeType.Filled : ShapeType.Line, 3);
  				var vertices = this.mesh.getVertices();
  				var idx = this.vertexIndex;
  				if (color === null)
  					color = this.color;
  				if (color2 === null)
  					color2 = this.color;
  				if (color3 === null)
  					color3 = this.color;
  				if (filled) {
  					this.vertex(x, y, color);
  					this.vertex(x2, y2, color2);
  					this.vertex(x3, y3, color3);
  				}
  				else {
  					this.vertex(x, y, color);
  					this.vertex(x2, y2, color2);
  					this.vertex(x2, y2, color);
  					this.vertex(x3, y3, color2);
  					this.vertex(x3, y3, color);
  					this.vertex(x, y, color2);
  				}
  			};
  			ShapeRenderer.prototype.quad = function (filled, x, y, x2, y2, x3, y3, x4, y4, color, color2, color3, color4) {
  				if (color === void 0) { color = null; }
  				if (color2 === void 0) { color2 = null; }
  				if (color3 === void 0) { color3 = null; }
  				if (color4 === void 0) { color4 = null; }
  				this.check(filled ? ShapeType.Filled : ShapeType.Line, 3);
  				var vertices = this.mesh.getVertices();
  				var idx = this.vertexIndex;
  				if (color === null)
  					color = this.color;
  				if (color2 === null)
  					color2 = this.color;
  				if (color3 === null)
  					color3 = this.color;
  				if (color4 === null)
  					color4 = this.color;
  				if (filled) {
  					this.vertex(x, y, color);
  					this.vertex(x2, y2, color2);
  					this.vertex(x3, y3, color3);
  					this.vertex(x3, y3, color3);
  					this.vertex(x4, y4, color4);
  					this.vertex(x, y, color);
  				}
  				else {
  					this.vertex(x, y, color);
  					this.vertex(x2, y2, color2);
  					this.vertex(x2, y2, color2);
  					this.vertex(x3, y3, color3);
  					this.vertex(x3, y3, color3);
  					this.vertex(x4, y4, color4);
  					this.vertex(x4, y4, color4);
  					this.vertex(x, y, color);
  				}
  			};
  			ShapeRenderer.prototype.rect = function (filled, x, y, width, height, color) {
  				if (color === void 0) { color = null; }
  				this.quad(filled, x, y, x + width, y, x + width, y + height, x, y + height, color, color, color, color);
  			};
  			ShapeRenderer.prototype.rectLine = function (filled, x1, y1, x2, y2, width, color) {
  				if (color === void 0) { color = null; }
  				this.check(filled ? ShapeType.Filled : ShapeType.Line, 8);
  				if (color === null)
  					color = this.color;
  				var t = this.tmp.set(y2 - y1, x1 - x2);
  				t.normalize();
  				width *= 0.5;
  				var tx = t.x * width;
  				var ty = t.y * width;
  				if (!filled) {
  					this.vertex(x1 + tx, y1 + ty, color);
  					this.vertex(x1 - tx, y1 - ty, color);
  					this.vertex(x2 + tx, y2 + ty, color);
  					this.vertex(x2 - tx, y2 - ty, color);
  					this.vertex(x2 + tx, y2 + ty, color);
  					this.vertex(x1 + tx, y1 + ty, color);
  					this.vertex(x2 - tx, y2 - ty, color);
  					this.vertex(x1 - tx, y1 - ty, color);
  				}
  				else {
  					this.vertex(x1 + tx, y1 + ty, color);
  					this.vertex(x1 - tx, y1 - ty, color);
  					this.vertex(x2 + tx, y2 + ty, color);
  					this.vertex(x2 - tx, y2 - ty, color);
  					this.vertex(x2 + tx, y2 + ty, color);
  					this.vertex(x1 - tx, y1 - ty, color);
  				}
  			};
  			ShapeRenderer.prototype.x = function (x, y, size) {
  				this.line(x - size, y - size, x + size, y + size);
  				this.line(x - size, y + size, x + size, y - size);
  			};
  			ShapeRenderer.prototype.polygon = function (polygonVertices, offset, count, color) {
  				if (color === void 0) { color = null; }
  				if (count < 3)
  					throw new Error("Polygon must contain at least 3 vertices");
  				this.check(ShapeType.Line, count * 2);
  				if (color === null)
  					color = this.color;
  				var vertices = this.mesh.getVertices();
  				var idx = this.vertexIndex;
  				offset <<= 1;
  				count <<= 1;
  				var firstX = polygonVertices[offset];
  				var firstY = polygonVertices[offset + 1];
  				var last = offset + count;
  				for (var i = offset, n = offset + count - 2; i < n; i += 2) {
  					var x1 = polygonVertices[i];
  					var y1 = polygonVertices[i + 1];
  					var x2 = 0;
  					var y2 = 0;
  					if (i + 2 >= last) {
  						x2 = firstX;
  						y2 = firstY;
  					}
  					else {
  						x2 = polygonVertices[i + 2];
  						y2 = polygonVertices[i + 3];
  					}
  					this.vertex(x1, y1, color);
  					this.vertex(x2, y2, color);
  				}
  			};
  			ShapeRenderer.prototype.circle = function (filled, x, y, radius, color, segments) {
  				if (color === void 0) { color = null; }
  				if (segments === void 0) { segments = 0; }
  				if (segments === 0)
  					segments = Math.max(1, (6 * spine.MathUtils.cbrt(radius)) | 0);
  				if (segments <= 0)
  					throw new Error("segments must be > 0.");
  				if (color === null)
  					color = this.color;
  				var angle = 2 * spine.MathUtils.PI / segments;
  				var cos = Math.cos(angle);
  				var sin = Math.sin(angle);
  				var cx = radius, cy = 0;
  				if (!filled) {
  					this.check(ShapeType.Line, segments * 2 + 2);
  					for (var i = 0; i < segments; i++) {
  						this.vertex(x + cx, y + cy, color);
  						var temp_1 = cx;
  						cx = cos * cx - sin * cy;
  						cy = sin * temp_1 + cos * cy;
  						this.vertex(x + cx, y + cy, color);
  					}
  					this.vertex(x + cx, y + cy, color);
  				}
  				else {
  					this.check(ShapeType.Filled, segments * 3 + 3);
  					segments--;
  					for (var i = 0; i < segments; i++) {
  						this.vertex(x, y, color);
  						this.vertex(x + cx, y + cy, color);
  						var temp_2 = cx;
  						cx = cos * cx - sin * cy;
  						cy = sin * temp_2 + cos * cy;
  						this.vertex(x + cx, y + cy, color);
  					}
  					this.vertex(x, y, color);
  					this.vertex(x + cx, y + cy, color);
  				}
  				var temp = cx;
  				cx = radius;
  				cy = 0;
  				this.vertex(x + cx, y + cy, color);
  			};
  			ShapeRenderer.prototype.curve = function (x1, y1, cx1, cy1, cx2, cy2, x2, y2, segments, color) {
  				if (color === void 0) { color = null; }
  				this.check(ShapeType.Line, segments * 2 + 2);
  				if (color === null)
  					color = this.color;
  				var subdiv_step = 1 / segments;
  				var subdiv_step2 = subdiv_step * subdiv_step;
  				var subdiv_step3 = subdiv_step * subdiv_step * subdiv_step;
  				var pre1 = 3 * subdiv_step;
  				var pre2 = 3 * subdiv_step2;
  				var pre4 = 6 * subdiv_step2;
  				var pre5 = 6 * subdiv_step3;
  				var tmp1x = x1 - cx1 * 2 + cx2;
  				var tmp1y = y1 - cy1 * 2 + cy2;
  				var tmp2x = (cx1 - cx2) * 3 - x1 + x2;
  				var tmp2y = (cy1 - cy2) * 3 - y1 + y2;
  				var fx = x1;
  				var fy = y1;
  				var dfx = (cx1 - x1) * pre1 + tmp1x * pre2 + tmp2x * subdiv_step3;
  				var dfy = (cy1 - y1) * pre1 + tmp1y * pre2 + tmp2y * subdiv_step3;
  				var ddfx = tmp1x * pre4 + tmp2x * pre5;
  				var ddfy = tmp1y * pre4 + tmp2y * pre5;
  				var dddfx = tmp2x * pre5;
  				var dddfy = tmp2y * pre5;
  				while (segments-- > 0) {
  					this.vertex(fx, fy, color);
  					fx += dfx;
  					fy += dfy;
  					dfx += ddfx;
  					dfy += ddfy;
  					ddfx += dddfx;
  					ddfy += dddfy;
  					this.vertex(fx, fy, color);
  				}
  				this.vertex(fx, fy, color);
  				this.vertex(x2, y2, color);
  			};
  			ShapeRenderer.prototype.vertex = function (x, y, color) {
  				var idx = this.vertexIndex;
  				var vertices = this.mesh.getVertices();
  				vertices[idx++] = x;
  				vertices[idx++] = y;
  				vertices[idx++] = color.r;
  				vertices[idx++] = color.g;
  				vertices[idx++] = color.b;
  				vertices[idx++] = color.a;
  				this.vertexIndex = idx;
  			};
  			ShapeRenderer.prototype.end = function () {
  				if (!this.isDrawing)
  					throw new Error("ShapeRenderer.begin() has not been called");
  				this.flush();
  				this.context.gl.disable(this.context.gl.BLEND);
  				this.isDrawing = false;
  			};
  			ShapeRenderer.prototype.flush = function () {
  				if (this.vertexIndex == 0)
  					return;
  				this.mesh.setVerticesLength(this.vertexIndex);
  				this.mesh.draw(this.shader, this.shapeType);
  				this.vertexIndex = 0;
  			};
  			ShapeRenderer.prototype.check = function (shapeType, numVertices) {
  				if (!this.isDrawing)
  					throw new Error("ShapeRenderer.begin() has not been called");
  				if (this.shapeType == shapeType) {
  					if (this.mesh.maxVertices() - this.mesh.numVertices() < numVertices)
  						this.flush();
  					else
  						return;
  				}
  				else {
  					this.flush();
  					this.shapeType = shapeType;
  				}
  			};
  			ShapeRenderer.prototype.dispose = function () {
  				this.mesh.dispose();
  			};
  			return ShapeRenderer;
  		}());
  		webgl.ShapeRenderer = ShapeRenderer;
  		var ShapeType;
  		(function (ShapeType) {
  			ShapeType[ShapeType["Point"] = 0] = "Point";
  			ShapeType[ShapeType["Line"] = 1] = "Line";
  			ShapeType[ShapeType["Filled"] = 4] = "Filled";
  		})(ShapeType = webgl.ShapeType || (webgl.ShapeType = {}));
  	})(webgl = spine.webgl || (spine.webgl = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var webgl;
  	(function (webgl) {
  		var SkeletonDebugRenderer = (function () {
  			function SkeletonDebugRenderer(context) {
  				this.boneLineColor = new spine.Color(1, 0, 0, 1);
  				this.boneOriginColor = new spine.Color(0, 1, 0, 1);
  				this.attachmentLineColor = new spine.Color(0, 0, 1, 0.5);
  				this.triangleLineColor = new spine.Color(1, 0.64, 0, 0.5);
  				this.pathColor = new spine.Color().setFromString("FF7F00");
  				this.clipColor = new spine.Color(0.8, 0, 0, 2);
  				this.aabbColor = new spine.Color(0, 1, 0, 0.5);
  				this.drawBones = true;
  				this.drawRegionAttachments = true;
  				this.drawBoundingBoxes = true;
  				this.drawMeshHull = true;
  				this.drawMeshTriangles = true;
  				this.drawPaths = true;
  				this.drawSkeletonXY = false;
  				this.drawClipping = true;
  				this.premultipliedAlpha = false;
  				this.scale = 1;
  				this.boneWidth = 2;
  				this.bounds = new spine.SkeletonBounds();
  				this.temp = new Array();
  				this.vertices = spine.Utils.newFloatArray(2 * 1024);
  				this.context = context instanceof webgl.ManagedWebGLRenderingContext ? context : new webgl.ManagedWebGLRenderingContext(context);
  			}
  			SkeletonDebugRenderer.prototype.draw = function (shapes, skeleton, ignoredBones) {
  				if (ignoredBones === void 0) { ignoredBones = null; }
  				var skeletonX = skeleton.x;
  				var skeletonY = skeleton.y;
  				var gl = this.context.gl;
  				var srcFunc = this.premultipliedAlpha ? gl.ONE : gl.SRC_ALPHA;
  				shapes.setBlendMode(srcFunc, gl.ONE_MINUS_SRC_ALPHA);
  				var bones = skeleton.bones;
  				if (this.drawBones) {
  					shapes.setColor(this.boneLineColor);
  					for (var i = 0, n = bones.length; i < n; i++) {
  						var bone = bones[i];
  						if (ignoredBones && ignoredBones.indexOf(bone.data.name) > -1)
  							continue;
  						if (bone.parent == null)
  							continue;
  						var x = skeletonX + bone.data.length * bone.a + bone.worldX;
  						var y = skeletonY + bone.data.length * bone.c + bone.worldY;
  						shapes.rectLine(true, skeletonX + bone.worldX, skeletonY + bone.worldY, x, y, this.boneWidth * this.scale);
  					}
  					if (this.drawSkeletonXY)
  						shapes.x(skeletonX, skeletonY, 4 * this.scale);
  				}
  				if (this.drawRegionAttachments) {
  					shapes.setColor(this.attachmentLineColor);
  					var slots = skeleton.slots;
  					for (var i = 0, n = slots.length; i < n; i++) {
  						var slot = slots[i];
  						var attachment = slot.getAttachment();
  						if (attachment instanceof spine.RegionAttachment) {
  							var regionAttachment = attachment;
  							var vertices = this.vertices;
  							regionAttachment.computeWorldVertices(slot.bone, vertices, 0, 2);
  							shapes.line(vertices[0], vertices[1], vertices[2], vertices[3]);
  							shapes.line(vertices[2], vertices[3], vertices[4], vertices[5]);
  							shapes.line(vertices[4], vertices[5], vertices[6], vertices[7]);
  							shapes.line(vertices[6], vertices[7], vertices[0], vertices[1]);
  						}
  					}
  				}
  				if (this.drawMeshHull || this.drawMeshTriangles) {
  					var slots = skeleton.slots;
  					for (var i = 0, n = slots.length; i < n; i++) {
  						var slot = slots[i];
  						if (!slot.bone.active)
  							continue;
  						var attachment = slot.getAttachment();
  						if (!(attachment instanceof spine.MeshAttachment))
  							continue;
  						var mesh = attachment;
  						var vertices = this.vertices;
  						mesh.computeWorldVertices(slot, 0, mesh.worldVerticesLength, vertices, 0, 2);
  						var triangles = mesh.triangles;
  						var hullLength = mesh.hullLength;
  						if (this.drawMeshTriangles) {
  							shapes.setColor(this.triangleLineColor);
  							for (var ii = 0, nn = triangles.length; ii < nn; ii += 3) {
  								var v1 = triangles[ii] * 2, v2 = triangles[ii + 1] * 2, v3 = triangles[ii + 2] * 2;
  								shapes.triangle(false, vertices[v1], vertices[v1 + 1], vertices[v2], vertices[v2 + 1], vertices[v3], vertices[v3 + 1]);
  							}
  						}
  						if (this.drawMeshHull && hullLength > 0) {
  							shapes.setColor(this.attachmentLineColor);
  							hullLength = (hullLength >> 1) * 2;
  							var lastX = vertices[hullLength - 2], lastY = vertices[hullLength - 1];
  							for (var ii = 0, nn = hullLength; ii < nn; ii += 2) {
  								var x = vertices[ii], y = vertices[ii + 1];
  								shapes.line(x, y, lastX, lastY);
  								lastX = x;
  								lastY = y;
  							}
  						}
  					}
  				}
  				if (this.drawBoundingBoxes) {
  					var bounds = this.bounds;
  					bounds.update(skeleton, true);
  					shapes.setColor(this.aabbColor);
  					shapes.rect(false, bounds.minX, bounds.minY, bounds.getWidth(), bounds.getHeight());
  					var polygons = bounds.polygons;
  					var boxes = bounds.boundingBoxes;
  					for (var i = 0, n = polygons.length; i < n; i++) {
  						var polygon = polygons[i];
  						shapes.setColor(boxes[i].color);
  						shapes.polygon(polygon, 0, polygon.length);
  					}
  				}
  				if (this.drawPaths) {
  					var slots = skeleton.slots;
  					for (var i = 0, n = slots.length; i < n; i++) {
  						var slot = slots[i];
  						if (!slot.bone.active)
  							continue;
  						var attachment = slot.getAttachment();
  						if (!(attachment instanceof spine.PathAttachment))
  							continue;
  						var path = attachment;
  						var nn = path.worldVerticesLength;
  						var world = this.temp = spine.Utils.setArraySize(this.temp, nn, 0);
  						path.computeWorldVertices(slot, 0, nn, world, 0, 2);
  						var color = this.pathColor;
  						var x1 = world[2], y1 = world[3], x2 = 0, y2 = 0;
  						if (path.closed) {
  							shapes.setColor(color);
  							var cx1 = world[0], cy1 = world[1], cx2 = world[nn - 2], cy2 = world[nn - 1];
  							x2 = world[nn - 4];
  							y2 = world[nn - 3];
  							shapes.curve(x1, y1, cx1, cy1, cx2, cy2, x2, y2, 32);
  							shapes.setColor(SkeletonDebugRenderer.LIGHT_GRAY);
  							shapes.line(x1, y1, cx1, cy1);
  							shapes.line(x2, y2, cx2, cy2);
  						}
  						nn -= 4;
  						for (var ii = 4; ii < nn; ii += 6) {
  							var cx1 = world[ii], cy1 = world[ii + 1], cx2 = world[ii + 2], cy2 = world[ii + 3];
  							x2 = world[ii + 4];
  							y2 = world[ii + 5];
  							shapes.setColor(color);
  							shapes.curve(x1, y1, cx1, cy1, cx2, cy2, x2, y2, 32);
  							shapes.setColor(SkeletonDebugRenderer.LIGHT_GRAY);
  							shapes.line(x1, y1, cx1, cy1);
  							shapes.line(x2, y2, cx2, cy2);
  							x1 = x2;
  							y1 = y2;
  						}
  					}
  				}
  				if (this.drawBones) {
  					shapes.setColor(this.boneOriginColor);
  					for (var i = 0, n = bones.length; i < n; i++) {
  						var bone = bones[i];
  						if (ignoredBones && ignoredBones.indexOf(bone.data.name) > -1)
  							continue;
  						shapes.circle(true, skeletonX + bone.worldX, skeletonY + bone.worldY, 3 * this.scale, SkeletonDebugRenderer.GREEN, 8);
  					}
  				}
  				if (this.drawClipping) {
  					var slots = skeleton.slots;
  					shapes.setColor(this.clipColor);
  					for (var i = 0, n = slots.length; i < n; i++) {
  						var slot = slots[i];
  						if (!slot.bone.active)
  							continue;
  						var attachment = slot.getAttachment();
  						if (!(attachment instanceof spine.ClippingAttachment))
  							continue;
  						var clip = attachment;
  						var nn = clip.worldVerticesLength;
  						var world = this.temp = spine.Utils.setArraySize(this.temp, nn, 0);
  						clip.computeWorldVertices(slot, 0, nn, world, 0, 2);
  						for (var i_21 = 0, n_3 = world.length; i_21 < n_3; i_21 += 2) {
  							var x = world[i_21];
  							var y = world[i_21 + 1];
  							var x2 = world[(i_21 + 2) % world.length];
  							var y2 = world[(i_21 + 3) % world.length];
  							shapes.line(x, y, x2, y2);
  						}
  					}
  				}
  			};
  			SkeletonDebugRenderer.prototype.dispose = function () {
  			};
  			SkeletonDebugRenderer.LIGHT_GRAY = new spine.Color(192 / 255, 192 / 255, 192 / 255, 1);
  			SkeletonDebugRenderer.GREEN = new spine.Color(0, 1, 0, 1);
  			return SkeletonDebugRenderer;
  		}());
  		webgl.SkeletonDebugRenderer = SkeletonDebugRenderer;
  	})(webgl = spine.webgl || (spine.webgl = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var webgl;
  	(function (webgl) {
  		var Renderable = (function () {
  			function Renderable(vertices, numVertices, numFloats) {
  				this.vertices = vertices;
  				this.numVertices = numVertices;
  				this.numFloats = numFloats;
  			}
  			return Renderable;
  		}());
  		;
  		var SkeletonRenderer = (function () {
  			function SkeletonRenderer(context, twoColorTint) {
  				if (twoColorTint === void 0) { twoColorTint = true; }
  				this.premultipliedAlpha = false;
  				this.vertexEffect = null;
  				this.tempColor = new spine.Color();
  				this.tempColor2 = new spine.Color();
  				this.vertexSize = 2 + 2 + 4;
  				this.twoColorTint = false;
  				this.renderable = new Renderable(null, 0, 0);
  				this.clipper = new spine.SkeletonClipping();
  				this.temp = new spine.Vector2();
  				this.temp2 = new spine.Vector2();
  				this.temp3 = new spine.Color();
  				this.temp4 = new spine.Color();
  				this.twoColorTint = twoColorTint;
  				if (twoColorTint)
  					this.vertexSize += 4;
  				this.vertices = spine.Utils.newFloatArray(this.vertexSize * 1024);
  			}
  			SkeletonRenderer.prototype.draw = function (batcher, skeleton, slotRangeStart, slotRangeEnd) {
  				if (slotRangeStart === void 0) { slotRangeStart = -1; }
  				if (slotRangeEnd === void 0) { slotRangeEnd = -1; }
  				var clipper = this.clipper;
  				var premultipliedAlpha = this.premultipliedAlpha;
  				var twoColorTint = this.twoColorTint;
  				var blendMode = null;
  				var tempPos = this.temp;
  				var tempUv = this.temp2;
  				var tempLight = this.temp3;
  				var tempDark = this.temp4;
  				var renderable = this.renderable;
  				var uvs = null;
  				var triangles = null;
  				var drawOrder = skeleton.drawOrder;
  				var attachmentColor = null;
  				var skeletonColor = skeleton.color;
  				var vertexSize = twoColorTint ? 12 : 8;
  				var inRange = false;
  				if (slotRangeStart == -1)
  					inRange = true;
  				for (var i = 0, n = drawOrder.length; i < n; i++) {
  					var clippedVertexSize = clipper.isClipping() ? 2 : vertexSize;
  					var slot = drawOrder[i];
  					if (!slot.bone.active) {
  						clipper.clipEndWithSlot(slot);
  						continue;
  					}
  					if (slotRangeStart >= 0 && slotRangeStart == slot.data.index) {
  						inRange = true;
  					}
  					if (!inRange) {
  						clipper.clipEndWithSlot(slot);
  						continue;
  					}
  					if (slotRangeEnd >= 0 && slotRangeEnd == slot.data.index) {
  						inRange = false;
  					}
  					var attachment = slot.getAttachment();
  					var texture = null;
  					if (attachment instanceof spine.RegionAttachment) {
  						var region = attachment;
  						renderable.vertices = this.vertices;
  						renderable.numVertices = 4;
  						renderable.numFloats = clippedVertexSize << 2;
  						region.computeWorldVertices(slot.bone, renderable.vertices, 0, clippedVertexSize);
  						triangles = SkeletonRenderer.QUAD_TRIANGLES;
  						uvs = region.uvs;
  						texture = region.region.renderObject.texture;
  						attachmentColor = region.color;
  					}
  					else if (attachment instanceof spine.MeshAttachment) {
  						var mesh = attachment;
  						renderable.vertices = this.vertices;
  						renderable.numVertices = (mesh.worldVerticesLength >> 1);
  						renderable.numFloats = renderable.numVertices * clippedVertexSize;
  						if (renderable.numFloats > renderable.vertices.length) {
  							renderable.vertices = this.vertices = spine.Utils.newFloatArray(renderable.numFloats);
  						}
  						mesh.computeWorldVertices(slot, 0, mesh.worldVerticesLength, renderable.vertices, 0, clippedVertexSize);
  						triangles = mesh.triangles;
  						texture = mesh.region.renderObject.texture;
  						uvs = mesh.uvs;
  						attachmentColor = mesh.color;
  					}
  					else if (attachment instanceof spine.ClippingAttachment) {
  						var clip = (attachment);
  						clipper.clipStart(slot, clip);
  						continue;
  					}
  					else {
  						clipper.clipEndWithSlot(slot);
  						continue;
  					}
  					if (texture != null) {
  						var slotColor = slot.color;
  						var finalColor = this.tempColor;
  						finalColor.r = skeletonColor.r * slotColor.r * attachmentColor.r;
  						finalColor.g = skeletonColor.g * slotColor.g * attachmentColor.g;
  						finalColor.b = skeletonColor.b * slotColor.b * attachmentColor.b;
  						finalColor.a = skeletonColor.a * slotColor.a * attachmentColor.a;
  						if (premultipliedAlpha) {
  							finalColor.r *= finalColor.a;
  							finalColor.g *= finalColor.a;
  							finalColor.b *= finalColor.a;
  						}
  						var darkColor = this.tempColor2;
  						if (slot.darkColor == null)
  							darkColor.set(0, 0, 0, 1.0);
  						else {
  							if (premultipliedAlpha) {
  								darkColor.r = slot.darkColor.r * finalColor.a;
  								darkColor.g = slot.darkColor.g * finalColor.a;
  								darkColor.b = slot.darkColor.b * finalColor.a;
  							}
  							else {
  								darkColor.setFromColor(slot.darkColor);
  							}
  							darkColor.a = premultipliedAlpha ? 1.0 : 0.0;
  						}
  						var slotBlendMode = slot.data.blendMode;
  						if (slotBlendMode != blendMode) {
  							blendMode = slotBlendMode;
  							batcher.setBlendMode(webgl.WebGLBlendModeConverter.getSourceGLBlendMode(blendMode, premultipliedAlpha), webgl.WebGLBlendModeConverter.getDestGLBlendMode(blendMode));
  						}
  						if (clipper.isClipping()) {
  							clipper.clipTriangles(renderable.vertices, renderable.numFloats, triangles, triangles.length, uvs, finalColor, darkColor, twoColorTint);
  							var clippedVertices = new Float32Array(clipper.clippedVertices);
  							var clippedTriangles = clipper.clippedTriangles;
  							if (this.vertexEffect != null) {
  								var vertexEffect = this.vertexEffect;
  								var verts = clippedVertices;
  								if (!twoColorTint) {
  									for (var v = 0, n_4 = clippedVertices.length; v < n_4; v += vertexSize) {
  										tempPos.x = verts[v];
  										tempPos.y = verts[v + 1];
  										tempLight.set(verts[v + 2], verts[v + 3], verts[v + 4], verts[v + 5]);
  										tempUv.x = verts[v + 6];
  										tempUv.y = verts[v + 7];
  										tempDark.set(0, 0, 0, 0);
  										vertexEffect.transform(tempPos, tempUv, tempLight, tempDark);
  										verts[v] = tempPos.x;
  										verts[v + 1] = tempPos.y;
  										verts[v + 2] = tempLight.r;
  										verts[v + 3] = tempLight.g;
  										verts[v + 4] = tempLight.b;
  										verts[v + 5] = tempLight.a;
  										verts[v + 6] = tempUv.x;
  										verts[v + 7] = tempUv.y;
  									}
  								}
  								else {
  									for (var v = 0, n_5 = clippedVertices.length; v < n_5; v += vertexSize) {
  										tempPos.x = verts[v];
  										tempPos.y = verts[v + 1];
  										tempLight.set(verts[v + 2], verts[v + 3], verts[v + 4], verts[v + 5]);
  										tempUv.x = verts[v + 6];
  										tempUv.y = verts[v + 7];
  										tempDark.set(verts[v + 8], verts[v + 9], verts[v + 10], verts[v + 11]);
  										vertexEffect.transform(tempPos, tempUv, tempLight, tempDark);
  										verts[v] = tempPos.x;
  										verts[v + 1] = tempPos.y;
  										verts[v + 2] = tempLight.r;
  										verts[v + 3] = tempLight.g;
  										verts[v + 4] = tempLight.b;
  										verts[v + 5] = tempLight.a;
  										verts[v + 6] = tempUv.x;
  										verts[v + 7] = tempUv.y;
  										verts[v + 8] = tempDark.r;
  										verts[v + 9] = tempDark.g;
  										verts[v + 10] = tempDark.b;
  										verts[v + 11] = tempDark.a;
  									}
  								}
  							}
  							batcher.draw(texture, clippedVertices, clippedTriangles);
  						}
  						else {
  							var verts = renderable.vertices;
  							if (this.vertexEffect != null) {
  								var vertexEffect = this.vertexEffect;
  								if (!twoColorTint) {
  									for (var v = 0, u = 0, n_6 = renderable.numFloats; v < n_6; v += vertexSize, u += 2) {
  										tempPos.x = verts[v];
  										tempPos.y = verts[v + 1];
  										tempUv.x = uvs[u];
  										tempUv.y = uvs[u + 1];
  										tempLight.setFromColor(finalColor);
  										tempDark.set(0, 0, 0, 0);
  										vertexEffect.transform(tempPos, tempUv, tempLight, tempDark);
  										verts[v] = tempPos.x;
  										verts[v + 1] = tempPos.y;
  										verts[v + 2] = tempLight.r;
  										verts[v + 3] = tempLight.g;
  										verts[v + 4] = tempLight.b;
  										verts[v + 5] = tempLight.a;
  										verts[v + 6] = tempUv.x;
  										verts[v + 7] = tempUv.y;
  									}
  								}
  								else {
  									for (var v = 0, u = 0, n_7 = renderable.numFloats; v < n_7; v += vertexSize, u += 2) {
  										tempPos.x = verts[v];
  										tempPos.y = verts[v + 1];
  										tempUv.x = uvs[u];
  										tempUv.y = uvs[u + 1];
  										tempLight.setFromColor(finalColor);
  										tempDark.setFromColor(darkColor);
  										vertexEffect.transform(tempPos, tempUv, tempLight, tempDark);
  										verts[v] = tempPos.x;
  										verts[v + 1] = tempPos.y;
  										verts[v + 2] = tempLight.r;
  										verts[v + 3] = tempLight.g;
  										verts[v + 4] = tempLight.b;
  										verts[v + 5] = tempLight.a;
  										verts[v + 6] = tempUv.x;
  										verts[v + 7] = tempUv.y;
  										verts[v + 8] = tempDark.r;
  										verts[v + 9] = tempDark.g;
  										verts[v + 10] = tempDark.b;
  										verts[v + 11] = tempDark.a;
  									}
  								}
  							}
  							else {
  								if (!twoColorTint) {
  									for (var v = 2, u = 0, n_8 = renderable.numFloats; v < n_8; v += vertexSize, u += 2) {
  										verts[v] = finalColor.r;
  										verts[v + 1] = finalColor.g;
  										verts[v + 2] = finalColor.b;
  										verts[v + 3] = finalColor.a;
  										verts[v + 4] = uvs[u];
  										verts[v + 5] = uvs[u + 1];
  									}
  								}
  								else {
  									for (var v = 2, u = 0, n_9 = renderable.numFloats; v < n_9; v += vertexSize, u += 2) {
  										verts[v] = finalColor.r;
  										verts[v + 1] = finalColor.g;
  										verts[v + 2] = finalColor.b;
  										verts[v + 3] = finalColor.a;
  										verts[v + 4] = uvs[u];
  										verts[v + 5] = uvs[u + 1];
  										verts[v + 6] = darkColor.r;
  										verts[v + 7] = darkColor.g;
  										verts[v + 8] = darkColor.b;
  										verts[v + 9] = darkColor.a;
  									}
  								}
  							}
  							var view = renderable.vertices.subarray(0, renderable.numFloats);
  							batcher.draw(texture, view, triangles);
  						}
  					}
  					clipper.clipEndWithSlot(slot);
  				}
  				clipper.clipEnd();
  			};
  			SkeletonRenderer.QUAD_TRIANGLES = [0, 1, 2, 2, 3, 0];
  			return SkeletonRenderer;
  		}());
  		webgl.SkeletonRenderer = SkeletonRenderer;
  	})(webgl = spine.webgl || (spine.webgl = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var webgl;
  	(function (webgl) {
  		var Vector3 = (function () {
  			function Vector3(x, y, z) {
  				if (x === void 0) { x = 0; }
  				if (y === void 0) { y = 0; }
  				if (z === void 0) { z = 0; }
  				this.x = 0;
  				this.y = 0;
  				this.z = 0;
  				this.x = x;
  				this.y = y;
  				this.z = z;
  			}
  			Vector3.prototype.setFrom = function (v) {
  				this.x = v.x;
  				this.y = v.y;
  				this.z = v.z;
  				return this;
  			};
  			Vector3.prototype.set = function (x, y, z) {
  				this.x = x;
  				this.y = y;
  				this.z = z;
  				return this;
  			};
  			Vector3.prototype.add = function (v) {
  				this.x += v.x;
  				this.y += v.y;
  				this.z += v.z;
  				return this;
  			};
  			Vector3.prototype.sub = function (v) {
  				this.x -= v.x;
  				this.y -= v.y;
  				this.z -= v.z;
  				return this;
  			};
  			Vector3.prototype.scale = function (s) {
  				this.x *= s;
  				this.y *= s;
  				this.z *= s;
  				return this;
  			};
  			Vector3.prototype.normalize = function () {
  				var len = this.length();
  				if (len == 0)
  					return this;
  				len = 1 / len;
  				this.x *= len;
  				this.y *= len;
  				this.z *= len;
  				return this;
  			};
  			Vector3.prototype.cross = function (v) {
  				return this.set(this.y * v.z - this.z * v.y, this.z * v.x - this.x * v.z, this.x * v.y - this.y * v.x);
  			};
  			Vector3.prototype.multiply = function (matrix) {
  				var l_mat = matrix.values;
  				return this.set(this.x * l_mat[webgl.M00] + this.y * l_mat[webgl.M01] + this.z * l_mat[webgl.M02] + l_mat[webgl.M03], this.x * l_mat[webgl.M10] + this.y * l_mat[webgl.M11] + this.z * l_mat[webgl.M12] + l_mat[webgl.M13], this.x * l_mat[webgl.M20] + this.y * l_mat[webgl.M21] + this.z * l_mat[webgl.M22] + l_mat[webgl.M23]);
  			};
  			Vector3.prototype.project = function (matrix) {
  				var l_mat = matrix.values;
  				var l_w = 1 / (this.x * l_mat[webgl.M30] + this.y * l_mat[webgl.M31] + this.z * l_mat[webgl.M32] + l_mat[webgl.M33]);
  				return this.set((this.x * l_mat[webgl.M00] + this.y * l_mat[webgl.M01] + this.z * l_mat[webgl.M02] + l_mat[webgl.M03]) * l_w, (this.x * l_mat[webgl.M10] + this.y * l_mat[webgl.M11] + this.z * l_mat[webgl.M12] + l_mat[webgl.M13]) * l_w, (this.x * l_mat[webgl.M20] + this.y * l_mat[webgl.M21] + this.z * l_mat[webgl.M22] + l_mat[webgl.M23]) * l_w);
  			};
  			Vector3.prototype.dot = function (v) {
  				return this.x * v.x + this.y * v.y + this.z * v.z;
  			};
  			Vector3.prototype.length = function () {
  				return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
  			};
  			Vector3.prototype.distance = function (v) {
  				var a = v.x - this.x;
  				var b = v.y - this.y;
  				var c = v.z - this.z;
  				return Math.sqrt(a * a + b * b + c * c);
  			};
  			return Vector3;
  		}());
  		webgl.Vector3 = Vector3;
  	})(webgl = spine.webgl || (spine.webgl = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var webgl;
  	(function (webgl) {
  		var ManagedWebGLRenderingContext = (function () {
  			function ManagedWebGLRenderingContext(canvasOrContext, contextConfig) {
  				var _this = this;
  				if (contextConfig === void 0) { contextConfig = { alpha: "true" }; }
  				this.restorables = new Array();
  				if (canvasOrContext instanceof HTMLCanvasElement) {
  					var canvas = canvasOrContext;
  					this.gl = (canvas.getContext("webgl2", contextConfig) || canvas.getContext("webgl", contextConfig));
  					this.canvas = canvas;
  					canvas.addEventListener("webglcontextlost", function (e) {
  						var event = e;
  						if (e) {
  							e.preventDefault();
  						}
  					});
  					canvas.addEventListener("webglcontextrestored", function (e) {
  						for (var i = 0, n = _this.restorables.length; i < n; i++) {
  							_this.restorables[i].restore();
  						}
  					});
  				}
  				else {
  					this.gl = canvasOrContext;
  					this.canvas = this.gl.canvas;
  				}
  			}
  			ManagedWebGLRenderingContext.prototype.addRestorable = function (restorable) {
  				this.restorables.push(restorable);
  			};
  			ManagedWebGLRenderingContext.prototype.removeRestorable = function (restorable) {
  				var index = this.restorables.indexOf(restorable);
  				if (index > -1)
  					this.restorables.splice(index, 1);
  			};
  			return ManagedWebGLRenderingContext;
  		}());
  		webgl.ManagedWebGLRenderingContext = ManagedWebGLRenderingContext;
  		var WebGLBlendModeConverter = (function () {
  			function WebGLBlendModeConverter() {
  			}
  			WebGLBlendModeConverter.getDestGLBlendMode = function (blendMode) {
  				switch (blendMode) {
  					case spine.BlendMode.Normal: return WebGLBlendModeConverter.ONE_MINUS_SRC_ALPHA;
  					case spine.BlendMode.Additive: return WebGLBlendModeConverter.ONE;
  					case spine.BlendMode.Multiply: return WebGLBlendModeConverter.ONE_MINUS_SRC_ALPHA;
  					case spine.BlendMode.Screen: return WebGLBlendModeConverter.ONE_MINUS_SRC_ALPHA;
  					default: throw new Error("Unknown blend mode: " + blendMode);
  				}
  			};
  			WebGLBlendModeConverter.getSourceGLBlendMode = function (blendMode, premultipliedAlpha) {
  				if (premultipliedAlpha === void 0) { premultipliedAlpha = false; }
  				switch (blendMode) {
  					case spine.BlendMode.Normal: return premultipliedAlpha ? WebGLBlendModeConverter.ONE : WebGLBlendModeConverter.SRC_ALPHA;
  					case spine.BlendMode.Additive: return premultipliedAlpha ? WebGLBlendModeConverter.ONE : WebGLBlendModeConverter.SRC_ALPHA;
  					case spine.BlendMode.Multiply: return WebGLBlendModeConverter.DST_COLOR;
  					case spine.BlendMode.Screen: return WebGLBlendModeConverter.ONE;
  					default: throw new Error("Unknown blend mode: " + blendMode);
  				}
  			};
  			WebGLBlendModeConverter.ZERO = 0;
  			WebGLBlendModeConverter.ONE = 1;
  			WebGLBlendModeConverter.SRC_COLOR = 0x0300;
  			WebGLBlendModeConverter.ONE_MINUS_SRC_COLOR = 0x0301;
  			WebGLBlendModeConverter.SRC_ALPHA = 0x0302;
  			WebGLBlendModeConverter.ONE_MINUS_SRC_ALPHA = 0x0303;
  			WebGLBlendModeConverter.DST_ALPHA = 0x0304;
  			WebGLBlendModeConverter.ONE_MINUS_DST_ALPHA = 0x0305;
  			WebGLBlendModeConverter.DST_COLOR = 0x0306;
  			return WebGLBlendModeConverter;
  		}());
  		webgl.WebGLBlendModeConverter = WebGLBlendModeConverter;
  	})(webgl = spine.webgl || (spine.webgl = {}));
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var Popup = (function () {
  		function Popup(player, parent, htmlContent) {
  			this.player = player;
  			this.dom = createElement("\n\t\t\t\t<div class=\"spine-player-popup spine-player-hidden\">\n\t\t\t\t</div>\n\t\t\t");
  			this.dom.innerHTML = htmlContent;
  			parent.appendChild(this.dom);
  		}
  		Popup.prototype.show = function (dismissedListener) {
  			var _this = this;
  			this.dom.classList.remove("spine-player-hidden");
  			var dismissed = false;
  			var resize = function () {
  				if (!dismissed)
  					requestAnimationFrame(resize);
  				var bottomOffset = Math.abs(_this.dom.getBoundingClientRect().bottom - _this.player.getBoundingClientRect().bottom);
  				var rightOffset = Math.abs(_this.dom.getBoundingClientRect().right - _this.player.getBoundingClientRect().right);
  				var maxHeight = _this.player.clientHeight - bottomOffset - rightOffset;
  				_this.dom.style.maxHeight = maxHeight + "px";
  			};
  			requestAnimationFrame(resize);
  			var justClicked = true;
  			var windowClickListener = function (event) {
  				if (justClicked) {
  					justClicked = false;
  					return;
  				}
  				if (!isContained(_this.dom, event.target)) {
  					_this.dom.remove();
  					window.removeEventListener("click", windowClickListener);
  					dismissedListener();
  					dismissed = true;
  				}
  			};
  			window.addEventListener("click", windowClickListener);
  		};
  		return Popup;
  	}());
  	var Switch = (function () {
  		function Switch(text) {
  			this.text = text;
  			this.enabled = false;
  		}
  		Switch.prototype.render = function () {
  			var _this = this;
  			this["switch"] = createElement("\n\t\t\t\t<div class=\"spine-player-switch\">\n\t\t\t\t\t<span class=\"spine-player-switch-text\">" + this.text + "</span>\n\t\t\t\t\t<div class=\"spine-player-switch-knob-area\">\n\t\t\t\t\t\t<div class=\"spine-player-switch-knob\"></div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t");
  			this["switch"].addEventListener("click", function () {
  				_this.setEnabled(!_this.enabled);
  				if (_this.change)
  					_this.change(_this.enabled);
  			});
  			return this["switch"];
  		};
  		Switch.prototype.setEnabled = function (enabled) {
  			if (enabled)
  				this["switch"].classList.add("active");
  			else
  				this["switch"].classList.remove("active");
  			this.enabled = enabled;
  		};
  		Switch.prototype.isEnabled = function () {
  			return this.enabled;
  		};
  		return Switch;
  	}());
  	var Slider = (function () {
  		function Slider(snaps, snapPercentage, big) {
  			if (snaps === void 0) { snaps = 0; }
  			if (snapPercentage === void 0) { snapPercentage = 0.1; }
  			if (big === void 0) { big = false; }
  			this.snaps = snaps;
  			this.snapPercentage = snapPercentage;
  			this.big = big;
  		}
  		Slider.prototype.render = function () {
  			var _this = this;
  			this.slider = createElement("\n\t\t\t\t<div class=\"spine-player-slider " + (this.big ? "big" : "") + "\">\n\t\t\t\t\t<div class=\"spine-player-slider-value\"></div>\n\t\t\t\t\t<!--<div class=\"spine-player-slider-knob\"></div>-->\n\t\t\t\t</div>\n\t\t\t");
  			this.value = findWithClass(this.slider, "spine-player-slider-value")[0];
  			this.setValue(0);
  			var input = new spine.webgl.Input(this.slider);
  			var dragging = false;
  			input.addListener({
  				down: function (x, y) {
  					dragging = true;
  					_this.value.classList.add("hovering");
  				},
  				up: function (x, y) {
  					dragging = false;
  					var percentage = x / _this.slider.clientWidth;
  					percentage = percentage = Math.max(0, Math.min(percentage, 1));
  					_this.setValue(x / _this.slider.clientWidth);
  					if (_this.change)
  						_this.change(percentage);
  					_this.value.classList.remove("hovering");
  				},
  				moved: function (x, y) {
  					if (dragging) {
  						var percentage = x / _this.slider.clientWidth;
  						percentage = Math.max(0, Math.min(percentage, 1));
  						percentage = _this.setValue(x / _this.slider.clientWidth);
  						if (_this.change)
  							_this.change(percentage);
  					}
  				},
  				dragged: function (x, y) {
  					var percentage = x / _this.slider.clientWidth;
  					percentage = Math.max(0, Math.min(percentage, 1));
  					percentage = _this.setValue(x / _this.slider.clientWidth);
  					if (_this.change)
  						_this.change(percentage);
  				}
  			});
  			return this.slider;
  		};
  		Slider.prototype.setValue = function (percentage) {
  			percentage = Math.max(0, Math.min(1, percentage));
  			if (this.snaps > 0) {
  				var modulo = percentage % (1 / this.snaps);
  				if (modulo < (1 / this.snaps) * this.snapPercentage) {
  					percentage = percentage - modulo;
  				}
  				else if (modulo > (1 / this.snaps) - (1 / this.snaps) * this.snapPercentage) {
  					percentage = percentage - modulo + (1 / this.snaps);
  				}
  				percentage = Math.max(0, Math.min(1, percentage));
  			}
  			this.value.style.width = "" + (percentage * 100) + "%";
  			return percentage;
  		};
  		return Slider;
  	}());
  	var SpinePlayer = (function () {
  		function SpinePlayer(parent, config) {
  			this.config = config;
  			this.time = new spine.TimeKeeper();
  			this.paused = true;
  			this.playTime = 0;
  			this.speed = 1;
  			this.animationViewports = {};
  			this.currentViewport = null;
  			this.previousViewport = null;
  			this.viewportTransitionStart = 0;
  			this.stopRequestAnimationFrame = false;
  			this.cancelId = 0;
  			if (typeof parent === "string")
  				this.parent = document.getElementById(parent);
  			else
  				this.parent = parent;
  			this.parent.appendChild(this.render());
  		}
  		SpinePlayer.prototype.validateConfig = function (config) {
  			if (!config)
  				throw new Error("Please pass a configuration to new.spine.SpinePlayer().");
  			if (!config.jsonUrl && !config.skelUrl)
  				throw new Error("Please specify the URL of the skeleton JSON or .skel file.");
  			if (!config.atlasUrl)
  				throw new Error("Please specify the URL of the atlas file.");
  			if (!config.alpha)
  				config.alpha = false;
  			if (!config.backgroundColor)
  				config.backgroundColor = "#000000";
  			if (!config.fullScreenBackgroundColor)
  				config.fullScreenBackgroundColor = config.backgroundColor;
  			if (typeof config.premultipliedAlpha === "undefined")
  				config.premultipliedAlpha = true;
  			if (!config.success)
  				config.success = function (widget) { };
  			if (!config.error)
  				config.error = function (widget, msg) { };
  			if (!config.debug)
  				config.debug = {
  					bones: false,
  					regions: false,
  					meshes: false,
  					bounds: false,
  					clipping: false,
  					paths: false,
  					points: false,
  					hulls: false
  				};
  			if (typeof config.debug.bones === "undefined")
  				config.debug.bones = false;
  			if (typeof config.debug.bounds === "undefined")
  				config.debug.bounds = false;
  			if (typeof config.debug.clipping === "undefined")
  				config.debug.clipping = false;
  			if (typeof config.debug.hulls === "undefined")
  				config.debug.hulls = false;
  			if (typeof config.debug.paths === "undefined")
  				config.debug.paths = false;
  			if (typeof config.debug.points === "undefined")
  				config.debug.points = false;
  			if (typeof config.debug.regions === "undefined")
  				config.debug.regions = false;
  			if (typeof config.debug.meshes === "undefined")
  				config.debug.meshes = false;
  			if (config.animations && config.animation) {
  				if (config.animations.indexOf(config.animation) < 0)
  					throw new Error("Default animation '" + config.animation + "' is not contained in the list of selectable animations " + escapeHtml(JSON.stringify(this.config.animations)) + ".");
  			}
  			if (config.skins && config.skin) {
  				if (config.skins.indexOf(config.skin) < 0)
  					throw new Error("Default skin '" + config.skin + "' is not contained in the list of selectable skins " + escapeHtml(JSON.stringify(this.config.skins)) + ".");
  			}
  			if (!config.controlBones)
  				config.controlBones = [];
  			if (typeof config.showControls === "undefined")
  				config.showControls = true;
  			if (typeof config.defaultMix === "undefined")
  				config.defaultMix = 0.25;
  			return config;
  		};
  		SpinePlayer.prototype.showError = function (error) {
  			var errorDom = findWithClass(this.dom, "spine-player-error")[0];
  			errorDom.classList.remove("spine-player-hidden");
  			errorDom.innerHTML = "<p style=\"text-align: center; align-self: center;\">" + error + "</p>";
  			this.config.error(this, error);
  		};
  		SpinePlayer.prototype.render = function () {
  			var _this = this;
  			var config = this.config;
  			var dom = this.dom = createElement("\n\t\t\t\t<div class=\"spine-player\">\n\t\t\t\t\t<canvas class=\"spine-player-canvas\"></canvas>\n\t\t\t\t\t<div class=\"spine-player-error spine-player-hidden\"></div>\n\t\t\t\t\t<div class=\"spine-player-controls spine-player-popup-parent spine-player-controls-hidden\">\n\t\t\t\t\t\t<div class=\"spine-player-timeline\">\n\t\t\t\t\t\t</div>\n\t\t\t\t\t\t<div class=\"spine-player-buttons\">\n\t\t\t\t\t\t\t<button id=\"spine-player-button-play-pause\" class=\"spine-player-button spine-player-button-icon-pause\"></button>\n\t\t\t\t\t\t\t<div class=\"spine-player-button-spacer\"></div>\n\t\t\t\t\t\t\t<button id=\"spine-player-button-speed\" class=\"spine-player-button spine-player-button-icon-speed\"></button>\n\t\t\t\t\t\t\t<button id=\"spine-player-button-animation\" class=\"spine-player-button spine-player-button-icon-animations\"></button>\n\t\t\t\t\t\t\t<button id=\"spine-player-button-skin\" class=\"spine-player-button spine-player-button-icon-skins\"></button>\n\t\t\t\t\t\t\t<button id=\"spine-player-button-settings\" class=\"spine-player-button spine-player-button-icon-settings\"></button>\n\t\t\t\t\t\t\t<button id=\"spine-player-button-fullscreen\" class=\"spine-player-button spine-player-button-icon-fullscreen\"></button>\n\t\t\t\t\t\t\t<img id=\"spine-player-button-logo\" class=\"spine-player-button-icon-spine-logo\" src=\"data:image/svg+xml,%3Csvg%20id%3D%22Spine_Logo%22%20data-name%3D%22Spine%20Logo%22%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20viewBox%3D%220%200%20104%2031.16%22%3E%3Cdefs%3E%3Cstyle%3E.cls-1%7Bfill%3A%23fff%3B%7D.cls-2%7Bfill%3A%23ff4000%3B%7D%3C%2Fstyle%3E%3C%2Fdefs%3E%3Ctitle%3Espine-logo-white%3C%2Ftitle%3E%3Cpath%20id%3D%22e%22%20class%3D%22cls-1%22%20d%3D%22M104%2C12.68a1.31%2C1.31%2C0%2C0%2C1-.37%2C1%2C1.28%2C1.28%2C0%2C0%2C1-.85.31H91.57a10.51%2C10.51%2C0%2C0%2C0%2C.29%2C2.55%2C4.92%2C4.92%2C0%2C0%2C0%2C1%2C2A4.27%2C4.27%2C0%2C0%2C0%2C94.5%2C19.8a6.89%2C6.89%2C0%2C0%2C0%2C2.6.44%2C10.66%2C10.66%2C0%2C0%2C0%2C2.17-.2%2C12.81%2C12.81%2C0%2C0%2C0%2C1.64-.44q.69-.25%2C1.14-.44a1.87%2C1.87%2C0%2C0%2C1%2C.68-.2A.44.44%2C0%2C0%2C1%2C103%2C19a.43.43%2C0%2C0%2C1%2C.16.2%2C1.38%2C1.38%2C0%2C0%2C1%2C.09.37%2C4.89%2C4.89%2C0%2C0%2C1%2C0%2C.58%2C4.14%2C4.14%2C0%2C0%2C1%2C0%2C.43v.32a.83.83%2C0%2C0%2C1-.09.26%2C1.1%2C1.1%2C0%2C0%2C1-.17.22%2C2.77%2C2.77%2C0%2C0%2C1-.61.34%2C8.94%2C8.94%2C0%2C0%2C1-1.32.46%2C18.54%2C18.54%2C0%2C0%2C1-1.88.41%2C13.78%2C13.78%2C0%2C0%2C1-2.28.18%2C10.55%2C10.55%2C0%2C0%2C1-3.68-.59%2C6.82%2C6.82%2C0%2C0%2C1-2.66-1.74%2C7.44%2C7.44%2C0%2C0%2C1-1.63-2.89%2C13.48%2C13.48%2C0%2C0%2C1-.55-4%2C12.76%2C12.76%2C0%2C0%2C1%2C.57-3.94%2C8.35%2C8.35%2C0%2C0%2C1%2C1.64-3%2C7.15%2C7.15%2C0%2C0%2C1%2C2.58-1.87%2C8.47%2C8.47%2C0%2C0%2C1%2C3.39-.65%2C8.19%2C8.19%2C0%2C0%2C1%2C3.41.64%2C6.46%2C6.46%2C0%2C0%2C1%2C2.32%2C1.73A7%2C7%2C0%2C0%2C1%2C103.59%2C9a11.17%2C11.17%2C0%2C0%2C1%2C.43%2C3.13Zm-3.14-.93a5.69%2C5.69%2C0%2C0%2C0-1.09-3.86%2C4.17%2C4.17%2C0%2C0%2C0-3.42-1.4%2C4.52%2C4.52%2C0%2C0%2C0-2%2C.44%2C4.41%2C4.41%2C0%2C0%2C0-1.47%2C1.15A5.29%2C5.29%2C0%2C0%2C0%2C92%2C9.75a7%2C7%2C0%2C0%2C0-.36%2C2Z%22%2F%3E%3Cpath%20id%3D%22n%22%20class%3D%22cls-1%22%20d%3D%22M80.68%2C21.94a.42.42%2C0%2C0%2C1-.08.26.59.59%2C0%2C0%2C1-.25.18%2C1.74%2C1.74%2C0%2C0%2C1-.47.11%2C6.31%2C6.31%2C0%2C0%2C1-.76%2C0%2C6.5%2C6.5%2C0%2C0%2C1-.78%2C0%2C1.74%2C1.74%2C0%2C0%2C1-.47-.11.59.59%2C0%2C0%2C1-.25-.18.42.42%2C0%2C0%2C1-.08-.26V12a9.8%2C9.8%2C0%2C0%2C0-.23-2.35%2C4.86%2C4.86%2C0%2C0%2C0-.66-1.53%2C2.88%2C2.88%2C0%2C0%2C0-1.13-1%2C3.57%2C3.57%2C0%2C0%2C0-1.6-.34%2C4%2C4%2C0%2C0%2C0-2.35.83A12.71%2C12.71%2C0%2C0%2C0%2C69.11%2C10v11.9a.42.42%2C0%2C0%2C1-.08.26.59.59%2C0%2C0%2C1-.25.18%2C1.74%2C1.74%2C0%2C0%2C1-.47.11%2C6.51%2C6.51%2C0%2C0%2C1-.78%2C0%2C6.31%2C6.31%2C0%2C0%2C1-.76%2C0%2C1.88%2C1.88%2C0%2C0%2C1-.48-.11.52.52%2C0%2C0%2C1-.25-.18.46.46%2C0%2C0%2C1-.07-.26v-17A.53.53%2C0%2C0%2C1%2C66%2C4.69a.5.5%2C0%2C0%2C1%2C.23-.19%2C1.28%2C1.28%2C0%2C0%2C1%2C.44-.11%2C8.53%2C8.53%2C0%2C0%2C1%2C1.39%2C0%2C1.12%2C1.12%2C0%2C0%2C1%2C.43.11.6.6%2C0%2C0%2C1%2C.22.19.47.47%2C0%2C0%2C1%2C.07.26V7.2a10.46%2C10.46%2C0%2C0%2C1%2C2.87-2.36%2C6.17%2C6.17%2C0%2C0%2C1%2C2.88-.75%2C6.41%2C6.41%2C0%2C0%2C1%2C2.87.58%2C5.16%2C5.16%2C0%2C0%2C1%2C1.88%2C1.54%2C6.15%2C6.15%2C0%2C0%2C1%2C1%2C2.26%2C13.46%2C13.46%2C0%2C0%2C1%2C.31%2C3.11Z%22%2F%3E%3Cg%20id%3D%22i%22%3E%3Cpath%20class%3D%22cls-2%22%20d%3D%22M43.35%2C2.86c.09%2C2.6%2C1.89%2C4%2C5.48%2C4.61%2C3%2C.48%2C5.79.24%2C6.69-2.37%2C1.75-5.09-2.4-3.82-6-4.39S43.21-1.32%2C43.35%2C2.86Z%22%2F%3E%3Cpath%20class%3D%22cls-2%22%20d%3D%22M44.43%2C13.55c.33%2C1.94%2C2.14%2C3.06%2C4.91%2C3s4.84-1.16%2C5.13-3.25c.53-3.88-2.53-2.38-5.3-2.3S43.77%2C9.74%2C44.43%2C13.55Z%22%2F%3E%3Cpath%20class%3D%22cls-2%22%20d%3D%22M48%2C22.44c.55%2C1.45%2C2.06%2C2.06%2C4.1%2C1.63s3.45-1.11%2C3.33-2.76c-.21-3.06-2.22-2.1-4.26-1.66S47%2C19.6%2C48%2C22.44Z%22%2F%3E%3Cpath%20class%3D%22cls-2%22%20d%3D%22M49.78%2C29.22c.16%2C1.22%2C1.22%2C2%2C2.88%2C1.93s2.92-.67%2C3.13-2c.4-2.43-1.46-1.53-3.12-1.51S49.5%2C26.82%2C49.78%2C29.22Z%22%2F%3E%3C%2Fg%3E%3Cpath%20id%3D%22p%22%20class%3D%22cls-1%22%20d%3D%22M35.28%2C13.16a15.33%2C15.33%2C0%2C0%2C1-.48%2C4%2C8.75%2C8.75%2C0%2C0%2C1-1.42%2C3%2C6.35%2C6.35%2C0%2C0%2C1-2.32%2C1.91%2C7.14%2C7.14%2C0%2C0%2C1-3.16.67%2C6.1%2C6.1%2C0%2C0%2C1-1.4-.15%2C5.34%2C5.34%2C0%2C0%2C1-1.26-.47A7.29%2C7.29%2C0%2C0%2C1%2C24%2C21.31q-.61-.49-1.29-1.15v8.51a.47.47%2C0%2C0%2C1-.08.26.56.56%2C0%2C0%2C1-.25.19%2C1.74%2C1.74%2C0%2C0%2C1-.47.11%2C6.47%2C6.47%2C0%2C0%2C1-.78%2C0%2C6.26%2C6.26%2C0%2C0%2C1-.76%2C0%2C1.89%2C1.89%2C0%2C0%2C1-.48-.11.49.49%2C0%2C0%2C1-.25-.19.51.51%2C0%2C0%2C1-.07-.26V4.91a.57.57%2C0%2C0%2C1%2C.06-.27.46.46%2C0%2C0%2C1%2C.23-.18%2C1.47%2C1.47%2C0%2C0%2C1%2C.44-.1%2C7.41%2C7.41%2C0%2C0%2C1%2C1.3%2C0%2C1.45%2C1.45%2C0%2C0%2C1%2C.43.1.52.52%2C0%2C0%2C1%2C.24.18.51.51%2C0%2C0%2C1%2C.07.27V7.2a18.06%2C18.06%2C0%2C0%2C1%2C1.49-1.38%2C9%2C9%2C0%2C0%2C1%2C1.45-1%2C6.82%2C6.82%2C0%2C0%2C1%2C1.49-.59%2C7.09%2C7.09%2C0%2C0%2C1%2C4.78.52%2C6%2C6%2C0%2C0%2C1%2C2.13%2C2%2C8.79%2C8.79%2C0%2C0%2C1%2C1.2%2C2.9A15.72%2C15.72%2C0%2C0%2C1%2C35.28%2C13.16ZM32%2C13.52a15.64%2C15.64%2C0%2C0%2C0-.2-2.53%2C7.32%2C7.32%2C0%2C0%2C0-.69-2.17%2C4.06%2C4.06%2C0%2C0%2C0-1.3-1.51%2C3.49%2C3.49%2C0%2C0%2C0-2-.57%2C4.1%2C4.1%2C0%2C0%2C0-1.2.18%2C4.92%2C4.92%2C0%2C0%2C0-1.2.57%2C8.54%2C8.54%2C0%2C0%2C0-1.28%2C1A15.77%2C15.77%2C0%2C0%2C0%2C22.76%2C10v6.77a13.53%2C13.53%2C0%2C0%2C0%2C2.46%2C2.4%2C4.12%2C4.12%2C0%2C0%2C0%2C2.44.83%2C3.56%2C3.56%2C0%2C0%2C0%2C2-.57A4.28%2C4.28%2C0%2C0%2C0%2C31%2C18a7.58%2C7.58%2C0%2C0%2C0%2C.77-2.12A11.43%2C11.43%2C0%2C0%2C0%2C32%2C13.52Z%22%2F%3E%3Cpath%20id%3D%22s%22%20class%3D%22cls-1%22%20d%3D%22M12%2C17.3a5.39%2C5.39%2C0%2C0%2C1-.48%2C2.33%2C4.73%2C4.73%2C0%2C0%2C1-1.37%2C1.72%2C6.19%2C6.19%2C0%2C0%2C1-2.12%2C1.06%2C9.62%2C9.62%2C0%2C0%2C1-2.71.36%2C10.38%2C10.38%2C0%2C0%2C1-3.21-.5%2C7.63%2C7.63%2C0%2C0%2C1-1.11-.45%2C3.25%2C3.25%2C0%2C0%2C1-.66-.43%2C1.09%2C1.09%2C0%2C0%2C1-.3-.53A3.59%2C3.59%2C0%2C0%2C1%2C0%2C19.93a4.06%2C4.06%2C0%2C0%2C1%2C0-.61%2C2%2C2%2C0%2C0%2C1%2C.09-.4.42.42%2C0%2C0%2C1%2C.16-.22.43.43%2C0%2C0%2C1%2C.24-.07%2C1.35%2C1.35%2C0%2C0%2C1%2C.61.26q.41.26%2C1%2C.56A9.22%2C9.22%2C0%2C0%2C0%2C3.51%2C20a6.25%2C6.25%2C0%2C0%2C0%2C1.87.26%2C5.62%2C5.62%2C0%2C0%2C0%2C1.44-.17%2C3.48%2C3.48%2C0%2C0%2C0%2C1.12-.5%2C2.23%2C2.23%2C0%2C0%2C0%2C.73-.84%2C2.68%2C2.68%2C0%2C0%2C0%2C.26-1.21%2C2%2C2%2C0%2C0%2C0-.37-1.21%2C3.55%2C3.55%2C0%2C0%2C0-1-.87A8.09%2C8.09%2C0%2C0%2C0%2C6.2%2C14.8l-1.56-.61a16%2C16%2C0%2C0%2C1-1.57-.73%2C6%2C6%2C0%2C0%2C1-1.37-1%2C4.52%2C4.52%2C0%2C0%2C1-1-1.4%2C4.69%2C4.69%2C0%2C0%2C1-.37-2A4.88%2C4.88%2C0%2C0%2C1%2C.72%2C7.19%2C4.46%2C4.46%2C0%2C0%2C1%2C1.88%2C5.58%2C5.83%2C5.83%2C0%2C0%2C1%2C3.82%2C4.47%2C8.06%2C8.06%2C0%2C0%2C1%2C6.53%2C4a8.28%2C8.28%2C0%2C0%2C1%2C1.36.11%2C9.36%2C9.36%2C0%2C0%2C1%2C1.23.28%2C5.92%2C5.92%2C0%2C0%2C1%2C.94.37%2C4.09%2C4.09%2C0%2C0%2C1%2C.59.35%2C1%2C1%2C0%2C0%2C1%2C.26.26.83.83%2C0%2C0%2C1%2C.09.26%2C1.32%2C1.32%2C0%2C0%2C0%2C.06.35%2C3.87%2C3.87%2C0%2C0%2C1%2C0%2C.51%2C4.76%2C4.76%2C0%2C0%2C1%2C0%2C.56%2C1.39%2C1.39%2C0%2C0%2C1-.09.39.5.5%2C0%2C0%2C1-.16.22.35.35%2C0%2C0%2C1-.21.07%2C1%2C1%2C0%2C0%2C1-.49-.21%2C7%2C7%2C0%2C0%2C0-.83-.44%2C9.26%2C9.26%2C0%2C0%2C0-1.2-.44A5.49%2C5.49%2C0%2C0%2C0%2C6.5%2C6.48a4.93%2C4.93%2C0%2C0%2C0-1.4.18%2C2.69%2C2.69%2C0%2C0%2C0-1%2C.51A2.16%2C2.16%2C0%2C0%2C0%2C3.51%2C8a2.43%2C2.43%2C0%2C0%2C0-.2%2C1%2C2%2C2%2C0%2C0%2C0%2C.38%2C1.24%2C3.6%2C3.6%2C0%2C0%2C0%2C1%2C.88%2C8.25%2C8.25%2C0%2C0%2C0%2C1.38.68l1.58.62q.8.32%2C1.59.72a6%2C6%2C0%2C0%2C1%2C1.39%2C1%2C4.37%2C4.37%2C0%2C0%2C1%2C1%2C1.36A4.46%2C4.46%2C0%2C0%2C1%2C12%2C17.3Z%22%2F%3E%3C%2Fsvg%3E\"/>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t");
  			try {
  				this.config = this.validateConfig(config);
  			}
  			catch (e) {
  				this.showError(e);
  				return dom;
  			}
  			try {
  				this.canvas = findWithClass(dom, "spine-player-canvas")[0];
  				var webglConfig = { alpha: config.alpha };
  				this.context = new spine.webgl.ManagedWebGLRenderingContext(this.canvas, webglConfig);
  				this.sceneRenderer = new spine.webgl.SceneRenderer(this.canvas, this.context, true);
  				this.loadingScreen = new spine.webgl.LoadingScreen(this.sceneRenderer);
  			}
  			catch (e) {
  				this.showError("Sorry, your browser does not support WebGL.<br><br>Please use the latest version of Firefox, Chrome, Edge, or Safari.");
  				return dom;
  			}
  			this.assetManager = new spine.webgl.AssetManager(this.context);
  			if (config.rawDataURIs) {
  				for (var path in config.rawDataURIs) {
  					var data = config.rawDataURIs[path];
  					this.assetManager.setRawDataURI(path, data);
  				}
  			}
  			if (config.jsonUrl)
  				this.assetManager.loadText(config.jsonUrl);
  			else
  				this.assetManager.loadBinary(config.skelUrl);
  			this.assetManager.loadTextureAtlas(config.atlasUrl);
  			if (config.backgroundImage && config.backgroundImage.url)
  				this.assetManager.loadTexture(config.backgroundImage.url);
  			requestAnimationFrame(function () { return _this.drawFrame(); });
  			this.playerControls = findWithClass(dom, "spine-player-controls")[0];
  			var timeline = findWithClass(dom, "spine-player-timeline")[0];
  			this.timelineSlider = new Slider();
  			timeline.appendChild(this.timelineSlider.render());
  			this.playButton = findWithId(dom, "spine-player-button-play-pause")[0];
  			var speedButton = findWithId(dom, "spine-player-button-speed")[0];
  			this.animationButton = findWithId(dom, "spine-player-button-animation")[0];
  			this.skinButton = findWithId(dom, "spine-player-button-skin")[0];
  			var settingsButton = findWithId(dom, "spine-player-button-settings")[0];
  			var fullscreenButton = findWithId(dom, "spine-player-button-fullscreen")[0];
  			var logoButton = findWithId(dom, "spine-player-button-logo")[0];
  			this.playButton.onclick = function () {
  				if (_this.paused)
  					_this.play();
  				else
  					_this.pause();
  			};
  			speedButton.onclick = function () {
  				_this.showSpeedDialog(speedButton);
  			};
  			this.animationButton.onclick = function () {
  				_this.showAnimationsDialog(_this.animationButton);
  			};
  			this.skinButton.onclick = function () {
  				_this.showSkinsDialog(_this.skinButton);
  			};
  			settingsButton.onclick = function () {
  				_this.showSettingsDialog(settingsButton);
  			};
  			var oldWidth = this.canvas.clientWidth;
  			var oldHeight = this.canvas.clientHeight;
  			var oldStyleWidth = this.canvas.style.width;
  			var oldStyleHeight = this.canvas.style.height;
  			var isFullscreen = false;
  			fullscreenButton.onclick = function () {
  				var fullscreenChanged = function () {
  					isFullscreen = !isFullscreen;
  					if (!isFullscreen) {
  						_this.canvas.style.width = "" + oldWidth + "px";
  						_this.canvas.style.height = "" + oldHeight + "px";
  						_this.drawFrame(false);
  						requestAnimationFrame(function () {
  							_this.canvas.style.width = oldStyleWidth;
  							_this.canvas.style.height = oldStyleHeight;
  						});
  					}
  				};
  				var doc = document;
  				dom.onfullscreenchange = fullscreenChanged;
  				dom.onwebkitfullscreenchange = fullscreenChanged;
  				if (doc.fullscreenElement || doc.webkitFullscreenElement || doc.mozFullScreenElement || doc.msFullscreenElement) {
  					if (doc.exitFullscreen)
  						doc.exitFullscreen();
  					else if (doc.mozCancelFullScreen)
  						doc.mozCancelFullScreen();
  					else if (doc.webkitExitFullscreen)
  						doc.webkitExitFullscreen();
  					else if (doc.msExitFullscreen)
  						doc.msExitFullscreen();
  				}
  				else {
  					oldWidth = _this.canvas.clientWidth;
  					oldHeight = _this.canvas.clientHeight;
  					oldStyleWidth = _this.canvas.style.width;
  					oldStyleHeight = _this.canvas.style.height;
  					var player = dom;
  					if (player.requestFullscreen)
  						player.requestFullscreen();
  					else if (player.webkitRequestFullScreen)
  						player.webkitRequestFullScreen();
  					else if (player.mozRequestFullScreen)
  						player.mozRequestFullScreen();
  					else if (player.msRequestFullscreen)
  						player.msRequestFullscreen();
  				}
  			};
  			logoButton.onclick = function () {
  				window.open("http://esotericsoftware.com");
  			};
  			window.onresize = function () {
  				_this.drawFrame(false);
  			};
  			return dom;
  		};
  		SpinePlayer.prototype.showSpeedDialog = function (speedButton) {
  			var _this = this;
  			if (this.lastPopup)
  				this.lastPopup.dom.remove();
  			if (this.lastPopup && findWithClass(this.lastPopup.dom, "spine-player-popup-title")[0].textContent == "Speed") {
  				this.lastPopup = null;
  				speedButton.classList.remove("spine-player-button-icon-speed-selected");
  				return;
  			}
  			var popup = new Popup(this.dom, this.playerControls, "\n\t\t\t\t<div class=\"spine-player-popup-title\">Speed</div>\n\t\t\t\t<hr>\n\t\t\t\t<div class=\"spine-player-row\" style=\"user-select: none; align-items: center; padding: 8px;\">\n\t\t\t\t\t<div class=\"spine-player-column\">\n\t\t\t\t\t\t<div class=\"spine-player-speed-slider\" style=\"margin-bottom: 4px;\"></div>\n\t\t\t\t\t\t<div class=\"spine-player-row\" style=\"justify-content: space-between;\">\n\t\t\t\t\t\t\t<div>0.1x</div>\n\t\t\t\t\t\t\t<div>1x</div>\n\t\t\t\t\t\t\t<div>2x</div>\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t");
  			var sliderParent = findWithClass(popup.dom, "spine-player-speed-slider")[0];
  			var slider = new Slider(2, 0.1, true);
  			sliderParent.appendChild(slider.render());
  			slider.setValue(this.speed / 2);
  			slider.change = function (percentage) {
  				_this.speed = percentage * 2;
  			};
  			speedButton.classList.add("spine-player-button-icon-speed-selected");
  			popup.show(function () {
  				speedButton.classList.remove("spine-player-button-icon-speed-selected");
  				popup.dom.remove();
  				_this.lastPopup = null;
  			});
  			this.lastPopup = popup;
  		};
  		SpinePlayer.prototype.showAnimationsDialog = function (animationsButton) {
  			var _this = this;
  			if (this.lastPopup)
  				this.lastPopup.dom.remove();
  			if (this.lastPopup && findWithClass(this.lastPopup.dom, "spine-player-popup-title")[0].textContent == "Animations") {
  				this.lastPopup = null;
  				animationsButton.classList.remove("spine-player-button-icon-animations-selected");
  				return;
  			}
  			if (!this.skeleton || this.skeleton.data.animations.length == 0)
  				return;
  			var popup = new Popup(this.dom, this.playerControls, "\n\t\t\t\t<div class=\"spine-player-popup-title\">Animations</div>\n\t\t\t\t<hr>\n\t\t\t\t<ul class=\"spine-player-list\"></ul>\n\t\t\t");
  			var rows = findWithClass(popup.dom, "spine-player-list")[0];
  			this.skeleton.data.animations.forEach(function (animation) {
  				if (_this.config.animations && _this.config.animations.indexOf(animation.name) < 0) {
  					return;
  				}
  				var row = createElement("\n\t\t\t\t\t<li class=\"spine-player-list-item selectable\">\n\t\t\t\t\t\t<div class=\"selectable-circle\">\n\t\t\t\t\t\t</div>\n\t\t\t\t\t\t<div class=\"selectable-text\">\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</li>\n\t\t\t\t");
  				if (animation.name == _this.config.animation)
  					row.classList.add("selected");
  				findWithClass(row, "selectable-text")[0].innerText = animation.name;
  				rows.appendChild(row);
  				row.onclick = function () {
  					removeClass(rows.children, "selected");
  					row.classList.add("selected");
  					_this.config.animation = animation.name;
  					_this.playTime = 0;
  					_this.setAnimation(animation.name);
  				};
  			});
  			animationsButton.classList.add("spine-player-button-icon-animations-selected");
  			popup.show(function () {
  				animationsButton.classList.remove("spine-player-button-icon-animations-selected");
  				popup.dom.remove();
  				_this.lastPopup = null;
  			});
  			this.lastPopup = popup;
  		};
  		SpinePlayer.prototype.showSkinsDialog = function (skinButton) {
  			var _this = this;
  			if (this.lastPopup)
  				this.lastPopup.dom.remove();
  			if (this.lastPopup && findWithClass(this.lastPopup.dom, "spine-player-popup-title")[0].textContent == "Skins") {
  				this.lastPopup = null;
  				skinButton.classList.remove("spine-player-button-icon-skins-selected");
  				return;
  			}
  			if (!this.skeleton || this.skeleton.data.animations.length == 0)
  				return;
  			var popup = new Popup(this.dom, this.playerControls, "\n\t\t\t\t<div class=\"spine-player-popup-title\">Skins</div>\n\t\t\t\t<hr>\n\t\t\t\t<ul class=\"spine-player-list\"></ul>\n\t\t\t");
  			var rows = findWithClass(popup.dom, "spine-player-list")[0];
  			this.skeleton.data.skins.forEach(function (skin) {
  				if (_this.config.skins && _this.config.skins.indexOf(skin.name) < 0) {
  					return;
  				}
  				var row = createElement("\n\t\t\t\t\t<li class=\"spine-player-list-item selectable\">\n\t\t\t\t\t\t<div class=\"selectable-circle\">\n\t\t\t\t\t\t</div>\n\t\t\t\t\t\t<div class=\"selectable-text\">\n\t\t\t\t\t\t</div>\n\t\t\t\t\t</li>\n\t\t\t\t");
  				if (skin.name == _this.config.skin)
  					row.classList.add("selected");
  				findWithClass(row, "selectable-text")[0].innerText = skin.name;
  				rows.appendChild(row);
  				row.onclick = function () {
  					removeClass(rows.children, "selected");
  					row.classList.add("selected");
  					_this.config.skin = skin.name;
  					_this.skeleton.setSkinByName(_this.config.skin);
  					_this.skeleton.setSlotsToSetupPose();
  				};
  			});
  			skinButton.classList.add("spine-player-button-icon-skins-selected");
  			popup.show(function () {
  				skinButton.classList.remove("spine-player-button-icon-skins-selected");
  				popup.dom.remove();
  				_this.lastPopup = null;
  			});
  			this.lastPopup = popup;
  		};
  		SpinePlayer.prototype.showSettingsDialog = function (settingsButton) {
  			var _this = this;
  			if (this.lastPopup)
  				this.lastPopup.dom.remove();
  			if (this.lastPopup && findWithClass(this.lastPopup.dom, "spine-player-popup-title")[0].textContent == "Debug") {
  				this.lastPopup = null;
  				settingsButton.classList.remove("spine-player-button-icon-settings-selected");
  				return;
  			}
  			if (!this.skeleton || this.skeleton.data.animations.length == 0)
  				return;
  			var popup = new Popup(this.dom, this.playerControls, "\n\t\t\t\t<div class=\"spine-player-popup-title\">Debug</div>\n\t\t\t\t<hr>\n\t\t\t\t<ul class=\"spine-player-list\">\n\t\t\t\t</li>\n\t\t\t");
  			var rows = findWithClass(popup.dom, "spine-player-list")[0];
  			var makeItem = function (label, name) {
  				var row = createElement("<li class=\"spine-player-list-item\"></li>");
  				var s = new Switch(label);
  				row.appendChild(s.render());
  				s.setEnabled(_this.config.debug[name]);
  				s.change = function (value) {
  					_this.config.debug[name] = value;
  				};
  				rows.appendChild(row);
  			};
  			makeItem("Bones", "bones");
  			makeItem("Regions", "regions");
  			makeItem("Meshes", "meshes");
  			makeItem("Bounds", "bounds");
  			makeItem("Paths", "paths");
  			makeItem("Clipping", "clipping");
  			makeItem("Points", "points");
  			makeItem("Hulls", "hulls");
  			settingsButton.classList.add("spine-player-button-icon-settings-selected");
  			popup.show(function () {
  				settingsButton.classList.remove("spine-player-button-icon-settings-selected");
  				popup.dom.remove();
  				_this.lastPopup = null;
  			});
  			this.lastPopup = popup;
  		};
  		SpinePlayer.prototype.drawFrame = function (requestNextFrame) {
  			var _this = this;
  			if (requestNextFrame === void 0) { requestNextFrame = true; }
  			if (requestNextFrame && !this.stopRequestAnimationFrame)
  				requestAnimationFrame(function () { return _this.drawFrame(); });
  			var ctx = this.context;
  			var gl = ctx.gl;
  			var doc = document;
  			var isFullscreen = doc.fullscreenElement || doc.webkitFullscreenElement || doc.mozFullScreenElement || doc.msFullscreenElement;
  			var bg = new spine.Color().setFromString(isFullscreen ? this.config.fullScreenBackgroundColor : this.config.backgroundColor);
  			gl.clearColor(bg.r, bg.g, bg.b, bg.a);
  			gl.clear(gl.COLOR_BUFFER_BIT);
  			this.loadingScreen.backgroundColor.setFromColor(bg);
  			this.loadingScreen.draw(this.assetManager.isLoadingComplete());
  			if (this.assetManager.isLoadingComplete() && this.skeleton == null)
  				this.loadSkeleton();
  			this.sceneRenderer.resize(spine.webgl.ResizeMode.Expand);
  			if (this.loaded) {
  				if (!this.paused && this.config.animation) {
  					this.time.update();
  					var delta = this.time.delta * this.speed;
  					var animationDuration = this.animationState.getCurrent(0).animation.duration;
  					this.playTime += delta;
  					while (this.playTime >= animationDuration && animationDuration != 0) {
  						this.playTime -= animationDuration;
  					}
  					this.playTime = Math.max(0, Math.min(this.playTime, animationDuration));
  					this.timelineSlider.setValue(this.playTime / animationDuration);
  					this.animationState.update(delta);
  					this.animationState.apply(this.skeleton);
  				}
  				this.skeleton.updateWorldTransform();
  				var viewport = {
  					x: this.currentViewport.x - this.currentViewport.padLeft,
  					y: this.currentViewport.y - this.currentViewport.padBottom,
  					width: this.currentViewport.width + this.currentViewport.padLeft + this.currentViewport.padRight,
  					height: this.currentViewport.height + this.currentViewport.padBottom + this.currentViewport.padTop
  				};
  				var transitionAlpha = ((performance.now() - this.viewportTransitionStart) / 1000) / this.config.viewport.transitionTime;
  				if (this.previousViewport && transitionAlpha < 1) {
  					var oldViewport = {
  						x: this.previousViewport.x - this.previousViewport.padLeft,
  						y: this.previousViewport.y - this.previousViewport.padBottom,
  						width: this.previousViewport.width + this.previousViewport.padLeft + this.previousViewport.padRight,
  						height: this.previousViewport.height + this.previousViewport.padBottom + this.previousViewport.padTop
  					};
  					viewport = {
  						x: oldViewport.x + (viewport.x - oldViewport.x) * transitionAlpha,
  						y: oldViewport.y + (viewport.y - oldViewport.y) * transitionAlpha,
  						width: oldViewport.width + (viewport.width - oldViewport.width) * transitionAlpha,
  						height: oldViewport.height + (viewport.height - oldViewport.height) * transitionAlpha
  					};
  				}
  				var viewportSize = this.scale(viewport.width, viewport.height, this.canvas.width, this.canvas.height);
  				this.sceneRenderer.camera.zoom = viewport.width / viewportSize.x;
  				this.sceneRenderer.camera.position.x = viewport.x + viewport.width / 2;
  				this.sceneRenderer.camera.position.y = viewport.y + viewport.height / 2;
  				this.sceneRenderer.begin();
  				if (this.config.backgroundImage && this.config.backgroundImage.url) {
  					var bgImage = this.assetManager.get(this.config.backgroundImage.url);
  					if (!(this.config.backgroundImage.hasOwnProperty("x") && this.config.backgroundImage.hasOwnProperty("y") && this.config.backgroundImage.hasOwnProperty("width") && this.config.backgroundImage.hasOwnProperty("height"))) {
  						this.sceneRenderer.drawTexture(bgImage, viewport.x, viewport.y, viewport.width, viewport.height);
  					}
  					else {
  						this.sceneRenderer.drawTexture(bgImage, this.config.backgroundImage.x, this.config.backgroundImage.y, this.config.backgroundImage.width, this.config.backgroundImage.height);
  					}
  				}
  				this.sceneRenderer.drawSkeleton(this.skeleton, this.config.premultipliedAlpha);
  				this.sceneRenderer.skeletonDebugRenderer.drawBones = this.config.debug.bones;
  				this.sceneRenderer.skeletonDebugRenderer.drawBoundingBoxes = this.config.debug.bounds;
  				this.sceneRenderer.skeletonDebugRenderer.drawClipping = this.config.debug.clipping;
  				this.sceneRenderer.skeletonDebugRenderer.drawMeshHull = this.config.debug.hulls;
  				this.sceneRenderer.skeletonDebugRenderer.drawPaths = this.config.debug.paths;
  				this.sceneRenderer.skeletonDebugRenderer.drawRegionAttachments = this.config.debug.regions;
  				this.sceneRenderer.skeletonDebugRenderer.drawMeshTriangles = this.config.debug.meshes;
  				this.sceneRenderer.drawSkeletonDebug(this.skeleton, this.config.premultipliedAlpha);
  				var controlBones = this.config.controlBones;
  				var selectedBones = this.selectedBones;
  				var skeleton = this.skeleton;
  				gl.lineWidth(2);
  				for (var i = 0; i < controlBones.length; i++) {
  					var bone = skeleton.findBone(controlBones[i]);
  					if (!bone)
  						continue;
  					var colorInner = selectedBones[i] !== null ? SpinePlayer.HOVER_COLOR_INNER : SpinePlayer.NON_HOVER_COLOR_INNER;
  					var colorOuter = selectedBones[i] !== null ? SpinePlayer.HOVER_COLOR_OUTER : SpinePlayer.NON_HOVER_COLOR_OUTER;
  					this.sceneRenderer.circle(true, skeleton.x + bone.worldX, skeleton.y + bone.worldY, 20, colorInner);
  					this.sceneRenderer.circle(false, skeleton.x + bone.worldX, skeleton.y + bone.worldY, 20, colorOuter);
  				}
  				gl.lineWidth(1);
  				if (this.config.viewport.debugRender) {
  					this.sceneRenderer.rect(false, this.currentViewport.x, this.currentViewport.y, this.currentViewport.width, this.currentViewport.height, spine.Color.GREEN);
  					this.sceneRenderer.rect(false, viewport.x, viewport.y, viewport.width, viewport.height, spine.Color.RED);
  				}
  				this.sceneRenderer.end();
  				this.sceneRenderer.camera.zoom = 0;
  			}
  		};
  		SpinePlayer.prototype.scale = function (sourceWidth, sourceHeight, targetWidth, targetHeight) {
  			var targetRatio = targetHeight / targetWidth;
  			var sourceRatio = sourceHeight / sourceWidth;
  			var scale = targetRatio > sourceRatio ? targetWidth / sourceWidth : targetHeight / sourceHeight;
  			var temp = new spine.Vector2();
  			temp.x = sourceWidth * scale;
  			temp.y = sourceHeight * scale;
  			return temp;
  		};
  		SpinePlayer.prototype.loadSkeleton = function () {
  			var _this = this;
  			if (this.loaded)
  				return;
  			if (this.assetManager.hasErrors()) {
  				this.showError("Error: assets could not be loaded.<br><br>" + escapeHtml(JSON.stringify(this.assetManager.getErrors())));
  				return;
  			}
  			var atlas = this.assetManager.get(this.config.atlasUrl);
  			var skeletonData;
  			if (this.config.jsonUrl) {
  				var jsonText = this.assetManager.get(this.config.jsonUrl);
  				var json = new spine.SkeletonJson(new spine.AtlasAttachmentLoader(atlas));
  				try {
  					skeletonData = json.readSkeletonData(jsonText);
  				}
  				catch (e) {
  					this.showError("Error: could not load skeleton .json.<br><br>" + escapeHtml(JSON.stringify(e)));
  					return;
  				}
  			}
  			else {
  				var binaryData = this.assetManager.get(this.config.skelUrl);
  				var binary = new spine.SkeletonBinary(new spine.AtlasAttachmentLoader(atlas));
  				try {
  					skeletonData = binary.readSkeletonData(binaryData);
  				}
  				catch (e) {
  					this.showError("Error: could not load skeleton .skel.<br><br>" + escapeHtml(JSON.stringify(e)));
  					return;
  				}
  			}
  			this.skeleton = new spine.Skeleton(skeletonData);
  			var stateData = new spine.AnimationStateData(skeletonData);
  			stateData.defaultMix = this.config.defaultMix;
  			this.animationState = new spine.AnimationState(stateData);
  			if (this.config.controlBones) {
  				this.config.controlBones.forEach(function (bone) {
  					if (!skeletonData.findBone(bone)) {
  						_this.showError("Error: control bone '" + bone + "' does not exist in skeleton.");
  					}
  				});
  			}
  			if (!this.config.skin) {
  				if (skeletonData.skins.length > 0) {
  					this.config.skin = skeletonData.skins[0].name;
  				}
  			}
  			if (this.config.skins && this.config.skin.length > 0) {
  				this.config.skins.forEach(function (skin) {
  					if (!_this.skeleton.data.findSkin(skin)) {
  						_this.showError("Error: skin '" + skin + "' in selectable skin list does not exist in skeleton.");
  						return;
  					}
  				});
  			}
  			if (this.config.skin) {
  				if (!this.skeleton.data.findSkin(this.config.skin)) {
  					this.showError("Error: skin '" + this.config.skin + "' does not exist in skeleton.");
  					return;
  				}
  				this.skeleton.setSkinByName(this.config.skin);
  				this.skeleton.setSlotsToSetupPose();
  			}
  			if (!this.config.viewport) {
  				this.config.viewport = {
  					animations: {},
  					debugRender: false,
  					transitionTime: 0.2
  				};
  			}
  			if (typeof this.config.viewport.debugRender === "undefined")
  				this.config.viewport.debugRender = false;
  			if (typeof this.config.viewport.transitionTime === "undefined")
  				this.config.viewport.transitionTime = 0.2;
  			if (!this.config.viewport.animations) {
  				this.config.viewport.animations = {};
  			}
  			else {
  				Object.getOwnPropertyNames(this.config.viewport.animations).forEach(function (animation) {
  					if (!skeletonData.findAnimation(animation)) {
  						_this.showError("Error: animation '" + animation + "' for which a viewport was specified does not exist in skeleton.");
  						return;
  					}
  				});
  			}
  			if (this.config.animations && this.config.animations.length > 0) {
  				this.config.animations.forEach(function (animation) {
  					if (!_this.skeleton.data.findAnimation(animation)) {
  						_this.showError("Error: animation '" + animation + "' in selectable animation list does not exist in skeleton.");
  						return;
  					}
  				});
  				if (!this.config.animation) {
  					this.config.animation = this.config.animations[0];
  				}
  			}
  			if (!this.config.animation) {
  				if (skeletonData.animations.length > 0) {
  					this.config.animation = skeletonData.animations[0].name;
  				}
  			}
  			if (this.config.animation) {
  				if (!skeletonData.findAnimation(this.config.animation)) {
  					this.showError("Error: animation '" + this.config.animation + "' does not exist in skeleton.");
  					return;
  				}
  				this.play();
  				this.timelineSlider.change = function (percentage) {
  					_this.pause();
  					var animationDuration = _this.animationState.getCurrent(0).animation.duration;
  					var time = animationDuration * percentage;
  					_this.animationState.update(time - _this.playTime);
  					_this.animationState.apply(_this.skeleton);
  					_this.skeleton.updateWorldTransform();
  					_this.playTime = time;
  				};
  			}
  			this.setupInput();
  			if (skeletonData.skins.length == 1 || (this.config.skins && this.config.skins.length == 1))
  				this.skinButton.classList.add("spine-player-hidden");
  			if (skeletonData.animations.length == 1 || (this.config.animations && this.config.animations.length == 1))
  				this.animationButton.classList.add("spine-player-hidden");
  			this.config.success(this);
  			this.loaded = true;
  		};
  		SpinePlayer.prototype.setupInput = function () {
  			var _this = this;
  			var controlBones = this.config.controlBones;
  			var selectedBones = this.selectedBones = new Array(this.config.controlBones.length);
  			var canvas = this.canvas;
  			var input = new spine.webgl.Input(canvas);
  			var target = null;
  			var coords = new spine.webgl.Vector3();
  			var temp = new spine.webgl.Vector3();
  			var temp2 = new spine.Vector2();
  			var skeleton = this.skeleton;
  			var renderer = this.sceneRenderer;
  			input.addListener({
  				down: function (x, y) {
  					for (var i = 0; i < controlBones.length; i++) {
  						var bone = skeleton.findBone(controlBones[i]);
  						if (!bone)
  							continue;
  						renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);
  						if (temp.set(skeleton.x + bone.worldX, skeleton.y + bone.worldY, 0).distance(coords) < 30) {
  							target = bone;
  						}
  					}
  				},
  				up: function (x, y) {
  					if (target) {
  						target = null;
  					}
  					else {
  						if (!_this.config.showControls)
  							return;
  						if (_this.paused)
  							_this.play();
  						else
  							_this.pause();
  					}
  				},
  				dragged: function (x, y) {
  					if (target != null) {
  						renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);
  						if (target.parent !== null) {
  							target.parent.worldToLocal(temp2.set(coords.x - skeleton.x, coords.y - skeleton.y));
  							target.x = temp2.x;
  							target.y = temp2.y;
  						}
  						else {
  							target.x = coords.x - skeleton.x;
  							target.y = coords.y - skeleton.y;
  						}
  					}
  				},
  				moved: function (x, y) {
  					for (var i = 0; i < controlBones.length; i++) {
  						var bone = skeleton.findBone(controlBones[i]);
  						if (!bone)
  							continue;
  						renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);
  						if (temp.set(skeleton.x + bone.worldX, skeleton.y + bone.worldY, 0).distance(coords) < 30) {
  							selectedBones[i] = bone;
  						}
  						else {
  							selectedBones[i] = null;
  						}
  					}
  				}
  			});
  			var mouseOverControls = true;
  			var mouseOverCanvas = false;
  			document.addEventListener("mousemove", function (ev) {
  				if (ev instanceof MouseEvent) {
  					handleHover(ev.clientX, ev.clientY);
  				}
  			});
  			document.addEventListener("touchmove", function (ev) {
  				if (ev instanceof TouchEvent) {
  					var touches = ev.changedTouches;
  					if (touches.length > 0) {
  						var touch = touches[0];
  						handleHover(touch.clientX, touch.clientY);
  					}
  				}
  			});
  			var handleHover = function (mouseX, mouseY) {
  				if (!_this.config.showControls)
  					return;
  				var popup = findWithClass(_this.dom, "spine-player-popup");
  				mouseOverControls = overlap(mouseX, mouseY, _this.playerControls.getBoundingClientRect());
  				mouseOverCanvas = overlap(mouseX, mouseY, _this.canvas.getBoundingClientRect());
  				clearTimeout(_this.cancelId);
  				var hide = popup.length == 0 && !mouseOverControls && !mouseOverCanvas && !_this.paused;
  				if (hide) {
  					_this.playerControls.classList.add("spine-player-controls-hidden");
  				}
  				else {
  					_this.playerControls.classList.remove("spine-player-controls-hidden");
  				}
  				if (!mouseOverControls && popup.length == 0 && !_this.paused) {
  					var remove = function () {
  						if (!_this.paused)
  							_this.playerControls.classList.add("spine-player-controls-hidden");
  					};
  					_this.cancelId = setTimeout(remove, 1000);
  				}
  			};
  			var overlap = function (mouseX, mouseY, rect) {
  				var x = mouseX - rect.left;
  				var y = mouseY - rect.top;
  				return x >= 0 && x <= rect.width && y >= 0 && y <= rect.height;
  			};
  		};
  		SpinePlayer.prototype.play = function () {
  			var _this = this;
  			this.paused = false;
  			var remove = function () {
  				if (!_this.paused)
  					_this.playerControls.classList.add("spine-player-controls-hidden");
  			};
  			this.cancelId = setTimeout(remove, 1000);
  			this.playButton.classList.remove("spine-player-button-icon-play");
  			this.playButton.classList.add("spine-player-button-icon-pause");
  			if (this.config.animation) {
  				if (!this.animationState.getCurrent(0)) {
  					this.setAnimation(this.config.animation);
  				}
  			}
  		};
  		SpinePlayer.prototype.pause = function () {
  			this.paused = true;
  			this.playerControls.classList.remove("spine-player-controls-hidden");
  			clearTimeout(this.cancelId);
  			this.playButton.classList.remove("spine-player-button-icon-pause");
  			this.playButton.classList.add("spine-player-button-icon-play");
  		};
  		SpinePlayer.prototype.setAnimation = function (animation) {
  			this.previousViewport = this.currentViewport;
  			var animViewport = this.calculateAnimationViewport(animation);
  			var viewport = {
  				x: animViewport.x,
  				y: animViewport.y,
  				width: animViewport.width,
  				height: animViewport.height,
  				padLeft: "10%",
  				padRight: "10%",
  				padTop: "10%",
  				padBottom: "10%"
  			};
  			var globalViewport = this.config.viewport;
  			if (typeof globalViewport.x !== "undefined" && typeof globalViewport.y !== "undefined" && typeof globalViewport.width !== "undefined" && typeof globalViewport.height !== "undefined") {
  				viewport.x = globalViewport.x;
  				viewport.y = globalViewport.y;
  				viewport.width = globalViewport.width;
  				viewport.height = globalViewport.height;
  			}
  			if (typeof globalViewport.padLeft !== "undefined")
  				viewport.padLeft = globalViewport.padLeft;
  			if (typeof globalViewport.padRight !== "undefined")
  				viewport.padRight = globalViewport.padRight;
  			if (typeof globalViewport.padTop !== "undefined")
  				viewport.padTop = globalViewport.padTop;
  			if (typeof globalViewport.padBottom !== "undefined")
  				viewport.padBottom = globalViewport.padBottom;
  			var userAnimViewport = this.config.viewport.animations[animation];
  			if (userAnimViewport) {
  				if (typeof userAnimViewport.x !== "undefined" && typeof userAnimViewport.y !== "undefined" && typeof userAnimViewport.width !== "undefined" && typeof userAnimViewport.height !== "undefined") {
  					viewport.x = userAnimViewport.x;
  					viewport.y = userAnimViewport.y;
  					viewport.width = userAnimViewport.width;
  					viewport.height = userAnimViewport.height;
  				}
  				if (typeof userAnimViewport.padLeft !== "undefined")
  					viewport.padLeft = userAnimViewport.padLeft;
  				if (typeof userAnimViewport.padRight !== "undefined")
  					viewport.padRight = userAnimViewport.padRight;
  				if (typeof userAnimViewport.padTop !== "undefined")
  					viewport.padTop = userAnimViewport.padTop;
  				if (typeof userAnimViewport.padBottom !== "undefined")
  					viewport.padBottom = userAnimViewport.padBottom;
  			}
  			viewport.padLeft = this.percentageToWorldUnit(viewport.width, viewport.padLeft);
  			viewport.padRight = this.percentageToWorldUnit(viewport.width, viewport.padRight);
  			viewport.padBottom = this.percentageToWorldUnit(viewport.height, viewport.padBottom);
  			viewport.padTop = this.percentageToWorldUnit(viewport.height, viewport.padTop);
  			this.currentViewport = viewport;
  			this.viewportTransitionStart = performance.now();
  			this.animationState.clearTracks();
  			this.skeleton.setToSetupPose();
  			this.animationState.setAnimation(0, animation, true);
  		};
  		SpinePlayer.prototype.percentageToWorldUnit = function (size, percentageOrAbsolute) {
  			if (typeof percentageOrAbsolute === "string") {
  				return size * parseFloat(percentageOrAbsolute.substr(0, percentageOrAbsolute.length - 1)) / 100;
  			}
  			else {
  				return percentageOrAbsolute;
  			}
  		};
  		SpinePlayer.prototype.calculateAnimationViewport = function (animationName) {
  			var animation = this.skeleton.data.findAnimation(animationName);
  			this.animationState.clearTracks();
  			this.skeleton.setToSetupPose();
  			this.animationState.setAnimationWith(0, animation, true);
  			var steps = 100;
  			var stepTime = animation.duration > 0 ? animation.duration / steps : 0;
  			var minX = 100000000;
  			var maxX = -100000000;
  			var minY = 100000000;
  			var maxY = -100000000;
  			var offset = new spine.Vector2();
  			var size = new spine.Vector2();
  			for (var i = 0; i < steps; i++) {
  				this.animationState.update(stepTime);
  				this.animationState.apply(this.skeleton);
  				this.skeleton.updateWorldTransform();
  				this.skeleton.getBounds(offset, size);
  				minX = Math.min(offset.x, minX);
  				maxX = Math.max(offset.x + size.x, maxX);
  				minY = Math.min(offset.y, minY);
  				maxY = Math.max(offset.y + size.y, maxY);
  			}
  			offset.x = minX;
  			offset.y = minY;
  			size.x = maxX - minX;
  			size.y = maxY - minY;
  			return {
  				x: offset.x,
  				y: offset.y,
  				width: size.x,
  				height: size.y
  			};
  		};
  		SpinePlayer.prototype.stopRendering = function () {
  			this.stopRequestAnimationFrame = true;
  		};
  		SpinePlayer.HOVER_COLOR_INNER = new spine.Color(0.478, 0, 0, 0.25);
  		SpinePlayer.HOVER_COLOR_OUTER = new spine.Color(1, 1, 1, 1);
  		SpinePlayer.NON_HOVER_COLOR_INNER = new spine.Color(0.478, 0, 0, 0.5);
  		SpinePlayer.NON_HOVER_COLOR_OUTER = new spine.Color(1, 0, 0, 0.8);
  		return SpinePlayer;
  	}());
  	spine.SpinePlayer = SpinePlayer;
  	function isContained(dom, needle) {
  		if (dom === needle)
  			return true;
  		var findRecursive = function (dom, needle) {
  			for (var i = 0; i < dom.children.length; i++) {
  				var child = dom.children[i];
  				if (child === needle)
  					return true;
  				if (findRecursive(child, needle))
  					return true;
  			}
  			return false;
  		};
  		return findRecursive(dom, needle);
  	}
  	function findWithId(dom, id) {
  		var found = new Array();
  		var findRecursive = function (dom, id, found) {
  			for (var i = 0; i < dom.children.length; i++) {
  				var child = dom.children[i];
  				if (child.id === id)
  					found.push(child);
  				findRecursive(child, id, found);
  			}
  		};
  		findRecursive(dom, id, found);
  		return found;
  	}
  	function findWithClass(dom, className) {
  		var found = new Array();
  		var findRecursive = function (dom, className, found) {
  			for (var i = 0; i < dom.children.length; i++) {
  				var child = dom.children[i];
  				if (child.classList.contains(className))
  					found.push(child);
  				findRecursive(child, className, found);
  			}
  		};
  		findRecursive(dom, className, found);
  		return found;
  	}
  	function createElement(html) {
  		var dom = document.createElement("div");
  		dom.innerHTML = html;
  		return dom.children[0];
  	}
  	function removeClass(elements, clazz) {
  		for (var i = 0; i < elements.length; i++) {
  			elements[i].classList.remove(clazz);
  		}
  	}
  	function escapeHtml(str) {
  		if (!str)
  			return "";
  		return str
  			.replace(/&/g, "&amp;")
  			.replace(/</g, "&lt;")
  			.replace(/>/g, "&gt;")
  			.replace(/"/g, "&#34;")
  			.replace(/'/g, "&#39;");
  	}
  })(spine || (spine = {}));
  var spine;
  (function (spine) {
  	var SpinePlayerEditor = (function () {
  		function SpinePlayerEditor(parent) {
  			this.prefix = "<html>\n<head>\n<style>\nbody {\n\tmargin: 0px;\n}\n</style>\n</head>\n<body>".trim();
  			this.postfix = "</body>";
  			this.timerId = 0;
  			this.render(parent);
  		}
  		SpinePlayerEditor.prototype.render = function (parent) {
  			var _this = this;
  			var dom = "\n\t\t\t\t<div class=\"spine-player-editor-container\">\n\t\t\t\t\t<div class=\"spine-player-editor-code\"></div>\n\t\t\t\t\t<iframe class=\"spine-player-editor-player\"></iframe>\n\t\t\t\t</div>\n\t\t\t";
  			parent.innerHTML = dom;
  			var codeElement = parent.getElementsByClassName("spine-player-editor-code")[0];
  			this.player = parent.getElementsByClassName("spine-player-editor-player")[0];
  			requestAnimationFrame(function () {
  				_this.code = CodeMirror(codeElement, {
  					lineNumbers: true,
  					tabSize: 3,
  					indentUnit: 3,
  					indentWithTabs: true,
  					scrollBarStyle: "native",
  					mode: "htmlmixed",
  					theme: "monokai"
  				});
  				_this.code.on("change", function () {
  					_this.startPlayer();
  				});
  				_this.setCode(SpinePlayerEditor.DEFAULT_CODE);
  			});
  		};
  		SpinePlayerEditor.prototype.setPreAndPostfix = function (prefix, postfix) {
  			this.prefix = prefix;
  			this.postfix = postfix;
  			this.startPlayer();
  		};
  		SpinePlayerEditor.prototype.setCode = function (code) {
  			this.code.setValue(code);
  			this.startPlayer();
  		};
  		SpinePlayerEditor.prototype.startPlayer = function () {
  			var _this = this;
  			clearTimeout(this.timerId);
  			this.timerId = setTimeout(function () {
  				var code = _this.code.getDoc().getValue();
  				code = _this.prefix + code + _this.postfix;
  				code = window.btoa(code);
  				_this.player.src = "";
  				_this.player.src = "data:text/html;base64," + code;
  			}, 500);
  		};
  		SpinePlayerEditor.DEFAULT_CODE = "\n<script src=\"https://esotericsoftware.com/files/spine-player/3.7/spine-player.js\"></script>\n<link rel=\"stylesheet\" href=\"https://esotericsoftware.com/files/spine-player/3.7/spine-player.css\">\n\n<div id=\"player-container\" style=\"width: 100%; height: 100vh;\"></div>\n\n<script>\nnew spine.SpinePlayer(\"player-container\", {\n\tjsonUrl: \"https://esotericsoftware.com/files/examples/spineboy/export/spineboy-pro.json\",\n\tatlasUrl: \"https://esotericsoftware.com/files/examples/spineboy/export/spineboy-pma.atlas\"\n});\n</script>\n\t\t".trim();
  		return SpinePlayerEditor;
  	}());
  	spine.SpinePlayerEditor = SpinePlayerEditor;
  })(spine || (spine = {}));
  //# sourceMappingURL=spine-player.js.map