highcharts-rails 3.0.3 → 3.0.5

data/app/assets/javascripts/highcharts/adapters/standalone.js

@@ -0,0 +1,17 @@
+/*
+ Highcharts JS v3.0.5 (2013-08-23)
+
+ Standalone Highcharts Framework
+
+ License: MIT License
+*/
+var HighchartsAdapter=function(){function n(c){function a(a,b,d){a.removeEventListener(b,d,!1)}function d(a,b,d){d=a.HCProxiedMethods[d.toString()];a.detachEvent("on"+b,d)}function b(b,c){var g=b.HCEvents,i,h,l,f;if(b.removeEventListener)i=a;else if(b.attachEvent)i=d;else return;c?(h={},h[c]=!0):h=g;for(f in h)if(g[f])for(l=g[f].length;l--;)i(b,f,g[f][l])}c.HCExtended||Highcharts.extend(c,{HCExtended:!0,HCEvents:{},bind:function(b,a){var d=this,c=this.HCEvents,h;if(d.addEventListener)d.addEventListener(b,
+a,!1);else if(d.attachEvent){h=function(b){a.call(d,b)};if(!d.HCProxiedMethods)d.HCProxiedMethods={};d.HCProxiedMethods[a.toString()]=h;d.attachEvent("on"+b,h)}c[b]===q&&(c[b]=[]);c[b].push(a)},unbind:function(c,k){var g,i;c?(g=this.HCEvents[c]||[],k?(i=HighchartsAdapter.inArray(k,g),i>-1&&(g.splice(i,1),this.HCEvents[c]=g),this.removeEventListener?a(this,c,k):this.attachEvent&&d(this,c,k)):(b(this,c),this.HCEvents[c]=[])):(b(this),this.HCEvents={})},trigger:function(b,a){var d=this.HCEvents[b]||
+[],c=d.length,h,f;for(h=function(){a.defaultPrevented=!0};c--;){f=d[c];if(a.stopped)break;a.preventDefault=h;a.target=this;f.call(this,a)===!1&&a.preventDefault()}}});return c}var q,f=document,o=[],j=[],p,m;Math.easeInOutSine=function(c,a,d,b){return-d/2*(Math.cos(Math.PI*c/b)-1)+a};return{init:function(c){if(!f.defaultView)this._getStyle=function(a,d){var b;return a.style[d]?a.style[d]:(d==="opacity"&&(d="filter"),b=a.currentStyle[d.replace(/\-(\w)/g,function(a,b){return b.toUpperCase()})],d==="filter"&&
+(b=b.replace(/alpha\(opacity=([0-9]+)\)/,function(b,a){return a/100})),b===""?1:b)},this.adapterRun=function(a,d){var b={width:"clientWidth",height:"clientHeight"}[d];if(b)return a.style.zoom=1,a[b]-2*parseInt(HighchartsAdapter._getStyle(a,"padding"),10)};if(!Array.prototype.forEach)this.each=function(a,d){for(var b=0,c=a.length;b<c;b++)if(d.call(a[b],a[b],b,a)===!1)return b};if(!Array.prototype.indexOf)this.inArray=function(a,d){var b,c=0;if(d)for(b=d.length;c<b;c++)if(d[c]===a)return c;return-1};
+if(!Array.prototype.filter)this.grep=function(a,d){for(var b=[],c=0,f=a.length;c<f;c++)d(a[c],c)&&b.push(a[c]);return b};m=function(a,c,b){this.options=c;this.elem=a;this.prop=b};m.prototype={update:function(){var a;a=this.paths;var d=this.elem,b=d.element;a&&b?d.attr("d",c.step(a[0],a[1],this.now,this.toD)):d.attr?b&&d.attr(this.prop,this.now):(a={},a[d]=this.now+this.unit,Highcharts.css(d,a));this.options.step&&this.options.step.call(this.elem,this.now,this)},custom:function(a,c,b){var e=this,f=
+function(a){return e.step(a)},g;this.startTime=+new Date;this.start=a;this.end=c;this.unit=b;this.now=this.start;this.pos=this.state=0;f.elem=this.elem;f()&&j.push(f)===1&&(p=setInterval(function(){for(g=0;g<j.length;g++)j[g]()||j.splice(g--,1);j.length||clearInterval(p)},13))},step:function(a){var c=+new Date,b;b=this.options;var e;if(this.elem.stopAnimation)b=!1;else if(a||c>=b.duration+this.startTime){this.now=this.end;this.pos=this.state=1;this.update();a=this.options.curAnim[this.prop]=!0;for(e in b.curAnim)b.curAnim[e]!==
+!0&&(a=!1);a&&b.complete&&b.complete.call(this.elem);b=!1}else e=c-this.startTime,this.state=e/b.duration,this.pos=b.easing(e,0,1,b.duration),this.now=this.start+(this.end-this.start)*this.pos,this.update(),b=!0;return b}};this.animate=function(a,d,b){var e,f="",g,i,h;a.stopAnimation=!1;if(typeof b!=="object"||b===null)e=arguments,b={duration:e[2],easing:e[3],complete:e[4]};if(typeof b.duration!=="number")b.duration=400;b.easing=Math[b.easing]||Math.easeInOutSine;b.curAnim=Highcharts.extend({},d);
+for(h in d)i=new m(a,b,h),g=null,h==="d"?(i.paths=c.init(a,a.d,d.d),i.toD=d.d,e=0,g=1):a.attr?e=a.attr(h):(e=parseFloat(this._getStyle(a,h))||0,h!=="opacity"&&(f="px")),g||(g=parseFloat(d[h])),i.custom(e,g,f)}},_getStyle:function(c,a){return window.getComputedStyle(c).getPropertyValue(a)},getScript:function(c,a){var d=f.getElementsByTagName("head")[0],b=f.createElement("script");b.type="text/javascript";b.src=c;b.onload=a;d.appendChild(b)},inArray:function(c,a){return a.indexOf?a.indexOf(c):o.indexOf.call(a,
+c)},adapterRun:function(c,a){return parseInt(HighchartsAdapter._getStyle(c,a),10)},grep:function(c,a){return o.filter.call(c,a)},map:function(c,a){for(var d=[],b=0,e=c.length;b<e;b++)d[b]=a.call(c[b],c[b],b,c);return d},offset:function(c){for(var a=0,d=0;c;)a+=c.offsetLeft,d+=c.offsetTop,c=c.offsetParent;return{left:a,top:d}},addEvent:function(c,a,d){n(c).bind(a,d)},removeEvent:function(c,a,d){n(c).unbind(a,d)},fireEvent:function(c,a,d,b){var e;f.createEvent&&(c.dispatchEvent||c.fireEvent)?(e=f.createEvent("Events"),
+e.initEvent(a,!0,!0),e.target=c,Highcharts.extend(e,d),c.dispatchEvent?c.dispatchEvent(e):c.fireEvent(a,e)):c.HCExtended===!0&&(d=d||{},c.trigger(a,d));d&&d.defaultPrevented&&(b=null);b&&b(d)},washMouseEvent:function(c){return c},stop:function(c){c.stopAnimation=!0},each:function(c,a){return Array.prototype.forEach.call(c,a)}}}();

data/app/assets/javascripts/highcharts/highcharts-more.js

@@ -1,2426 +1,50 @@
-// ==ClosureCompiler==
-// @compilation_level SIMPLE_OPTIMIZATIONS
-
-/**
- * @license Highcharts JS v3.0.3 (2013-07-31)
- *
- * (c) 2009-2013 Torstein Hønsi
- *
- * License: www.highcharts.com/license
- */
-
-// JSLint options:
-/*global Highcharts, HighchartsAdapter, document, window, navigator, setInterval, clearInterval, clearTimeout, setTimeout, location, jQuery, $, console */
-
-(function (Highcharts, UNDEFINED) {
-var arrayMin = Highcharts.arrayMin,
-	arrayMax = Highcharts.arrayMax,
-	each = Highcharts.each,
-	extend = Highcharts.extend,
-	merge = Highcharts.merge,
-	map = Highcharts.map,
-	pick = Highcharts.pick,
-	pInt = Highcharts.pInt,
-	defaultPlotOptions = Highcharts.getOptions().plotOptions,
-	seriesTypes = Highcharts.seriesTypes,
-	extendClass = Highcharts.extendClass,
-	splat = Highcharts.splat,
-	wrap = Highcharts.wrap,
-	Axis = Highcharts.Axis,
-	Tick = Highcharts.Tick,
-	Series = Highcharts.Series,
-	colProto = seriesTypes.column.prototype,
-	math = Math,
-	mathRound = math.round,
-	mathFloor = math.floor,
-	mathMax = math.max,
-	noop = function () {};/**
- * The Pane object allows options that are common to a set of X and Y axes.
- * 
- * In the future, this can be extended to basic Highcharts and Highstock.
- */
-function Pane(options, chart, firstAxis) {
-	this.init.call(this, options, chart, firstAxis);
-}
-
-// Extend the Pane prototype
-extend(Pane.prototype, {
-	
-	/**
-	 * Initiate the Pane object
-	 */
-	init: function (options, chart, firstAxis) {
-		var pane = this,
-			backgroundOption,
-			defaultOptions = pane.defaultOptions;
-		
-		pane.chart = chart;
-		
-		// Set options
-		if (chart.angular) { // gauges
-			defaultOptions.background = {}; // gets extended by this.defaultBackgroundOptions
-		}
-		pane.options = options = merge(defaultOptions, options);
-		
-		backgroundOption = options.background;
-		
-		// To avoid having weighty logic to place, update and remove the backgrounds,
-		// push them to the first axis' plot bands and borrow the existing logic there.
-		if (backgroundOption) {
-			each([].concat(splat(backgroundOption)).reverse(), function (config) {
-				var backgroundColor = config.backgroundColor; // if defined, replace the old one (specific for gradients)
-				config = merge(pane.defaultBackgroundOptions, config);
-				if (backgroundColor) {
-					config.backgroundColor = backgroundColor;
-				}
-				config.color = config.backgroundColor; // due to naming in plotBands
-				firstAxis.options.plotBands.unshift(config);
-			});
-		}
-	},
-	
-	/**
-	 * The default options object
-	 */
-	defaultOptions: {
-		// background: {conditional},
-		center: ['50%', '50%'],
-		size: '85%',
-		startAngle: 0
-		//endAngle: startAngle + 360
-	},	
-	
-	/**
-	 * The default background options
-	 */
-	defaultBackgroundOptions: {
-		shape: 'circle',
-		borderWidth: 1,
-		borderColor: 'silver',
-		backgroundColor: {
-			linearGradient: { x1: 0, y1: 0, x2: 0, y2: 1 },
-			stops: [
-				[0, '#FFF'],
-				[1, '#DDD']
-			]
-		},
-		from: Number.MIN_VALUE, // corrected to axis min
-		innerRadius: 0,
-		to: Number.MAX_VALUE, // corrected to axis max
-		outerRadius: '105%'
-	}
-	
-});
-var axisProto = Axis.prototype,
-	tickProto = Tick.prototype;
-	
-/**
- * Augmented methods for the x axis in order to hide it completely, used for the X axis in gauges
- */
-var hiddenAxisMixin = {
-	getOffset: noop,
-	redraw: function () {
-		this.isDirty = false; // prevent setting Y axis dirty
-	},
-	render: function () {
-		this.isDirty = false; // prevent setting Y axis dirty
-	},
-	setScale: noop,
-	setCategories: noop,
-	setTitle: noop
-};
-
-/**
- * Augmented methods for the value axis
- */
-/*jslint unparam: true*/
-var radialAxisMixin = {
-	isRadial: true,
-	
-	/**
-	 * The default options extend defaultYAxisOptions
-	 */
-	defaultRadialGaugeOptions: {
-		labels: {
-			align: 'center',
-			x: 0,
-			y: null // auto
-		},
-		minorGridLineWidth: 0,
-		minorTickInterval: 'auto',
-		minorTickLength: 10,
-		minorTickPosition: 'inside',
-		minorTickWidth: 1,
-		plotBands: [],
-		tickLength: 10,
-		tickPosition: 'inside',
-		tickWidth: 2,
-		title: {
-			rotation: 0
-		},
-		zIndex: 2 // behind dials, points in the series group
-	},
-	
-	// Circular axis around the perimeter of a polar chart
-	defaultRadialXOptions: {
-		gridLineWidth: 1, // spokes
-		labels: {
-			align: null, // auto
-			distance: 15,
-			x: 0,
-			y: null // auto
-		},
-		maxPadding: 0,
-		minPadding: 0,
-		plotBands: [],
-		showLastLabel: false, 
-		tickLength: 0
-	},
-	
-	// Radial axis, like a spoke in a polar chart
-	defaultRadialYOptions: {
-		gridLineInterpolation: 'circle',
-		labels: {
-			align: 'right',
-			x: -3,
-			y: -2
-		},
-		plotBands: [],
-		showLastLabel: false,
-		title: {
-			x: 4,
-			text: null,
-			rotation: 90
-		}
-	},
-	
-	/**
-	 * Merge and set options
-	 */
-	setOptions: function (userOptions) {
-		
-		this.options = merge(
-			this.defaultOptions,
-			this.defaultRadialOptions,
-			userOptions
-		);
-		
-	},
-	
-	/**
-	 * Wrap the getOffset method to return zero offset for title or labels in a radial 
-	 * axis
-	 */
-	getOffset: function () {
-		// Call the Axis prototype method (the method we're in now is on the instance)
-		axisProto.getOffset.call(this);
-		
-		// Title or label offsets are not counted
-		this.chart.axisOffset[this.side] = 0;
-		
-		// Set the center array
-		this.center = this.pane.center = seriesTypes.pie.prototype.getCenter.call(this.pane);
-	},
-
-
-	/**
-	 * Get the path for the axis line. This method is also referenced in the getPlotLinePath
-	 * method.
-	 */
-	getLinePath: function (lineWidth, radius) {
-		var center = this.center;
-		radius = pick(radius, center[2] / 2 - this.offset);
-		
-		return this.chart.renderer.symbols.arc(
-			this.left + center[0],
-			this.top + center[1],
-			radius,
-			radius, 
-			{
-				start: this.startAngleRad,
-				end: this.endAngleRad,
-				open: true,
-				innerR: 0
-			}
-		);
-	},
-
-	/**
-	 * Override setAxisTranslation by setting the translation to the difference
-	 * in rotation. This allows the translate method to return angle for 
-	 * any given value.
-	 */
-	setAxisTranslation: function () {
-		
-		// Call uber method		
-		axisProto.setAxisTranslation.call(this);
-			
-		// Set transA and minPixelPadding
-		if (this.center) { // it's not defined the first time
-			if (this.isCircular) {
-				
-				this.transA = (this.endAngleRad - this.startAngleRad) / 
-					((this.max - this.min) || 1);
-					
-				
-			} else { 
-				this.transA = (this.center[2] / 2) / ((this.max - this.min) || 1);
-			}
-			
-			if (this.isXAxis) {
-				this.minPixelPadding = this.transA * this.minPointOffset +
-					(this.reversed ? (this.endAngleRad - this.startAngleRad) / 4 : 0); // ???
-			}
-		}
-	},
-	
-	/**
-	 * In case of auto connect, add one closestPointRange to the max value right before
-	 * tickPositions are computed, so that ticks will extend passed the real max.
-	 */
-	beforeSetTickPositions: function () {
-		if (this.autoConnect) {
-			this.max += (this.categories && 1) || this.pointRange || this.closestPointRange; // #1197
-		}
-	},
-	
-	/**
-	 * Override the setAxisSize method to use the arc's circumference as length. This
-	 * allows tickPixelInterval to apply to pixel lengths along the perimeter
-	 */
-	setAxisSize: function () {
-		
-		axisProto.setAxisSize.call(this);
-		
-		if (this.center) { // it's not defined the first time
-			this.len = this.width = this.height = this.isCircular ?
-				this.center[2] * (this.endAngleRad - this.startAngleRad) / 2 :
-				this.center[2] / 2;
-		}
-	},
-	
-	/**
-	 * Returns the x, y coordinate of a point given by a value and a pixel distance
-	 * from center
-	 */
-	getPosition: function (value, length) {
-		if (!this.isCircular) {
-			length = this.translate(value);
-			value = this.min;	
-		}
-		
-		return this.postTranslate(
-			this.translate(value),
-			pick(length, this.center[2] / 2) - this.offset
-		);		
-	},
-	
-	/**
-	 * Translate from intermediate plotX (angle), plotY (axis.len - radius) to final chart coordinates. 
-	 */
-	postTranslate: function (angle, radius) {
-		
-		var chart = this.chart,
-			center = this.center;
-			
-		angle = this.startAngleRad + angle;
-		
-		return {
-			x: chart.plotLeft + center[0] + Math.cos(angle) * radius,
-			y: chart.plotTop + center[1] + Math.sin(angle) * radius
-		}; 
-		
-	},
-	
-	/**
-	 * Find the path for plot bands along the radial axis
-	 */
-	getPlotBandPath: function (from, to, options) {
-		var center = this.center,
-			startAngleRad = this.startAngleRad,
-			fullRadius = center[2] / 2,
-			radii = [
-				pick(options.outerRadius, '100%'),
-				options.innerRadius,
-				pick(options.thickness, 10)
-			],
-			percentRegex = /%$/,
-			start,
-			end,
-			open,
-			isCircular = this.isCircular, // X axis in a polar chart
-			ret;
-			
-		// Polygonal plot bands
-		if (this.options.gridLineInterpolation === 'polygon') {
-			ret = this.getPlotLinePath(from).concat(this.getPlotLinePath(to, true));
-		
-		// Circular grid bands
-		} else {
-			
-			// Plot bands on Y axis (radial axis) - inner and outer radius depend on to and from
-			if (!isCircular) {
-				radii[0] = this.translate(from);
-				radii[1] = this.translate(to);
-			}
-			
-			// Convert percentages to pixel values
-			radii = map(radii, function (radius) {
-				if (percentRegex.test(radius)) {
-					radius = (pInt(radius, 10) * fullRadius) / 100;
-				}
-				return radius;
-			});
-			
-			// Handle full circle
-			if (options.shape === 'circle' || !isCircular) {
-				start = -Math.PI / 2;
-				end = Math.PI * 1.5;
-				open = true;
-			} else {
-				start = startAngleRad + this.translate(from);
-				end = startAngleRad + this.translate(to);
-			}
-		
-		
-			ret = this.chart.renderer.symbols.arc(
-				this.left + center[0],
-				this.top + center[1],
-				radii[0],
-				radii[0],
-				{
-					start: start,
-					end: end,
-					innerR: pick(radii[1], radii[0] - radii[2]),
-					open: open
-				}
-			);
-		}
-		 
-		return ret;
-	},
-	
-	/**
-	 * Find the path for plot lines perpendicular to the radial axis.
-	 */
-	getPlotLinePath: function (value, reverse) {
-		var axis = this,
-			center = axis.center,
-			chart = axis.chart,
-			end = axis.getPosition(value),
-			xAxis,
-			xy,
-			tickPositions,
-			ret;
-		
-		// Spokes
-		if (axis.isCircular) {
-			ret = ['M', center[0] + chart.plotLeft, center[1] + chart.plotTop, 'L', end.x, end.y];
-		
-		// Concentric circles			
-		} else if (axis.options.gridLineInterpolation === 'circle') {
-			value = axis.translate(value);
-			if (value) { // a value of 0 is in the center
-				ret = axis.getLinePath(0, value);
-			}
-		// Concentric polygons 
-		} else {
-			xAxis = chart.xAxis[0];
-			ret = [];
-			value = axis.translate(value);
-			tickPositions = xAxis.tickPositions;
-			if (xAxis.autoConnect) {
-				tickPositions = tickPositions.concat([tickPositions[0]]);
-			}
-			// Reverse the positions for concatenation of polygonal plot bands
-			if (reverse) {
-				tickPositions = [].concat(tickPositions).reverse();
-			}
-				
-			each(tickPositions, function (pos, i) {
-				xy = xAxis.getPosition(pos, value);
-				ret.push(i ? 'L' : 'M', xy.x, xy.y);
-			});
-			
-		}
-		return ret;
-	},
-	
-	/**
-	 * Find the position for the axis title, by default inside the gauge
-	 */
-	getTitlePosition: function () {
-		var center = this.center,
-			chart = this.chart,
-			titleOptions = this.options.title;
-		
-		return { 
-			x: chart.plotLeft + center[0] + (titleOptions.x || 0), 
-			y: chart.plotTop + center[1] - ({ high: 0.5, middle: 0.25, low: 0 }[titleOptions.align] * 
-				center[2]) + (titleOptions.y || 0)  
-		};
-	}
-	
-};
-/*jslint unparam: false*/
-
-/**
- * Override axisProto.init to mix in special axis instance functions and function overrides
- */
-wrap(axisProto, 'init', function (proceed, chart, userOptions) {
-	var axis = this,
-		angular = chart.angular,
-		polar = chart.polar,
-		isX = userOptions.isX,
-		isHidden = angular && isX,
-		isCircular,
-		startAngleRad,
-		endAngleRad,
-		options,
-		chartOptions = chart.options,
-		paneIndex = userOptions.pane || 0,
-		pane,
-		paneOptions;
-		
-	// Before prototype.init
-	if (angular) {
-		extend(this, isHidden ? hiddenAxisMixin : radialAxisMixin);
-		isCircular =  !isX;
-		if (isCircular) {
-			this.defaultRadialOptions = this.defaultRadialGaugeOptions;
-		}
-		
-	} else if (polar) {
-		//extend(this, userOptions.isX ? radialAxisMixin : radialAxisMixin);
-		extend(this, radialAxisMixin);
-		isCircular = isX;
-		this.defaultRadialOptions = isX ? this.defaultRadialXOptions : merge(this.defaultYAxisOptions, this.defaultRadialYOptions);
-		
-	}
-	
-	// Run prototype.init
-	proceed.call(this, chart, userOptions);
-	
-	if (!isHidden && (angular || polar)) {
-		options = this.options;
-		
-		// Create the pane and set the pane options.
-		if (!chart.panes) {
-			chart.panes = [];
-		}
-		this.pane = pane = chart.panes[paneIndex] = chart.panes[paneIndex] || new Pane(
-			splat(chartOptions.pane)[paneIndex],
-			chart,
-			axis
-		);
-		paneOptions = pane.options;
-		
-			
-		// Disable certain features on angular and polar axes
-		chart.inverted = false;
-		chartOptions.chart.zoomType = null;
-		
-		// Start and end angle options are
-		// given in degrees relative to top, while internal computations are
-		// in radians relative to right (like SVG).
-		this.startAngleRad = startAngleRad = (paneOptions.startAngle - 90) * Math.PI / 180;
-		this.endAngleRad = endAngleRad = (pick(paneOptions.endAngle, paneOptions.startAngle + 360)  - 90) * Math.PI / 180;
-		this.offset = options.offset || 0;
-		
-		this.isCircular = isCircular;
-		
-		// Automatically connect grid lines?
-		if (isCircular && userOptions.max === UNDEFINED && endAngleRad - startAngleRad === 2 * Math.PI) {
-			this.autoConnect = true;
-		}
-	}
-	
-});
-
-/**
- * Add special cases within the Tick class' methods for radial axes.
- */	
-wrap(tickProto, 'getPosition', function (proceed, horiz, pos, tickmarkOffset, old) {
-	var axis = this.axis;
-	
-	return axis.getPosition ? 
-		axis.getPosition(pos) :
-		proceed.call(this, horiz, pos, tickmarkOffset, old);	
-});
-
-/**
- * Wrap the getLabelPosition function to find the center position of the label
- * based on the distance option
- */	
-wrap(tickProto, 'getLabelPosition', function (proceed, x, y, label, horiz, labelOptions, tickmarkOffset, index, step) {
-	var axis = this.axis,
-		optionsY = labelOptions.y,
-		ret,
-		align = labelOptions.align,
-		angle = ((axis.translate(this.pos) + axis.startAngleRad + Math.PI / 2) / Math.PI * 180) % 360;
-	
-	if (axis.isRadial) {
-		ret = axis.getPosition(this.pos, (axis.center[2] / 2) + pick(labelOptions.distance, -25));
-		
-		// Automatically rotated
-		if (labelOptions.rotation === 'auto') {
-			label.attr({ 
-				rotation: angle
-			});
-		
-		// Vertically centered
-		} else if (optionsY === null) {
-			optionsY = pInt(label.styles.lineHeight) * 0.9 - label.getBBox().height / 2;
-		
-		}
-		
-		// Automatic alignment
-		if (align === null) {
-			if (axis.isCircular) {
-				if (angle > 20 && angle < 160) {
-					align = 'left'; // right hemisphere
-				} else if (angle > 200 && angle < 340) {
-					align = 'right'; // left hemisphere
-				} else {
-					align = 'center'; // top or bottom
-				}
-			} else {
-				align = 'center';
-			}
-			label.attr({
-				align: align
-			});
-		}
-		
-		ret.x += labelOptions.x;
-		ret.y += optionsY;
-		
-	} else {
-		ret = proceed.call(this, x, y, label, horiz, labelOptions, tickmarkOffset, index, step);
-	}
-	return ret;
-});
-
-/**
- * Wrap the getMarkPath function to return the path of the radial marker
- */
-wrap(tickProto, 'getMarkPath', function (proceed, x, y, tickLength, tickWidth, horiz, renderer) {
-	var axis = this.axis,
-		endPoint,
-		ret;
-		
-	if (axis.isRadial) {
-		endPoint = axis.getPosition(this.pos, axis.center[2] / 2 + tickLength);
-		ret = [
-			'M',
-			x,
-			y,
-			'L',
-			endPoint.x,
-			endPoint.y
-		];
-	} else {
-		ret = proceed.call(this, x, y, tickLength, tickWidth, horiz, renderer);
-	}
-	return ret;
-});/* 
- * The AreaRangeSeries class
- * 
- */
-
-/**
- * Extend the default options with map options
- */
-defaultPlotOptions.arearange = merge(defaultPlotOptions.area, {
-	lineWidth: 1,
-	marker: null,
-	threshold: null,
-	tooltip: {
-		pointFormat: '<span style="color:{series.color}">{series.name}</span>: <b>{point.low}</b> - <b>{point.high}</b><br/>' 
-	},
-	trackByArea: true,
-	dataLabels: {
-		verticalAlign: null,
-		xLow: 0,
-		xHigh: 0,
-		yLow: 0,
-		yHigh: 0	
-	}
-});
-
-/**
- * Add the series type
- */
-seriesTypes.arearange = Highcharts.extendClass(seriesTypes.area, {
-	type: 'arearange',
-	pointArrayMap: ['low', 'high'],
-	toYData: function (point) {
-		return [point.low, point.high];
-	},
-	pointValKey: 'low',
-	
-	/**
-	 * Extend getSegments to force null points if the higher value is null. #1703.
-	 */
-	getSegments: function () {
-		var series = this;
-
-		each(series.points, function (point) {
-			if (!series.options.connectNulls && (point.low === null || point.high === null)) {
-				point.y = null;
-			} else if (point.low === null && point.high !== null) {
-				point.y = point.high;
-			}
-		});
-		Series.prototype.getSegments.call(this);
-	},
-	
-	/**
-	 * Translate data points from raw values x and y to plotX and plotY
-	 */
-	translate: function () {
-		var series = this,
-			yAxis = series.yAxis;
-
-		seriesTypes.area.prototype.translate.apply(series);
-
-		// Set plotLow and plotHigh
-		each(series.points, function (point) {
-
-			var low = point.low,
-				high = point.high,
-				plotY = point.plotY;
-
-			if (high === null && low === null) {
-				point.y = null;
-			} else if (low === null) {
-				point.plotLow = point.plotY = null;
-				point.plotHigh = yAxis.translate(high, 0, 1, 0, 1);
-			} else if (high === null) {
-				point.plotLow = plotY;
-				point.plotHigh = null;
-			} else {
-				point.plotLow = plotY;
-				point.plotHigh = yAxis.translate(high, 0, 1, 0, 1);
-			}
-		});
-	},
-	
-	/**
-	 * Extend the line series' getSegmentPath method by applying the segment
-	 * path to both lower and higher values of the range
-	 */
-	getSegmentPath: function (segment) {
-		
-		var lowSegment,
-			highSegment = [],
-			i = segment.length,
-			baseGetSegmentPath = Series.prototype.getSegmentPath,
-			point,
-			linePath,
-			lowerPath,
-			options = this.options,
-			step = options.step,
-			higherPath;
-			
-		// Remove nulls from low segment
-		lowSegment = HighchartsAdapter.grep(segment, function (point) {
-			return point.plotLow !== null;
-		});
-		
-		// Make a segment with plotX and plotY for the top values
-		while (i--) {
-			point = segment[i];
-			if (point.plotHigh !== null) {
-				highSegment.push({
-					plotX: point.plotX,
-					plotY: point.plotHigh
-				});
-			}
-		}
-		
-		// Get the paths
-		lowerPath = baseGetSegmentPath.call(this, lowSegment);
-		if (step) {
-			if (step === true) {
-				step = 'left';
-			}
-			options.step = { left: 'right', center: 'center', right: 'left' }[step]; // swap for reading in getSegmentPath
-		}
-		higherPath = baseGetSegmentPath.call(this, highSegment);
-		options.step = step;
-		
-		// Create a line on both top and bottom of the range
-		linePath = [].concat(lowerPath, higherPath);
-		
-		// For the area path, we need to change the 'move' statement into 'lineTo' or 'curveTo'
-		higherPath[0] = 'L'; // this probably doesn't work for spline			
-		this.areaPath = this.areaPath.concat(lowerPath, higherPath);
-		
-		return linePath;
-	},
-	
-	/**
-	 * Extend the basic drawDataLabels method by running it for both lower and higher
-	 * values.
-	 */
-	drawDataLabels: function () {
-		
-		var data = this.data,
-			length = data.length,
-			i,
-			originalDataLabels = [],
-			seriesProto = Series.prototype,
-			dataLabelOptions = this.options.dataLabels,
-			point,
-			inverted = this.chart.inverted;
-			
-		if (dataLabelOptions.enabled || this._hasPointLabels) {
-			
-			// Step 1: set preliminary values for plotY and dataLabel and draw the upper labels
-			i = length;
-			while (i--) {
-				point = data[i];
-				
-				// Set preliminary values
-				point.y = point.high;
-				point.plotY = point.plotHigh;
-				
-				// Store original data labels and set preliminary label objects to be picked up 
-				// in the uber method
-				originalDataLabels[i] = point.dataLabel;
-				point.dataLabel = point.dataLabelUpper;
-				
-				// Set the default offset
-				point.below = false;
-				if (inverted) {
-					dataLabelOptions.align = 'left';
-					dataLabelOptions.x = dataLabelOptions.xHigh;								
-				} else {
-					dataLabelOptions.y = dataLabelOptions.yHigh;
-				}
-			}
-			seriesProto.drawDataLabels.apply(this, arguments); // #1209
-			
-			// Step 2: reorganize and handle data labels for the lower values
-			i = length;
-			while (i--) {
-				point = data[i];
-				
-				// Move the generated labels from step 1, and reassign the original data labels
-				point.dataLabelUpper = point.dataLabel;
-				point.dataLabel = originalDataLabels[i];
-				
-				// Reset values
-				point.y = point.low;
-				point.plotY = point.plotLow;
-				
-				// Set the default offset
-				point.below = true;
-				if (inverted) {
-					dataLabelOptions.align = 'right';
-					dataLabelOptions.x = dataLabelOptions.xLow;
-				} else {
-					dataLabelOptions.y = dataLabelOptions.yLow;
-				}
-			}
-			seriesProto.drawDataLabels.apply(this, arguments);
-		}
-	
-	},
-	
-	alignDataLabel: seriesTypes.column.prototype.alignDataLabel,
-	
-	getSymbol: seriesTypes.column.prototype.getSymbol,
-	
-	drawPoints: noop
-});/**
- * The AreaSplineRangeSeries class
- */
-
-defaultPlotOptions.areasplinerange = merge(defaultPlotOptions.arearange);
-
-/**
- * AreaSplineRangeSeries object
- */
-seriesTypes.areasplinerange = extendClass(seriesTypes.arearange, {
-	type: 'areasplinerange',
-	getPointSpline: seriesTypes.spline.prototype.getPointSpline
-});/**
- * The ColumnRangeSeries class
- */
-defaultPlotOptions.columnrange = merge(defaultPlotOptions.column, defaultPlotOptions.arearange, {
-	lineWidth: 1,
-	pointRange: null
-});
-
-/**
- * ColumnRangeSeries object
- */
-seriesTypes.columnrange = extendClass(seriesTypes.arearange, {
-	type: 'columnrange',
-	/**
-	 * Translate data points from raw values x and y to plotX and plotY
-	 */
-	translate: function () {
-		var series = this,
-			yAxis = series.yAxis,
-			plotHigh;
-
-		colProto.translate.apply(series);
-
-		// Set plotLow and plotHigh
-		each(series.points, function (point) {
-			var shapeArgs = point.shapeArgs,
-				minPointLength = series.options.minPointLength,
-				heightDifference,
-				height,
-				y;
-
-			point.plotHigh = plotHigh = yAxis.translate(point.high, 0, 1, 0, 1);
-			point.plotLow = point.plotY;
-
-			// adjust shape
-			y = plotHigh;
-			height = point.plotY - plotHigh;
-
-			if (height < minPointLength) {
-				heightDifference = (minPointLength - height);
-				height += heightDifference;
-				y -= heightDifference / 2;
-			}
-			shapeArgs.height = height;
-			shapeArgs.y = y;
-		});
-	},
-	trackerGroups: ['group', 'dataLabels'],
-	drawGraph: noop,
-	pointAttrToOptions: colProto.pointAttrToOptions,
-	drawPoints: colProto.drawPoints,
-	drawTracker: colProto.drawTracker,
-	animate: colProto.animate,
-	getColumnMetrics: colProto.getColumnMetrics
-});
-/* 
- * The GaugeSeries class
- */
-
-
-
-/**
- * Extend the default options
- */
-defaultPlotOptions.gauge = merge(defaultPlotOptions.line, {
-	dataLabels: {
-		enabled: true,
-		y: 15,
-		borderWidth: 1,
-		borderColor: 'silver',
-		borderRadius: 3,
-		style: {
-			fontWeight: 'bold'
-		},
-		verticalAlign: 'top',
-		zIndex: 2
-	},
-	dial: {
-		// radius: '80%',
-		// backgroundColor: 'black',
-		// borderColor: 'silver',
-		// borderWidth: 0,
-		// baseWidth: 3,
-		// topWidth: 1,
-		// baseLength: '70%' // of radius
-		// rearLength: '10%'
-	},
-	pivot: {
-		//radius: 5,
-		//borderWidth: 0
-		//borderColor: 'silver',
-		//backgroundColor: 'black'
-	},
-	tooltip: {
-		headerFormat: ''
-	},
-	showInLegend: false
-});
-
-/**
- * Extend the point object
- */
-var GaugePoint = Highcharts.extendClass(Highcharts.Point, {
-	/**
-	 * Don't do any hover colors or anything
-	 */
-	setState: function (state) {
-		this.state = state;
-	}
-});
-
-
-/**
- * Add the series type
- */
-var GaugeSeries = {
-	type: 'gauge',
-	pointClass: GaugePoint,
-	
-	// chart.angular will be set to true when a gauge series is present, and this will
-	// be used on the axes
-	angular: true, 
-	drawGraph: noop,
-	trackerGroups: ['group', 'dataLabels'],
-	
-	/**
-	 * Calculate paths etc
-	 */
-	translate: function () {
-		
-		var series = this,
-			yAxis = series.yAxis,
-			options = series.options,
-			center = yAxis.center;
-			
-		series.generatePoints();
-		
-		each(series.points, function (point) {
-			
-			var dialOptions = merge(options.dial, point.dial),
-				radius = (pInt(pick(dialOptions.radius, 80)) * center[2]) / 200,
-				baseLength = (pInt(pick(dialOptions.baseLength, 70)) * radius) / 100,
-				rearLength = (pInt(pick(dialOptions.rearLength, 10)) * radius) / 100,
-				baseWidth = dialOptions.baseWidth || 3,
-				topWidth = dialOptions.topWidth || 1,
-				rotation = yAxis.startAngleRad + yAxis.translate(point.y, null, null, null, true);
-
-			// Handle the wrap option
-			if (options.wrap === false) {
-				rotation = Math.max(yAxis.startAngleRad, Math.min(yAxis.endAngleRad, rotation));
-			}
-			rotation = rotation * 180 / Math.PI;
-				
-			point.shapeType = 'path';
-			point.shapeArgs = {
-				d: dialOptions.path || [
-					'M', 
-					-rearLength, -baseWidth / 2, 
-					'L', 
-					baseLength, -baseWidth / 2,
-					radius, -topWidth / 2,
-					radius, topWidth / 2,
-					baseLength, baseWidth / 2,
-					-rearLength, baseWidth / 2,
-					'z'
-				],
-				translateX: center[0],
-				translateY: center[1],
-				rotation: rotation
-			};
-			
-			// Positions for data label
-			point.plotX = center[0];
-			point.plotY = center[1];
-		});
-	},
-	
-	/**
-	 * Draw the points where each point is one needle
-	 */
-	drawPoints: function () {
-		
-		var series = this,
-			center = series.yAxis.center,
-			pivot = series.pivot,
-			options = series.options,
-			pivotOptions = options.pivot,
-			renderer = series.chart.renderer;
-		
-		each(series.points, function (point) {
-			
-			var graphic = point.graphic,
-				shapeArgs = point.shapeArgs,
-				d = shapeArgs.d,
-				dialOptions = merge(options.dial, point.dial); // #1233
-			
-			if (graphic) {
-				graphic.animate(shapeArgs);
-				shapeArgs.d = d; // animate alters it
-			} else {
-				point.graphic = renderer[point.shapeType](shapeArgs)
-					.attr({
-						stroke: dialOptions.borderColor || 'none',
-						'stroke-width': dialOptions.borderWidth || 0,
-						fill: dialOptions.backgroundColor || 'black',
-						rotation: shapeArgs.rotation // required by VML when animation is false
-					})
-					.add(series.group);
-			}
-		});
-		
-		// Add or move the pivot
-		if (pivot) {
-			pivot.animate({ // #1235
-				translateX: center[0],
-				translateY: center[1]
-			});
-		} else {
-			series.pivot = renderer.circle(0, 0, pick(pivotOptions.radius, 5))
-				.attr({
-					'stroke-width': pivotOptions.borderWidth || 0,
-					stroke: pivotOptions.borderColor || 'silver',
-					fill: pivotOptions.backgroundColor || 'black'
-				})
-				.translate(center[0], center[1])
-				.add(series.group);
-		}
-	},
-	
-	/**
-	 * Animate the arrow up from startAngle
-	 */
-	animate: function (init) {
-		var series = this;
-
-		if (!init) {
-			each(series.points, function (point) {
-				var graphic = point.graphic;
-
-				if (graphic) {
-					// start value
-					graphic.attr({
-						rotation: series.yAxis.startAngleRad * 180 / Math.PI
-					});
-
-					// animate
-					graphic.animate({
-						rotation: point.shapeArgs.rotation
-					}, series.options.animation);
-				}
-			});
-
-			// delete this function to allow it only once
-			series.animate = null;
-		}
-	},
-	
-	render: function () {
-		this.group = this.plotGroup(
-			'group', 
-			'series', 
-			this.visible ? 'visible' : 'hidden', 
-			this.options.zIndex, 
-			this.chart.seriesGroup
-		);
-		seriesTypes.pie.prototype.render.call(this);
-		this.group.clip(this.chart.clipRect);
-	},
-	
-	setData: seriesTypes.pie.prototype.setData,
-	drawTracker: seriesTypes.column.prototype.drawTracker
-};
-seriesTypes.gauge = Highcharts.extendClass(seriesTypes.line, GaugeSeries);/* ****************************************************************************
- * Start Box plot series code											      *
- *****************************************************************************/
-
-// Set default options
-defaultPlotOptions.boxplot = merge(defaultPlotOptions.column, {
-	fillColor: '#FFFFFF',
-	lineWidth: 1,
-	//medianColor: null,
-	medianWidth: 2,
-	states: {
-		hover: {
-			brightness: -0.3
-		}
-	},
-	//stemColor: null,
-	//stemDashStyle: 'solid'
-	//stemWidth: null,
-	threshold: null,
-	tooltip: {
-		pointFormat: '<span style="color:{series.color};font-weight:bold">{series.name}</span><br/>' +
-			'Maximum: {point.high}<br/>' +
-			'Upper quartile: {point.q3}<br/>' +
-			'Median: {point.median}<br/>' +
-			'Lower quartile: {point.q1}<br/>' +
-			'Minimum: {point.low}<br/>'
-			
-	},
-	//whiskerColor: null,
-	whiskerLength: '50%',
-	whiskerWidth: 2
-});
-
-// Create the series object
-seriesTypes.boxplot = extendClass(seriesTypes.column, {
-	type: 'boxplot',
-	pointArrayMap: ['low', 'q1', 'median', 'q3', 'high'], // array point configs are mapped to this
-	toYData: function (point) { // return a plain array for speedy calculation
-		return [point.low, point.q1, point.median, point.q3, point.high];
-	},
-	pointValKey: 'high', // defines the top of the tracker
-	
-	/**
-	 * One-to-one mapping from options to SVG attributes
-	 */
-	pointAttrToOptions: { // mapping between SVG attributes and the corresponding options
-		fill: 'fillColor',
-		stroke: 'color',
-		'stroke-width': 'lineWidth'
-	},
-	
-	/**
-	 * Disable data labels for box plot
-	 */
-	drawDataLabels: noop,
-
-	/**
-	 * Translate data points from raw values x and y to plotX and plotY
-	 */
-	translate: function () {
-		var series = this,
-			yAxis = series.yAxis,
-			pointArrayMap = series.pointArrayMap;
-
-		seriesTypes.column.prototype.translate.apply(series);
-
-		// do the translation on each point dimension
-		each(series.points, function (point) {
-			each(pointArrayMap, function (key) {
-				if (point[key] !== null) {
-					point[key + 'Plot'] = yAxis.translate(point[key], 0, 1, 0, 1);
-				}
-			});
-		});
-	},
-
-	/**
-	 * Draw the data points
-	 */
-	drawPoints: function () {
-		var series = this,  //state = series.state,
-			points = series.points,
-			options = series.options,
-			chart = series.chart,
-			renderer = chart.renderer,
-			pointAttr,
-			q1Plot,
-			q3Plot,
-			highPlot,
-			lowPlot,
-			medianPlot,
-			crispCorr,
-			crispX,
-			graphic,
-			stemPath,
-			stemAttr,
-			boxPath,
-			whiskersPath,
-			whiskersAttr,
-			medianPath,
-			medianAttr,
-			width,
-			left,
-			right,
-			halfWidth,
-			shapeArgs,
-			color,
-			doQuartiles = series.doQuartiles !== false, // error bar inherits this series type but doesn't do quartiles
-			whiskerLength = parseInt(series.options.whiskerLength, 10) / 100;
-
-
-		each(points, function (point) {
-
-			graphic = point.graphic;
-			shapeArgs = point.shapeArgs; // the box
-			stemAttr = {};
-			whiskersAttr = {};
-			medianAttr = {};
-			color = point.color || series.color;
-			
-			if (point.plotY !== UNDEFINED) {
-
-				pointAttr = point.pointAttr[point.selected ? 'selected' : ''];
-
-				// crisp vector coordinates
-				width = shapeArgs.width;
-				left = mathFloor(shapeArgs.x);
-				right = left + width;
-				halfWidth = mathRound(width / 2);
-				//crispX = mathRound(left + halfWidth) + crispCorr;
-				q1Plot = mathFloor(doQuartiles ? point.q1Plot : point.lowPlot);// + crispCorr;
-				q3Plot = mathFloor(doQuartiles ? point.q3Plot : point.lowPlot);// + crispCorr;
-				highPlot = mathFloor(point.highPlot);// + crispCorr;
-				lowPlot = mathFloor(point.lowPlot);// + crispCorr;
-				
-				// Stem attributes
-				stemAttr.stroke = point.stemColor || options.stemColor || color;
-				stemAttr['stroke-width'] = pick(point.stemWidth, options.stemWidth, options.lineWidth);
-				stemAttr.dashstyle = point.stemDashStyle || options.stemDashStyle;
-				
-				// Whiskers attributes
-				whiskersAttr.stroke = point.whiskerColor || options.whiskerColor || color;
-				whiskersAttr['stroke-width'] = pick(point.whiskerWidth, options.whiskerWidth, options.lineWidth);
-				
-				// Median attributes
-				medianAttr.stroke = point.medianColor || options.medianColor || color;
-				medianAttr['stroke-width'] = pick(point.medianWidth, options.medianWidth, options.lineWidth);
-				
-				
-				// The stem
-				crispCorr = (stemAttr['stroke-width'] % 2) / 2;
-				crispX = left + halfWidth + crispCorr;				
-				stemPath = [
-					// stem up
-					'M',
-					crispX, q3Plot,
-					'L',
-					crispX, highPlot,
-					
-					// stem down
-					'M',
-					crispX, q1Plot,
-					'L',
-					crispX, lowPlot,
-					'z'
-				];
-				
-				// The box
-				if (doQuartiles) {
-					crispCorr = (pointAttr['stroke-width'] % 2) / 2;
-					crispX = mathFloor(crispX) + crispCorr;
-					q1Plot = mathFloor(q1Plot) + crispCorr;
-					q3Plot = mathFloor(q3Plot) + crispCorr;
-					left += crispCorr;
-					right += crispCorr;
-					boxPath = [
-						'M',
-						left, q3Plot,
-						'L',
-						left, q1Plot,
-						'L',
-						right, q1Plot,
-						'L',
-						right, q3Plot,
-						'L',
-						left, q3Plot,
-						'z'
-					];
-				}
-				
-				// The whiskers
-				if (whiskerLength) {
-					crispCorr = (whiskersAttr['stroke-width'] % 2) / 2;
-					highPlot = highPlot + crispCorr;
-					lowPlot = lowPlot + crispCorr;
-					whiskersPath = [
-						// High whisker
-						'M',
-						crispX - halfWidth * whiskerLength, 
-						highPlot,
-						'L',
-						crispX + halfWidth * whiskerLength, 
-						highPlot,
-						
-						// Low whisker
-						'M',
-						crispX - halfWidth * whiskerLength, 
-						lowPlot,
-						'L',
-						crispX + halfWidth * whiskerLength, 
-						lowPlot
-					];
-				}
-				
-				// The median
-				crispCorr = (medianAttr['stroke-width'] % 2) / 2;				
-				medianPlot = mathRound(point.medianPlot) + crispCorr;
-				medianPath = [
-					'M',
-					left, 
-					medianPlot,
-					'L',
-					right, 
-					medianPlot,
-					'z'
-				];
-				
-				// Create or update the graphics
-				if (graphic) { // update
-					
-					point.stem.animate({ d: stemPath });
-					if (whiskerLength) {
-						point.whiskers.animate({ d: whiskersPath });
-					}
-					if (doQuartiles) {
-						point.box.animate({ d: boxPath });
-					}
-					point.medianShape.animate({ d: medianPath });
-					
-				} else { // create new
-					point.graphic = graphic = renderer.g()
-						.add(series.group);
-					
-					point.stem = renderer.path(stemPath)
-						.attr(stemAttr)
-						.add(graphic);
-						
-					if (whiskerLength) {
-						point.whiskers = renderer.path(whiskersPath) 
-							.attr(whiskersAttr)
-							.add(graphic);
-					}
-					if (doQuartiles) {
-						point.box = renderer.path(boxPath)
-							.attr(pointAttr)
-							.add(graphic);
-					}	
-					point.medianShape = renderer.path(medianPath)
-						.attr(medianAttr)
-						.add(graphic);
-				}
-			}
-		});
-
-	}
-
-
-});
-
-/* ****************************************************************************
- * End Box plot series code												*
- *****************************************************************************/
-/* ****************************************************************************
- * Start error bar series code                                                *
- *****************************************************************************/
-
-// 1 - set default options
-defaultPlotOptions.errorbar = merge(defaultPlotOptions.boxplot, {
-	color: '#000000',
-	grouping: false,
-	linkedTo: ':previous',
-	tooltip: {
-		pointFormat: defaultPlotOptions.arearange.tooltip.pointFormat
-	},
-	whiskerWidth: null
-});
-
-// 2 - Create the series object
-seriesTypes.errorbar = extendClass(seriesTypes.boxplot, {
-	type: 'errorbar',
-	pointArrayMap: ['low', 'high'], // array point configs are mapped to this
-	toYData: function (point) { // return a plain array for speedy calculation
-		return [point.low, point.high];
-	},
-	pointValKey: 'high', // defines the top of the tracker
-	doQuartiles: false,
-
-	/**
-	 * Get the width and X offset, either on top of the linked series column
-	 * or standalone
-	 */
-	getColumnMetrics: function () {
-		return (this.linkedParent && this.linkedParent.columnMetrics) || 
-			seriesTypes.column.prototype.getColumnMetrics.call(this);
-	}
-});
-
-/* ****************************************************************************
- * End error bar series code                                                  *
- *****************************************************************************/
-/* ****************************************************************************
- * Start Waterfall series code                                                *
- *****************************************************************************/
-
-// 1 - set default options
-defaultPlotOptions.waterfall = merge(defaultPlotOptions.column, {
-	lineWidth: 1,
-	lineColor: '#333',
-	dashStyle: 'dot',
-	borderColor: '#333'
-});
-
-
-// 2 - Create the series object
-seriesTypes.waterfall = extendClass(seriesTypes.column, {
-	type: 'waterfall',
-
-	upColorProp: 'fill',
-
-	pointArrayMap: ['low', 'y'],
-
-	pointValKey: 'y',
-
-	/**
-	 * Init waterfall series, force stacking
-	 */
-	init: function (chart, options) {
-		// force stacking
-		options.stacking = true;
-
-		seriesTypes.column.prototype.init.call(this, chart, options);
-	},
-
-
-	/**
-	 * Translate data points from raw values
-	 */
-	translate: function () {
-		var series = this,
-			options = series.options,
-			axis = series.yAxis,
-			len,
-			i,
-			points,
-			point,
-			shapeArgs,
-			stack,
-			y,
-			previousY,
-			stackPoint,
-			threshold = options.threshold,
-			crispCorr = (options.borderWidth % 2) / 2;
-
-		// run column series translate
-		seriesTypes.column.prototype.translate.apply(this);
-
-		previousY = threshold;
-		points = series.points;
-
-		for (i = 0, len = points.length; i < len; i++) {
-			// cache current point object
-			point = points[i];
-			shapeArgs = point.shapeArgs;
-
-			// get current stack
-			stack = series.getStack(i);
-			stackPoint = stack.points[series.index];
-
-			// override point value for sums
-			if (isNaN(point.y)) {
-				point.y = series.yData[i];
-			}
-
-			// up points
-			y = mathMax(previousY, previousY + point.y) + stackPoint[0];
-			shapeArgs.y = axis.translate(y, 0, 1);
-
-
-			// sum points
-			if (point.isSum || point.isIntermediateSum) {
-				shapeArgs.y = axis.translate(stackPoint[1], 0, 1);
-				shapeArgs.height = axis.translate(stackPoint[0], 0, 1) - shapeArgs.y;
-
-			// if it's not the sum point, update previous stack end position
-			} else {
-				previousY += stack.total;
-			}
-
-			// negative points
-			if (shapeArgs.height < 0) {
-				shapeArgs.y += shapeArgs.height;
-				shapeArgs.height *= -1;
-			}
-
-			point.plotY = shapeArgs.y = mathRound(shapeArgs.y) - crispCorr;
-			shapeArgs.height = mathRound(shapeArgs.height);
-			point.yBottom = shapeArgs.y + shapeArgs.height;
-		}
-	},
-
-	/**
-	 * Call default processData then override yData to reflect waterfall's extremes on yAxis
-	 */
-	processData: function (force) {
-		var series = this,
-			options = series.options,
-			yData = series.yData,
-			points = series.points,
-			point,
-			dataLength = yData.length,
-			threshold = options.threshold || 0,
-			subSum,
-			sum,
-			dataMin,
-			dataMax,
-			y,
-			i;
-
-		sum = subSum = dataMin = dataMax = threshold;
-
-		for (i = 0; i < dataLength; i++) {
-			y = yData[i];
-			point = points ? points[i] : {};
-
-			if (y === "sum" || point.isSum) {
-				yData[i] = sum;
-			} else if (y === "intermediateSum" || point.isIntermediateSum) {
-				yData[i] = subSum;
-				subSum = threshold;
-			} else {
-				sum += y;
-				subSum += y;
-			}
-			dataMin = Math.min(sum, dataMin);
-			dataMax = Math.max(sum, dataMax);
-		}
-
-		Series.prototype.processData.call(this, force);
-
-		// Record extremes
-		series.dataMin = dataMin;
-		series.dataMax = dataMax;
-	},
-
-	/**
-	 * Return y value or string if point is sum
-	 */
-	toYData: function (pt) {
-		if (pt.isSum) {
-			return "sum";
-		} else if (pt.isIntermediateSum) {
-			return "intermediateSum";
-		}
-
-		return pt.y;
-	},
-
-	/**
-	 * Postprocess mapping between options and SVG attributes
-	 */
-	getAttribs: function () {
-		seriesTypes.column.prototype.getAttribs.apply(this, arguments);
-
-		var series = this,
-			options = series.options,
-			stateOptions = options.states,
-			upColor = options.upColor || series.color,
-			hoverColor = Highcharts.Color(upColor).brighten(0.1).get(),
-			seriesDownPointAttr = merge(series.pointAttr),
-			upColorProp = series.upColorProp;
-
-		seriesDownPointAttr[''][upColorProp] = upColor;
-		seriesDownPointAttr.hover[upColorProp] = stateOptions.hover.upColor || hoverColor;
-		seriesDownPointAttr.select[upColorProp] = stateOptions.select.upColor || upColor;
-
-		each(series.points, function (point) {
-			if (point.y > 0 && !point.color) {
-				point.pointAttr = seriesDownPointAttr;
-				point.color = upColor;
-			}
-		});
-	},
-
-	/**
-	 * Draw columns' connector lines
-	 */
-	getGraphPath: function () {
-
-		var data = this.data,
-			length = data.length,
-			lineWidth = this.options.lineWidth + this.options.borderWidth,
-			normalizer = mathRound(lineWidth) % 2 / 2,
-			path = [],
-			M = 'M',
-			L = 'L',
-			prevArgs,
-			pointArgs,
-			i,
-			d;
-
-		for (i = 1; i < length; i++) {
-			pointArgs = data[i].shapeArgs;
-			prevArgs = data[i - 1].shapeArgs;
-
-			d = [
-				M,
-				prevArgs.x + prevArgs.width, prevArgs.y + normalizer,
-				L,
-				pointArgs.x, prevArgs.y + normalizer
-			];
-
-			if (data[i - 1].y < 0) {
-				d[2] += prevArgs.height;
-				d[5] += prevArgs.height;
-			}
-
-			path = path.concat(d);
-		}
-
-		return path;
-	},
-
-	/**
-	 * Extremes are recorded in processData
-	 */
-	getExtremes: noop,
-
-	/**
-	 * Return stack for given index
-	 */
-	getStack: function (i) {
-		var axis = this.yAxis,
-			stacks = axis.stacks,
-			key = this.stackKey;
-
-		if (this.processedYData[i] < this.options.threshold) {
-			key = '-' + key;
-		}
-
-		return stacks[key][i];
-	},
-
-	drawGraph: Series.prototype.drawGraph
-});
-
-/* ****************************************************************************
- * End Waterfall series code                                                  *
- *****************************************************************************/
-/* ****************************************************************************
- * Start Bubble series code											          *
- *****************************************************************************/
-
-// 1 - set default options
-defaultPlotOptions.bubble = merge(defaultPlotOptions.scatter, {
-	dataLabels: {
-		inside: true,
-		style: {
-			color: 'white',
-			textShadow: '0px 0px 3px black'
-		},
-		verticalAlign: 'middle'
-	},
-	// displayNegative: true,
-	marker: {
-		// fillOpacity: 0.5,
-		lineColor: null, // inherit from series.color
-		lineWidth: 1
-	},
-	minSize: 8,
-	maxSize: '20%',
-	// negativeColor: null,
-	tooltip: {
-		pointFormat: '({point.x}, {point.y}), Size: {point.z}'
-	},
-	turboThreshold: 0, // docs: exclude from bubbles
-	zThreshold: 0
-});
-
-// 2 - Create the series object
-seriesTypes.bubble = extendClass(seriesTypes.scatter, {
-	type: 'bubble',
-	pointArrayMap: ['y', 'z'],
-	trackerGroups: ['group', 'dataLabelsGroup'],
-	
-	/**
-	 * Mapping between SVG attributes and the corresponding options
-	 */
-	pointAttrToOptions: { 
-		stroke: 'lineColor',
-		'stroke-width': 'lineWidth',
-		fill: 'fillColor'
-	},
-	
-	/**
-	 * Apply the fillOpacity to all fill positions
-	 */
-	applyOpacity: function (fill) {
-		var markerOptions = this.options.marker,
-			fillOpacity = pick(markerOptions.fillOpacity, 0.5);
-		
-		// When called from Legend.colorizeItem, the fill isn't predefined
-		fill = fill || markerOptions.fillColor || this.color; 
-		
-		if (fillOpacity !== 1) {
-			fill = Highcharts.Color(fill).setOpacity(fillOpacity).get('rgba');
-		}
-		return fill;
-	},
-	
-	/**
-	 * Extend the convertAttribs method by applying opacity to the fill
-	 */
-	convertAttribs: function () {
-		var obj = Series.prototype.convertAttribs.apply(this, arguments);
-		
-		obj.fill = this.applyOpacity(obj.fill);
-		
-		return obj;
-	},
-
-	/**
-	 * Get the radius for each point based on the minSize, maxSize and each point's Z value. This
-	 * must be done prior to Series.translate because the axis needs to add padding in 
-	 * accordance with the point sizes.
-	 */
-	getRadii: function (zMin, zMax, minSize, maxSize) {
-		var len,
-			i,
-			pos,
-			zData = this.zData,
-			radii = [],
-			zRange;
-		
-		// Set the shape type and arguments to be picked up in drawPoints
-		for (i = 0, len = zData.length; i < len; i++) {
-			zRange = zMax - zMin;
-			pos = zRange > 0 ? // relative size, a number between 0 and 1
-				(zData[i] - zMin) / (zMax - zMin) : 
-				0.5;
-			radii.push(math.ceil(minSize + pos * (maxSize - minSize)) / 2);
-		}
-		this.radii = radii;
-	},
-	
-	/**
-	 * Perform animation on the bubbles
-	 */
-	animate: function (init) {
-		var animation = this.options.animation;
-		
-		if (!init) { // run the animation
-			each(this.points, function (point) {
-				var graphic = point.graphic,
-					shapeArgs = point.shapeArgs;
-
-				if (graphic && shapeArgs) {
-					// start values
-					graphic.attr('r', 1);
-
-					// animate
-					graphic.animate({
-						r: shapeArgs.r
-					}, animation);
-				}
-			});
-
-			// delete this function to allow it only once
-			this.animate = null;
-		}
-	},
-	
-	/**
-	 * Extend the base translate method to handle bubble size
-	 */
-	translate: function () {
-		
-		var i,
-			data = this.data,
-			point,
-			radius,
-			radii = this.radii;
-		
-		// Run the parent method
-		seriesTypes.scatter.prototype.translate.call(this);
-		
-		// Set the shape type and arguments to be picked up in drawPoints
-		i = data.length;
-		
-		while (i--) {
-			point = data[i];
-			radius = radii ? radii[i] : 0; // #1737
-
-			// Flag for negativeColor to be applied in Series.js
-			point.negative = point.z < (this.options.zThreshold || 0);
-			
-			if (radius >= this.minPxSize / 2) {
-				// Shape arguments
-				point.shapeType = 'circle';
-				point.shapeArgs = {
-					x: point.plotX,
-					y: point.plotY,
-					r: radius
-				};
-				
-				// Alignment box for the data label
-				point.dlBox = {
-					x: point.plotX - radius,
-					y: point.plotY - radius,
-					width: 2 * radius,
-					height: 2 * radius
-				};
-			} else { // below zThreshold
-				point.shapeArgs = point.plotY = point.dlBox = UNDEFINED; // #1691
-			}
-		}
-	},
-	
-	/**
-	 * Get the series' symbol in the legend
-	 * 
-	 * @param {Object} legend The legend object
-	 * @param {Object} item The series (this) or point
-	 */
-	drawLegendSymbol: function (legend, item) {
-		var radius = pInt(legend.itemStyle.fontSize) / 2;
-		
-		item.legendSymbol = this.chart.renderer.circle(
-			radius,
-			legend.baseline - radius,
-			radius
-		).attr({
-			zIndex: 3
-		}).add(item.legendGroup);
-		item.legendSymbol.isMarker = true;	
-		
-	},
-	
-	drawPoints: seriesTypes.column.prototype.drawPoints,
-	alignDataLabel: seriesTypes.column.prototype.alignDataLabel
-});
-
-/**
- * Add logic to pad each axis with the amount of pixels
- * necessary to avoid the bubbles to overflow.
- */
-Axis.prototype.beforePadding = function () {
-	var axis = this,
-		axisLength = this.len,
-		chart = this.chart,
-		pxMin = 0, 
-		pxMax = axisLength,
-		isXAxis = this.isXAxis,
-		dataKey = isXAxis ? 'xData' : 'yData',
-		min = this.min,
-		extremes = {},
-		smallestSize = math.min(chart.plotWidth, chart.plotHeight),
-		zMin = Number.MAX_VALUE,
-		zMax = -Number.MAX_VALUE,
-		range = this.max - min,
-		transA = axisLength / range,
-		activeSeries = [];
-
-	// Handle padding on the second pass, or on redraw
-	if (this.tickPositions) {
-		each(this.series, function (series) {
-
-			var seriesOptions = series.options,
-				zData;
-
-			if (series.type === 'bubble' && series.visible) {
-
-				// Correction for #1673
-				axis.allowZoomOutside = true;
-
-				// Cache it
-				activeSeries.push(series);
-
-				if (isXAxis) { // because X axis is evaluated first
-				
-					// For each series, translate the size extremes to pixel values
-					each(['minSize', 'maxSize'], function (prop) {
-						var length = seriesOptions[prop],
-							isPercent = /%$/.test(length);
-						
-						length = pInt(length);
-						extremes[prop] = isPercent ?
-							smallestSize * length / 100 :
-							length;
-						
-					});
-					series.minPxSize = extremes.minSize;
-					
-					// Find the min and max Z
-					zData = series.zData;
-					if (zData.length) { // #1735
-						zMin = math.min(
-							zMin,
-							math.max(
-								arrayMin(zData), 
-								seriesOptions.displayNegative === false ? seriesOptions.zThreshold : -Number.MAX_VALUE
-							)
-						);
-						zMax = math.max(zMax, arrayMax(zData));
-					}
-				}
-			}
-		});
-
-		each(activeSeries, function (series) {
-
-			var data = series[dataKey],
-				i = data.length,
-				radius;
-
-			if (isXAxis) {
-				series.getRadii(zMin, zMax, extremes.minSize, extremes.maxSize);
-			}
-			
-			if (range > 0) {
-				while (i--) {
-					radius = series.radii[i];
-					pxMin = Math.min(((data[i] - min) * transA) - radius, pxMin);
-					pxMax = Math.max(((data[i] - min) * transA) + radius, pxMax);
-				}
-			}
-		});
-		
-		if (range > 0 && pick(this.options.min, this.userMin) === UNDEFINED && pick(this.options.max, this.userMax) === UNDEFINED) {
-			pxMax -= axisLength;
-			transA *= (axisLength + pxMin - pxMax) / axisLength;
-			this.min += pxMin / transA;
-			this.max += pxMax / transA;
-		}
-	}
-};
-
-/* ****************************************************************************
- * End Bubble series code                                                     *
- *****************************************************************************/
-/**
- * Extensions for polar charts. Additionally, much of the geometry required for polar charts is
- * gathered in RadialAxes.js.
- * 
- */
-
-var seriesProto = Series.prototype,
-	pointerProto = Highcharts.Pointer.prototype;
-
-
-
-/**
- * Translate a point's plotX and plotY from the internal angle and radius measures to 
- * true plotX, plotY coordinates
- */
-seriesProto.toXY = function (point) {
-	var xy,
-		chart = this.chart,
-		plotX = point.plotX,
-		plotY = point.plotY;
-	
-	// Save rectangular plotX, plotY for later computation
-	point.rectPlotX = plotX;
-	point.rectPlotY = plotY;
-	
-	// Record the angle in degrees for use in tooltip
-	point.clientX = ((plotX / Math.PI * 180) + this.xAxis.pane.options.startAngle) % 360;
-	
-	// Find the polar plotX and plotY
-	xy = this.xAxis.postTranslate(point.plotX, this.yAxis.len - plotY);
-	point.plotX = point.polarPlotX = xy.x - chart.plotLeft;
-	point.plotY = point.polarPlotY = xy.y - chart.plotTop;
-};
-
-/** 
- * Order the tooltip points to get the mouse capture ranges correct. #1915. 
- */
-seriesProto.orderTooltipPoints = function (points) {
-	if (this.chart.polar) {
-		points.sort(function (a, b) {
-			return a.clientX - b.clientX;
-		});
-
-		// Wrap mouse tracking around to capture movement on the segment to the left
-		// of the north point (#1469).
-		points[0].wrappedClientX = points[0].clientX + 360;
-		points.push(points[0]);
-	}
-};
-
-
-/**
- * Add some special init logic to areas and areasplines
- */
-function initArea(proceed, chart, options) {
-	proceed.call(this, chart, options);
-	if (this.chart.polar) {
-		
-		/**
-		 * Overridden method to close a segment path. While in a cartesian plane the area 
-		 * goes down to the threshold, in the polar chart it goes to the center.
-		 */
-		this.closeSegment = function (path) {
-			var center = this.xAxis.center;
-			path.push(
-				'L',
-				center[0],
-				center[1]
-			);			
-		};
-		
-		// Instead of complicated logic to draw an area around the inner area in a stack,
-		// just draw it behind
-		this.closedStacks = true;
-	}
-}
-wrap(seriesTypes.area.prototype, 'init', initArea);
-wrap(seriesTypes.areaspline.prototype, 'init', initArea);
-		
-
-/**
- * Overridden method for calculating a spline from one point to the next
- */
-wrap(seriesTypes.spline.prototype, 'getPointSpline', function (proceed, segment, point, i) {
-	
-	var ret,
-		smoothing = 1.5, // 1 means control points midway between points, 2 means 1/3 from the point, 3 is 1/4 etc;
-		denom = smoothing + 1,
-		plotX, 
-		plotY,
-		lastPoint,
-		nextPoint,
-		lastX,
-		lastY,
-		nextX,
-		nextY,
-		leftContX,
-		leftContY,
-		rightContX,
-		rightContY,
-		distanceLeftControlPoint,
-		distanceRightControlPoint,
-		leftContAngle,
-		rightContAngle,
-		jointAngle;
-		
-		
-	if (this.chart.polar) {
-		
-		plotX = point.plotX;
-		plotY = point.plotY;
-		lastPoint = segment[i - 1];
-		nextPoint = segment[i + 1];
-			
-		// Connect ends
-		if (this.connectEnds) {
-			if (!lastPoint) {
-				lastPoint = segment[segment.length - 2]; // not the last but the second last, because the segment is already connected
-			}
-			if (!nextPoint) {
-				nextPoint = segment[1];
-			}	
-		}
-
-		// find control points
-		if (lastPoint && nextPoint) {
-		
-			lastX = lastPoint.plotX;
-			lastY = lastPoint.plotY;
-			nextX = nextPoint.plotX;
-			nextY = nextPoint.plotY;
-			leftContX = (smoothing * plotX + lastX) / denom;
-			leftContY = (smoothing * plotY + lastY) / denom;
-			rightContX = (smoothing * plotX + nextX) / denom;
-			rightContY = (smoothing * plotY + nextY) / denom;
-			distanceLeftControlPoint = Math.sqrt(Math.pow(leftContX - plotX, 2) + Math.pow(leftContY - plotY, 2));
-			distanceRightControlPoint = Math.sqrt(Math.pow(rightContX - plotX, 2) + Math.pow(rightContY - plotY, 2));
-			leftContAngle = Math.atan2(leftContY - plotY, leftContX - plotX);
-			rightContAngle = Math.atan2(rightContY - plotY, rightContX - plotX);
-			jointAngle = (Math.PI / 2) + ((leftContAngle + rightContAngle) / 2);
-				
-				
-			// Ensure the right direction, jointAngle should be in the same quadrant as leftContAngle
-			if (Math.abs(leftContAngle - jointAngle) > Math.PI / 2) {
-				jointAngle -= Math.PI;
-			}
-			
-			// Find the corrected control points for a spline straight through the point
-			leftContX = plotX + Math.cos(jointAngle) * distanceLeftControlPoint;
-			leftContY = plotY + Math.sin(jointAngle) * distanceLeftControlPoint;
-			rightContX = plotX + Math.cos(Math.PI + jointAngle) * distanceRightControlPoint;
-			rightContY = plotY + Math.sin(Math.PI + jointAngle) * distanceRightControlPoint;
-			
-			// Record for drawing in next point
-			point.rightContX = rightContX;
-			point.rightContY = rightContY;
-
-		}
-		
-		
-		// moveTo or lineTo
-		if (!i) {
-			ret = ['M', plotX, plotY];
-		} else { // curve from last point to this
-			ret = [
-				'C',
-				lastPoint.rightContX || lastPoint.plotX,
-				lastPoint.rightContY || lastPoint.plotY,
-				leftContX || plotX,
-				leftContY || plotY,
-				plotX,
-				plotY
-			];
-			lastPoint.rightContX = lastPoint.rightContY = null; // reset for updating series later
-		}
-		
-		
-	} else {
-		ret = proceed.call(this, segment, point, i);
-	}
-	return ret;
-});
-
-/**
- * Extend translate. The plotX and plotY values are computed as if the polar chart were a
- * cartesian plane, where plotX denotes the angle in radians and (yAxis.len - plotY) is the pixel distance from
- * center. 
- */
-wrap(seriesProto, 'translate', function (proceed) {
-		
-	// Run uber method
-	proceed.call(this);
-	
-	// Postprocess plot coordinates
-	if (this.chart.polar && !this.preventPostTranslate) {
-		var points = this.points,
-			i = points.length;
-		while (i--) {
-			// Translate plotX, plotY from angle and radius to true plot coordinates
-			this.toXY(points[i]);
-		}
-	}
-});
-
-/** 
- * Extend getSegmentPath to allow connecting ends across 0 to provide a closed circle in 
- * line-like series.
- */
-wrap(seriesProto, 'getSegmentPath', function (proceed, segment) {
-		
-	var points = this.points;
-	
-	// Connect the path
-	if (this.chart.polar && this.options.connectEnds !== false && 
-			segment[segment.length - 1] === points[points.length - 1] && points[0].y !== null) {
-		this.connectEnds = true; // re-used in splines
-		segment = [].concat(segment, [points[0]]);
-	}
-	
-	// Run uber method
-	return proceed.call(this, segment);
-	
-});
-
-
-function polarAnimate(proceed, init) {
-	var chart = this.chart,
-		animation = this.options.animation,
-		group = this.group,
-		markerGroup = this.markerGroup,
-		center = this.xAxis.center,
-		plotLeft = chart.plotLeft,
-		plotTop = chart.plotTop,
-		attribs;
-
-	// Specific animation for polar charts
-	if (chart.polar) {
-		
-		// Enable animation on polar charts only in SVG. In VML, the scaling is different, plus animation
-		// would be so slow it would't matter.
-		if (chart.renderer.isSVG) {
-
-			if (animation === true) {
-				animation = {};
-			}
-	
-			// Initialize the animation
-			if (init) {
-				
-				// Scale down the group and place it in the center
-				attribs = {
-					translateX: center[0] + plotLeft,
-					translateY: center[1] + plotTop,
-					scaleX: 0.001, // #1499
-					scaleY: 0.001
-				};
-					
-				group.attr(attribs);
-				if (markerGroup) {
-					markerGroup.attrSetters = group.attrSetters;
-					markerGroup.attr(attribs);
-				}
-				
-			// Run the animation
-			} else {
-				attribs = {
-					translateX: plotLeft,
-					translateY: plotTop,
-					scaleX: 1,
-					scaleY: 1
-				};
-				group.animate(attribs, animation);
-				if (markerGroup) {
-					markerGroup.animate(attribs, animation);
-				}
-				
-				// Delete this function to allow it only once
-				this.animate = null;
-			}
-		}
-	
-	// For non-polar charts, revert to the basic animation
-	} else {
-		proceed.call(this, init);
-	} 
-}
-
-// Define the animate method for both regular series and column series and their derivatives
-wrap(seriesProto, 'animate', polarAnimate);
-wrap(colProto, 'animate', polarAnimate);
-
-
-/**
- * Throw in a couple of properties to let setTooltipPoints know we're indexing the points
- * in degrees (0-360), not plot pixel width.
- */
-wrap(seriesProto, 'setTooltipPoints', function (proceed, renew) {
-		
-	if (this.chart.polar) {
-		extend(this.xAxis, {
-			tooltipLen: 360 // degrees are the resolution unit of the tooltipPoints array
-		});	
-	}
-	
-	// Run uber method
-	return proceed.call(this, renew);
-});
-
-
-/**
- * Extend the column prototype's translate method
- */
-wrap(colProto, 'translate', function (proceed) {
-		
-	var xAxis = this.xAxis,
-		len = this.yAxis.len,
-		center = xAxis.center,
-		startAngleRad = xAxis.startAngleRad,
-		renderer = this.chart.renderer,
-		start,
-		points,
-		point,
-		i;
-	
-	this.preventPostTranslate = true;
-	
-	// Run uber method
-	proceed.call(this);
-	
-	// Postprocess plot coordinates
-	if (xAxis.isRadial) {
-		points = this.points;
-		i = points.length;
-		while (i--) {
-			point = points[i];
-			start = point.barX + startAngleRad;
-			point.shapeType = 'path';
-			point.shapeArgs = {
-				d: renderer.symbols.arc(
-					center[0],
-					center[1],
-					len - point.plotY,
-					null, 
-					{
-						start: start,
-						end: start + point.pointWidth,
-						innerR: len - pick(point.yBottom, len)
-					}
-				)
-			};
-			this.toXY(point); // provide correct plotX, plotY for tooltip
-		}
-	}
-});
-
-
-/**
- * Align column data labels outside the columns. #1199.
- */
-wrap(colProto, 'alignDataLabel', function (proceed, point, dataLabel, options, alignTo, isNew) {
-	
-	if (this.chart.polar) {
-		var angle = point.rectPlotX / Math.PI * 180,
-			align,
-			verticalAlign;
-		
-		// Align nicely outside the perimeter of the columns
-		if (options.align === null) {
-			if (angle > 20 && angle < 160) {
-				align = 'left'; // right hemisphere
-			} else if (angle > 200 && angle < 340) {
-				align = 'right'; // left hemisphere
-			} else {
-				align = 'center'; // top or bottom
-			}
-			options.align = align;
-		}
-		if (options.verticalAlign === null) {
-			if (angle < 45 || angle > 315) {
-				verticalAlign = 'bottom'; // top part
-			} else if (angle > 135 && angle < 225) {
-				verticalAlign = 'top'; // bottom part
-			} else {
-				verticalAlign = 'middle'; // left or right
-			}
-			options.verticalAlign = verticalAlign;
-		}
-		
-		seriesProto.alignDataLabel.call(this, point, dataLabel, options, alignTo, isNew);
-	} else {
-		proceed.call(this, point, dataLabel, options, alignTo, isNew);
-	}
-	
-});
-
-/**
- * Extend the mouse tracker to return the tooltip position index in terms of
- * degrees rather than pixels
- */
-wrap(pointerProto, 'getIndex', function (proceed, e) {
-	var ret,
-		chart = this.chart,
-		center,
-		x,
-		y;
-	
-	if (chart.polar) {
-		center = chart.xAxis[0].center;
-		x = e.chartX - center[0] - chart.plotLeft;
-		y = e.chartY - center[1] - chart.plotTop;
-		
-		ret = 180 - Math.round(Math.atan2(x, y) / Math.PI * 180);
-	
-	} else {
-	
-		// Run uber method
-		ret = proceed.call(this, e);
-	}
-	return ret;
-});
-
-/**
- * Extend getCoordinates to prepare for polar axis values
- */
-wrap(pointerProto, 'getCoordinates', function (proceed, e) {
-	var chart = this.chart,
-		ret = {
-			xAxis: [],
-			yAxis: []
-		};
-	
-	if (chart.polar) {	
-
-		each(chart.axes, function (axis) {
-			var isXAxis = axis.isXAxis,
-				center = axis.center,
-				x = e.chartX - center[0] - chart.plotLeft,
-				y = e.chartY - center[1] - chart.plotTop;
-			
-			ret[isXAxis ? 'xAxis' : 'yAxis'].push({
-				axis: axis,
-				value: axis.translate(
-					isXAxis ?
-						Math.PI - Math.atan2(x, y) : // angle 
-						Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)), // distance from center
-					true
-				)
-			});
-		});
-		
-	} else {
-		ret = proceed.call(this, e);
-	}
-	
-	return ret;
-});
-}(Highcharts));
+/*
+ Highcharts JS v3.0.5 (2013-08-23)
+
+ (c) 2009-2013 Torstein Hønsi
+
+ License: www.highcharts.com/license
+*/
+(function(l,C){function J(a,b,c){this.init.call(this,a,b,c)}function K(a,b,c){a.call(this,b,c);if(this.chart.polar)this.closeSegment=function(a){var c=this.xAxis.center;a.push("L",c[0],c[1])},this.closedStacks=!0}function L(a,b){var c=this.chart,d=this.options.animation,g=this.group,f=this.markerGroup,e=this.xAxis.center,i=c.plotLeft,o=c.plotTop;if(c.polar){if(c.renderer.isSVG)if(d===!0&&(d={}),b){if(c={translateX:e[0]+i,translateY:e[1]+o,scaleX:0.001,scaleY:0.001},g.attr(c),f)f.attrSetters=g.attrSetters,
+f.attr(c)}else c={translateX:i,translateY:o,scaleX:1,scaleY:1},g.animate(c,d),f&&f.animate(c,d),this.animate=null}else a.call(this,b)}var P=l.arrayMin,Q=l.arrayMax,r=l.each,F=l.extend,p=l.merge,R=l.map,q=l.pick,v=l.pInt,m=l.getOptions().plotOptions,h=l.seriesTypes,x=l.extendClass,M=l.splat,n=l.wrap,N=l.Axis,u=l.Tick,z=l.Series,t=h.column.prototype,s=Math,D=s.round,A=s.floor,S=s.max,w=function(){};F(J.prototype,{init:function(a,b,c){var d=this,g=d.defaultOptions;d.chart=b;if(b.angular)g.background=
+{};d.options=a=p(g,a);(a=a.background)&&r([].concat(M(a)).reverse(),function(a){var b=a.backgroundColor,a=p(d.defaultBackgroundOptions,a);if(b)a.backgroundColor=b;a.color=a.backgroundColor;c.options.plotBands.unshift(a)})},defaultOptions:{center:["50%","50%"],size:"85%",startAngle:0},defaultBackgroundOptions:{shape:"circle",borderWidth:1,borderColor:"silver",backgroundColor:{linearGradient:{x1:0,y1:0,x2:0,y2:1},stops:[[0,"#FFF"],[1,"#DDD"]]},from:Number.MIN_VALUE,innerRadius:0,to:Number.MAX_VALUE,
+outerRadius:"105%"}});var G=N.prototype,u=u.prototype,T={getOffset:w,redraw:function(){this.isDirty=!1},render:function(){this.isDirty=!1},setScale:w,setCategories:w,setTitle:w},O={isRadial:!0,defaultRadialGaugeOptions:{labels:{align:"center",x:0,y:null},minorGridLineWidth:0,minorTickInterval:"auto",minorTickLength:10,minorTickPosition:"inside",minorTickWidth:1,plotBands:[],tickLength:10,tickPosition:"inside",tickWidth:2,title:{rotation:0},zIndex:2},defaultRadialXOptions:{gridLineWidth:1,labels:{align:null,
+distance:15,x:0,y:null},maxPadding:0,minPadding:0,plotBands:[],showLastLabel:!1,tickLength:0},defaultRadialYOptions:{gridLineInterpolation:"circle",labels:{align:"right",x:-3,y:-2},plotBands:[],showLastLabel:!1,title:{x:4,text:null,rotation:90}},setOptions:function(a){this.options=p(this.defaultOptions,this.defaultRadialOptions,a)},getOffset:function(){G.getOffset.call(this);this.chart.axisOffset[this.side]=0;this.center=this.pane.center=h.pie.prototype.getCenter.call(this.pane)},getLinePath:function(a,
+b){var c=this.center,b=q(b,c[2]/2-this.offset);return this.chart.renderer.symbols.arc(this.left+c[0],this.top+c[1],b,b,{start:this.startAngleRad,end:this.endAngleRad,open:!0,innerR:0})},setAxisTranslation:function(){G.setAxisTranslation.call(this);if(this.center&&(this.transA=this.isCircular?(this.endAngleRad-this.startAngleRad)/(this.max-this.min||1):this.center[2]/2/(this.max-this.min||1),this.isXAxis))this.minPixelPadding=this.transA*this.minPointOffset+(this.reversed?(this.endAngleRad-this.startAngleRad)/
+4:0)},beforeSetTickPositions:function(){this.autoConnect&&(this.max+=this.categories&&1||this.pointRange||this.closestPointRange)},setAxisSize:function(){G.setAxisSize.call(this);if(this.center)this.len=this.width=this.height=this.isCircular?this.center[2]*(this.endAngleRad-this.startAngleRad)/2:this.center[2]/2},getPosition:function(a,b){if(!this.isCircular)b=this.translate(a),a=this.min;return this.postTranslate(this.translate(a),q(b,this.center[2]/2)-this.offset)},postTranslate:function(a,b){var c=
+this.chart,d=this.center,a=this.startAngleRad+a;return{x:c.plotLeft+d[0]+Math.cos(a)*b,y:c.plotTop+d[1]+Math.sin(a)*b}},getPlotBandPath:function(a,b,c){var d=this.center,g=this.startAngleRad,f=d[2]/2,e=[q(c.outerRadius,"100%"),c.innerRadius,q(c.thickness,10)],i=/%$/,o,k=this.isCircular;this.options.gridLineInterpolation==="polygon"?d=this.getPlotLinePath(a).concat(this.getPlotLinePath(b,!0)):(k||(e[0]=this.translate(a),e[1]=this.translate(b)),e=R(e,function(a){i.test(a)&&(a=v(a,10)*f/100);return a}),
+c.shape==="circle"||!k?(a=-Math.PI/2,b=Math.PI*1.5,o=!0):(a=g+this.translate(a),b=g+this.translate(b)),d=this.chart.renderer.symbols.arc(this.left+d[0],this.top+d[1],e[0],e[0],{start:a,end:b,innerR:q(e[1],e[0]-e[2]),open:o}));return d},getPlotLinePath:function(a,b){var c=this.center,d=this.chart,g=this.getPosition(a),f,e,i;this.isCircular?i=["M",c[0]+d.plotLeft,c[1]+d.plotTop,"L",g.x,g.y]:this.options.gridLineInterpolation==="circle"?(a=this.translate(a))&&(i=this.getLinePath(0,a)):(f=d.xAxis[0],
+i=[],a=this.translate(a),c=f.tickPositions,f.autoConnect&&(c=c.concat([c[0]])),b&&(c=[].concat(c).reverse()),r(c,function(c,b){e=f.getPosition(c,a);i.push(b?"L":"M",e.x,e.y)}));return i},getTitlePosition:function(){var a=this.center,b=this.chart,c=this.options.title;return{x:b.plotLeft+a[0]+(c.x||0),y:b.plotTop+a[1]-{high:0.5,middle:0.25,low:0}[c.align]*a[2]+(c.y||0)}}};n(G,"init",function(a,b,c){var j;var d=b.angular,g=b.polar,f=c.isX,e=d&&f,i,o;o=b.options;var k=c.pane||0;if(d){if(F(this,e?T:O),
+i=!f)this.defaultRadialOptions=this.defaultRadialGaugeOptions}else if(g)F(this,O),this.defaultRadialOptions=(i=f)?this.defaultRadialXOptions:p(this.defaultYAxisOptions,this.defaultRadialYOptions);a.call(this,b,c);if(!e&&(d||g)){a=this.options;if(!b.panes)b.panes=[];this.pane=(j=b.panes[k]=b.panes[k]||new J(M(o.pane)[k],b,this),k=j);k=k.options;b.inverted=!1;o.chart.zoomType=null;this.startAngleRad=b=(k.startAngle-90)*Math.PI/180;this.endAngleRad=o=(q(k.endAngle,k.startAngle+360)-90)*Math.PI/180;this.offset=
+a.offset||0;if((this.isCircular=i)&&c.max===C&&o-b===2*Math.PI)this.autoConnect=!0}});n(u,"getPosition",function(a,b,c,d,g){var f=this.axis;return f.getPosition?f.getPosition(c):a.call(this,b,c,d,g)});n(u,"getLabelPosition",function(a,b,c,d,g,f,e,i,o){var k=this.axis,j=f.y,h=f.align,l=(k.translate(this.pos)+k.startAngleRad+Math.PI/2)/Math.PI*180%360;k.isRadial?(a=k.getPosition(this.pos,k.center[2]/2+q(f.distance,-25)),f.rotation==="auto"?d.attr({rotation:l}):j===null&&(j=v(d.styles.lineHeight)*0.9-
+d.getBBox().height/2),h===null&&(h=k.isCircular?l>20&&l<160?"left":l>200&&l<340?"right":"center":"center",d.attr({align:h})),a.x+=f.x,a.y+=j):a=a.call(this,b,c,d,g,f,e,i,o);return a});n(u,"getMarkPath",function(a,b,c,d,g,f,e){var i=this.axis;i.isRadial?(a=i.getPosition(this.pos,i.center[2]/2+d),b=["M",b,c,"L",a.x,a.y]):b=a.call(this,b,c,d,g,f,e);return b});m.arearange=p(m.area,{lineWidth:1,marker:null,threshold:null,tooltip:{pointFormat:'<span style="color:{series.color}">{series.name}</span>: <b>{point.low}</b> - <b>{point.high}</b><br/>'},
+trackByArea:!0,dataLabels:{verticalAlign:null,xLow:0,xHigh:0,yLow:0,yHigh:0}});h.arearange=l.extendClass(h.area,{type:"arearange",pointArrayMap:["low","high"],toYData:function(a){return[a.low,a.high]},pointValKey:"low",getSegments:function(){var a=this;r(a.points,function(b){if(!a.options.connectNulls&&(b.low===null||b.high===null))b.y=null;else if(b.low===null&&b.high!==null)b.y=b.high});z.prototype.getSegments.call(this)},translate:function(){var a=this.yAxis;h.area.prototype.translate.apply(this);
+r(this.points,function(b){var c=b.low,d=b.high,g=b.plotY;d===null&&c===null?b.y=null:c===null?(b.plotLow=b.plotY=null,b.plotHigh=a.translate(d,0,1,0,1)):d===null?(b.plotLow=g,b.plotHigh=null):(b.plotLow=g,b.plotHigh=a.translate(d,0,1,0,1))})},getSegmentPath:function(a){var b,c=[],d=a.length,g=z.prototype.getSegmentPath,f,e;e=this.options;var i=e.step;for(b=HighchartsAdapter.grep(a,function(a){return a.plotLow!==null});d--;)f=a[d],f.plotHigh!==null&&c.push({plotX:f.plotX,plotY:f.plotHigh});a=g.call(this,
+b);if(i)i===!0&&(i="left"),e.step={left:"right",center:"center",right:"left"}[i];c=g.call(this,c);e.step=i;e=[].concat(a,c);c[0]="L";this.areaPath=this.areaPath.concat(a,c);return e},drawDataLabels:function(){var a=this.data,b=a.length,c,d=[],g=z.prototype,f=this.options.dataLabels,e,i=this.chart.inverted;if(f.enabled||this._hasPointLabels){for(c=b;c--;)e=a[c],e.y=e.high,e.plotY=e.plotHigh,d[c]=e.dataLabel,e.dataLabel=e.dataLabelUpper,e.below=!1,i?(f.align="left",f.x=f.xHigh):f.y=f.yHigh;g.drawDataLabels.apply(this,
+arguments);for(c=b;c--;)e=a[c],e.dataLabelUpper=e.dataLabel,e.dataLabel=d[c],e.y=e.low,e.plotY=e.plotLow,e.below=!0,i?(f.align="right",f.x=f.xLow):f.y=f.yLow;g.drawDataLabels.apply(this,arguments)}},alignDataLabel:h.column.prototype.alignDataLabel,getSymbol:h.column.prototype.getSymbol,drawPoints:w});m.areasplinerange=p(m.arearange);h.areasplinerange=x(h.arearange,{type:"areasplinerange",getPointSpline:h.spline.prototype.getPointSpline});m.columnrange=p(m.column,m.arearange,{lineWidth:1,pointRange:null});
+h.columnrange=x(h.arearange,{type:"columnrange",translate:function(){var a=this,b=a.yAxis,c;t.translate.apply(a);r(a.points,function(d){var g=d.shapeArgs,f=a.options.minPointLength,e;d.plotHigh=c=b.translate(d.high,0,1,0,1);d.plotLow=d.plotY;e=c;d=d.plotY-c;d<f&&(f-=d,d+=f,e-=f/2);g.height=d;g.y=e})},trackerGroups:["group","dataLabels"],drawGraph:w,pointAttrToOptions:t.pointAttrToOptions,drawPoints:t.drawPoints,drawTracker:t.drawTracker,animate:t.animate,getColumnMetrics:t.getColumnMetrics});m.gauge=
+p(m.line,{dataLabels:{enabled:!0,y:15,borderWidth:1,borderColor:"silver",borderRadius:3,style:{fontWeight:"bold"},verticalAlign:"top",zIndex:2},dial:{},pivot:{},tooltip:{headerFormat:""},showInLegend:!1});u={type:"gauge",pointClass:l.extendClass(l.Point,{setState:function(a){this.state=a}}),angular:!0,drawGraph:w,trackerGroups:["group","dataLabels"],translate:function(){var a=this.yAxis,b=this.options,c=a.center;this.generatePoints();r(this.points,function(d){var g=p(b.dial,d.dial),f=v(q(g.radius,
+80))*c[2]/200,e=v(q(g.baseLength,70))*f/100,i=v(q(g.rearLength,10))*f/100,o=g.baseWidth||3,k=g.topWidth||1,j=a.startAngleRad+a.translate(d.y,null,null,null,!0);b.wrap===!1&&(j=Math.max(a.startAngleRad,Math.min(a.endAngleRad,j)));j=j*180/Math.PI;d.shapeType="path";d.shapeArgs={d:g.path||["M",-i,-o/2,"L",e,-o/2,f,-k/2,f,k/2,e,o/2,-i,o/2,"z"],translateX:c[0],translateY:c[1],rotation:j};d.plotX=c[0];d.plotY=c[1]})},drawPoints:function(){var a=this,b=a.yAxis.center,c=a.pivot,d=a.options,g=d.pivot,f=a.chart.renderer;
+r(a.points,function(c){var b=c.graphic,g=c.shapeArgs,k=g.d,j=p(d.dial,c.dial);b?(b.animate(g),g.d=k):c.graphic=f[c.shapeType](g).attr({stroke:j.borderColor||"none","stroke-width":j.borderWidth||0,fill:j.backgroundColor||"black",rotation:g.rotation}).add(a.group)});c?c.animate({translateX:b[0],translateY:b[1]}):a.pivot=f.circle(0,0,q(g.radius,5)).attr({"stroke-width":g.borderWidth||0,stroke:g.borderColor||"silver",fill:g.backgroundColor||"black"}).translate(b[0],b[1]).add(a.group)},animate:function(a){var b=
+this;if(!a)r(b.points,function(a){var d=a.graphic;d&&(d.attr({rotation:b.yAxis.startAngleRad*180/Math.PI}),d.animate({rotation:a.shapeArgs.rotation},b.options.animation))}),b.animate=null},render:function(){this.group=this.plotGroup("group","series",this.visible?"visible":"hidden",this.options.zIndex,this.chart.seriesGroup);h.pie.prototype.render.call(this);this.group.clip(this.chart.clipRect)},setData:h.pie.prototype.setData,drawTracker:h.column.prototype.drawTracker};h.gauge=l.extendClass(h.line,
+u);m.boxplot=p(m.column,{fillColor:"#FFFFFF",lineWidth:1,medianWidth:2,states:{hover:{brightness:-0.3}},threshold:null,tooltip:{pointFormat:'<span style="color:{series.color};font-weight:bold">{series.name}</span><br/>Maximum: {point.high}<br/>Upper quartile: {point.q3}<br/>Median: {point.median}<br/>Lower quartile: {point.q1}<br/>Minimum: {point.low}<br/>'},whiskerLength:"50%",whiskerWidth:2});h.boxplot=x(h.column,{type:"boxplot",pointArrayMap:["low","q1","median","q3","high"],toYData:function(a){return[a.low,
+a.q1,a.median,a.q3,a.high]},pointValKey:"high",pointAttrToOptions:{fill:"fillColor",stroke:"color","stroke-width":"lineWidth"},drawDataLabels:w,translate:function(){var a=this.yAxis,b=this.pointArrayMap;h.column.prototype.translate.apply(this);r(this.points,function(c){r(b,function(b){c[b]!==null&&(c[b+"Plot"]=a.translate(c[b],0,1,0,1))})})},drawPoints:function(){var a=this,b=a.points,c=a.options,d=a.chart.renderer,g,f,e,i,o,k,j,h,l,m,n,H,p,E,I,t,w,s,v,u,z,y,x=a.doQuartiles!==!1,B=parseInt(a.options.whiskerLength,
+10)/100;r(b,function(b){l=b.graphic;z=b.shapeArgs;n={};E={};t={};y=b.color||a.color;if(b.plotY!==C)if(g=b.pointAttr[b.selected?"selected":""],w=z.width,s=A(z.x),v=s+w,u=D(w/2),f=A(x?b.q1Plot:b.lowPlot),e=A(x?b.q3Plot:b.lowPlot),i=A(b.highPlot),o=A(b.lowPlot),n.stroke=b.stemColor||c.stemColor||y,n["stroke-width"]=q(b.stemWidth,c.stemWidth,c.lineWidth),n.dashstyle=b.stemDashStyle||c.stemDashStyle,E.stroke=b.whiskerColor||c.whiskerColor||y,E["stroke-width"]=q(b.whiskerWidth,c.whiskerWidth,c.lineWidth),
+t.stroke=b.medianColor||c.medianColor||y,t["stroke-width"]=q(b.medianWidth,c.medianWidth,c.lineWidth),j=n["stroke-width"]%2/2,h=s+u+j,m=["M",h,e,"L",h,i,"M",h,f,"L",h,o,"z"],x&&(j=g["stroke-width"]%2/2,h=A(h)+j,f=A(f)+j,e=A(e)+j,s+=j,v+=j,H=["M",s,e,"L",s,f,"L",v,f,"L",v,e,"L",s,e,"z"]),B&&(j=E["stroke-width"]%2/2,i+=j,o+=j,p=["M",h-u*B,i,"L",h+u*B,i,"M",h-u*B,o,"L",h+u*B,o]),j=t["stroke-width"]%2/2,k=D(b.medianPlot)+j,I=["M",s,k,"L",v,k,"z"],l)b.stem.animate({d:m}),B&&b.whiskers.animate({d:p}),x&&
+b.box.animate({d:H}),b.medianShape.animate({d:I});else{b.graphic=l=d.g().add(a.group);b.stem=d.path(m).attr(n).add(l);if(B)b.whiskers=d.path(p).attr(E).add(l);if(x)b.box=d.path(H).attr(g).add(l);b.medianShape=d.path(I).attr(t).add(l)}})}});m.errorbar=p(m.boxplot,{color:"#000000",grouping:!1,linkedTo:":previous",tooltip:{pointFormat:m.arearange.tooltip.pointFormat},whiskerWidth:null});h.errorbar=x(h.boxplot,{type:"errorbar",pointArrayMap:["low","high"],toYData:function(a){return[a.low,a.high]},pointValKey:"high",
+doQuartiles:!1,getColumnMetrics:function(){return this.linkedParent&&this.linkedParent.columnMetrics||h.column.prototype.getColumnMetrics.call(this)}});m.waterfall=p(m.column,{lineWidth:1,lineColor:"#333",dashStyle:"dot",borderColor:"#333"});h.waterfall=x(h.column,{type:"waterfall",upColorProp:"fill",pointArrayMap:["low","y"],pointValKey:"y",init:function(a,b){b.stacking=!0;h.column.prototype.init.call(this,a,b)},translate:function(){var a=this.options,b=this.yAxis,c,d,g,f,e,i,o,k,j;c=a.threshold;
+a=a.borderWidth%2/2;h.column.prototype.translate.apply(this);k=c;g=this.points;for(d=0,c=g.length;d<c;d++){f=g[d];e=f.shapeArgs;i=this.getStack(d);j=i.points[this.index];if(isNaN(f.y))f.y=this.yData[d];o=S(k,k+f.y)+j[0];e.y=b.translate(o,0,1);f.isSum||f.isIntermediateSum?(e.y=b.translate(j[1],0,1),e.height=b.translate(j[0],0,1)-e.y):k+=i.total;e.height<0&&(e.y+=e.height,e.height*=-1);f.plotY=e.y=D(e.y)-a;e.height=D(e.height);f.yBottom=e.y+e.height}},processData:function(a){var b=this.yData,c=this.points,
+d,g=b.length,f=this.options.threshold||0,e,i,h,k,j,l;i=e=h=k=f;for(l=0;l<g;l++)j=b[l],d=c?c[l]:{},j==="sum"||d.isSum?b[l]=i:j==="intermediateSum"||d.isIntermediateSum?(b[l]=e,e=f):(i+=j,e+=j),h=Math.min(i,h),k=Math.max(i,k);z.prototype.processData.call(this,a);this.dataMin=h;this.dataMax=k},toYData:function(a){if(a.isSum)return"sum";else if(a.isIntermediateSum)return"intermediateSum";return a.y},getAttribs:function(){h.column.prototype.getAttribs.apply(this,arguments);var a=this.options,b=a.states,
+c=a.upColor||this.color,a=l.Color(c).brighten(0.1).get(),d=p(this.pointAttr),g=this.upColorProp;d[""][g]=c;d.hover[g]=b.hover.upColor||a;d.select[g]=b.select.upColor||c;r(this.points,function(a){if(a.y>0&&!a.color)a.pointAttr=d,a.color=c})},getGraphPath:function(){var a=this.data,b=a.length,c=D(this.options.lineWidth+this.options.borderWidth)%2/2,d=[],g,f,e;for(e=1;e<b;e++)f=a[e].shapeArgs,g=a[e-1].shapeArgs,f=["M",g.x+g.width,g.y+c,"L",f.x,g.y+c],a[e-1].y<0&&(f[2]+=g.height,f[5]+=g.height),d=d.concat(f);
+return d},getExtremes:w,getStack:function(a){var b=this.yAxis.stacks,c=this.stackKey;this.processedYData[a]<this.options.threshold&&(c="-"+c);return b[c][a]},drawGraph:z.prototype.drawGraph});m.bubble=p(m.scatter,{dataLabels:{inside:!0,style:{color:"white",textShadow:"0px 0px 3px black"},verticalAlign:"middle"},marker:{lineColor:null,lineWidth:1},minSize:8,maxSize:"20%",tooltip:{pointFormat:"({point.x}, {point.y}), Size: {point.z}"},turboThreshold:0,zThreshold:0});h.bubble=x(h.scatter,{type:"bubble",
+pointArrayMap:["y","z"],trackerGroups:["group","dataLabelsGroup"],pointAttrToOptions:{stroke:"lineColor","stroke-width":"lineWidth",fill:"fillColor"},applyOpacity:function(a){var b=this.options.marker,c=q(b.fillOpacity,0.5),a=a||b.fillColor||this.color;c!==1&&(a=l.Color(a).setOpacity(c).get("rgba"));return a},convertAttribs:function(){var a=z.prototype.convertAttribs.apply(this,arguments);a.fill=this.applyOpacity(a.fill);return a},getRadii:function(a,b,c,d){var g,f,e,i=this.zData,h=[];for(f=0,g=i.length;f<
+g;f++)e=b-a,e=e>0?(i[f]-a)/(b-a):0.5,h.push(s.ceil(c+e*(d-c))/2);this.radii=h},animate:function(a){var b=this.options.animation;if(!a)r(this.points,function(a){var d=a.graphic,a=a.shapeArgs;d&&a&&(d.attr("r",1),d.animate({r:a.r},b))}),this.animate=null},translate:function(){var a,b=this.data,c,d,g=this.radii;h.scatter.prototype.translate.call(this);for(a=b.length;a--;)c=b[a],d=g?g[a]:0,c.negative=c.z<(this.options.zThreshold||0),d>=this.minPxSize/2?(c.shapeType="circle",c.shapeArgs={x:c.plotX,y:c.plotY,
+r:d},c.dlBox={x:c.plotX-d,y:c.plotY-d,width:2*d,height:2*d}):c.shapeArgs=c.plotY=c.dlBox=C},drawLegendSymbol:function(a,b){var c=v(a.itemStyle.fontSize)/2;b.legendSymbol=this.chart.renderer.circle(c,a.baseline-c,c).attr({zIndex:3}).add(b.legendGroup);b.legendSymbol.isMarker=!0},drawPoints:h.column.prototype.drawPoints,alignDataLabel:h.column.prototype.alignDataLabel});N.prototype.beforePadding=function(){var a=this,b=this.len,c=this.chart,d=0,g=b,f=this.isXAxis,e=f?"xData":"yData",i=this.min,h={},
+k=s.min(c.plotWidth,c.plotHeight),j=Number.MAX_VALUE,l=-Number.MAX_VALUE,m=this.max-i,n=b/m,p=[];this.tickPositions&&(r(this.series,function(b){var c=b.options;if(b.type==="bubble"&&b.visible&&(a.allowZoomOutside=!0,p.push(b),f))r(["minSize","maxSize"],function(a){var b=c[a],d=/%$/.test(b),b=v(b);h[a]=d?k*b/100:b}),b.minPxSize=h.minSize,b=b.zData,b.length&&(j=s.min(j,s.max(P(b),c.displayNegative===!1?c.zThreshold:-Number.MAX_VALUE)),l=s.max(l,Q(b)))}),r(p,function(a){var b=a[e],c=b.length,k;f&&a.getRadii(j,
+l,h.minSize,h.maxSize);if(m>0)for(;c--;)k=a.radii[c],d=Math.min((b[c]-i)*n-k,d),g=Math.max((b[c]-i)*n+k,g)}),m>0&&q(this.options.min,this.userMin)===C&&q(this.options.max,this.userMax)===C&&(g-=b,n*=(b+d-g)/b,this.min+=d/n,this.max+=g/n))};var y=z.prototype,m=l.Pointer.prototype;y.toXY=function(a){var b,c=this.chart;b=a.plotX;var d=a.plotY;a.rectPlotX=b;a.rectPlotY=d;a.clientX=(b/Math.PI*180+this.xAxis.pane.options.startAngle)%360;b=this.xAxis.postTranslate(a.plotX,this.yAxis.len-d);a.plotX=a.polarPlotX=
+b.x-c.plotLeft;a.plotY=a.polarPlotY=b.y-c.plotTop};y.orderTooltipPoints=function(a){if(this.chart.polar&&(a.sort(function(a,c){return a.clientX-c.clientX}),a[0]))a[0].wrappedClientX=a[0].clientX+360,a.push(a[0])};n(h.area.prototype,"init",K);n(h.areaspline.prototype,"init",K);n(h.spline.prototype,"getPointSpline",function(a,b,c,d){var g,f,e,i,h,k,j;if(this.chart.polar){g=c.plotX;f=c.plotY;a=b[d-1];e=b[d+1];this.connectEnds&&(a||(a=b[b.length-2]),e||(e=b[1]));if(a&&e)i=a.plotX,h=a.plotY,b=e.plotX,
+k=e.plotY,i=(1.5*g+i)/2.5,h=(1.5*f+h)/2.5,e=(1.5*g+b)/2.5,j=(1.5*f+k)/2.5,b=Math.sqrt(Math.pow(i-g,2)+Math.pow(h-f,2)),k=Math.sqrt(Math.pow(e-g,2)+Math.pow(j-f,2)),i=Math.atan2(h-f,i-g),h=Math.atan2(j-f,e-g),j=Math.PI/2+(i+h)/2,Math.abs(i-j)>Math.PI/2&&(j-=Math.PI),i=g+Math.cos(j)*b,h=f+Math.sin(j)*b,e=g+Math.cos(Math.PI+j)*k,j=f+Math.sin(Math.PI+j)*k,c.rightContX=e,c.rightContY=j;d?(c=["C",a.rightContX||a.plotX,a.rightContY||a.plotY,i||g,h||f,g,f],a.rightContX=a.rightContY=null):c=["M",g,f]}else c=
+a.call(this,b,c,d);return c});n(y,"translate",function(a){a.call(this);if(this.chart.polar&&!this.preventPostTranslate)for(var a=this.points,b=a.length;b--;)this.toXY(a[b])});n(y,"getSegmentPath",function(a,b){var c=this.points;if(this.chart.polar&&this.options.connectEnds!==!1&&b[b.length-1]===c[c.length-1]&&c[0].y!==null)this.connectEnds=!0,b=[].concat(b,[c[0]]);return a.call(this,b)});n(y,"animate",L);n(t,"animate",L);n(y,"setTooltipPoints",function(a,b){this.chart.polar&&F(this.xAxis,{tooltipLen:360});
+return a.call(this,b)});n(t,"translate",function(a){var b=this.xAxis,c=this.yAxis.len,d=b.center,g=b.startAngleRad,f=this.chart.renderer,e,h;this.preventPostTranslate=!0;a.call(this);if(b.isRadial){b=this.points;for(h=b.length;h--;)e=b[h],a=e.barX+g,e.shapeType="path",e.shapeArgs={d:f.symbols.arc(d[0],d[1],c-e.plotY,null,{start:a,end:a+e.pointWidth,innerR:c-q(e.yBottom,c)})},this.toXY(e)}});n(t,"alignDataLabel",function(a,b,c,d,g,f){if(this.chart.polar){a=b.rectPlotX/Math.PI*180;if(d.align===null)d.align=
+a>20&&a<160?"left":a>200&&a<340?"right":"center";if(d.verticalAlign===null)d.verticalAlign=a<45||a>315?"bottom":a>135&&a<225?"top":"middle";y.alignDataLabel.call(this,b,c,d,g,f)}else a.call(this,b,c,d,g,f)});n(m,"getIndex",function(a,b){var c,d=this.chart,g;d.polar?(g=d.xAxis[0].center,c=b.chartX-g[0]-d.plotLeft,d=b.chartY-g[1]-d.plotTop,c=180-Math.round(Math.atan2(c,d)/Math.PI*180)):c=a.call(this,b);return c});n(m,"getCoordinates",function(a,b){var c=this.chart,d={xAxis:[],yAxis:[]};c.polar?r(c.axes,
+function(a){var f=a.isXAxis,e=a.center,h=b.chartX-e[0]-c.plotLeft,e=b.chartY-e[1]-c.plotTop;d[f?"xAxis":"yAxis"].push({axis:a,value:a.translate(f?Math.PI-Math.atan2(h,e):Math.sqrt(Math.pow(h,2)+Math.pow(e,2)),!0)})}):d=a.call(this,b);return d})})(Highcharts);