highcharts-rails 4.1.9 → 4.1.10

data/app/assets/javascripts/highcharts/modules/boost.js

@@ -42,35 +42,42 @@
  *   number of points drawn gets higher, and you may want to set the threshold lower in order to 
  *   use optimizations.
  */
-/*global document, Highcharts, HighchartsAdapter, setTimeout */
-(function (H, HA) {
+
+/* eslint indent: [2, 4] */
+(function (factory) {
+    if (typeof module === 'object' && module.exports) {
+        module.exports = factory;
+    } else {
+        factory(Highcharts);
+    }
+}(function (H) {
 
     'use strict';
 
-    var noop = function () { return undefined; },
+    var noop = function () {},
         Color = H.Color,
         Series = H.Series,
         seriesTypes = H.seriesTypes,
         each = H.each,
         extend = H.extend,
-        addEvent = HA.addEvent,
-        fireEvent = HA.fireEvent,
+        addEvent = H.addEvent,
+        fireEvent = H.fireEvent,
         merge = H.merge,
         pick = H.pick,
         wrap = H.wrap,
         plotOptions = H.getOptions().plotOptions,
         CHUNK_SIZE = 50000;
 
-    function eachAsync(arr, fn, callback, chunkSize, i) {
+    function eachAsync(arr, fn, finalFunc, chunkSize, i) {
         i = i || 0;
         chunkSize = chunkSize || CHUNK_SIZE;
         each(arr.slice(i, i + chunkSize), fn);
         if (i + chunkSize < arr.length) {
             setTimeout(function () {
-                eachAsync(arr, fn, callback, chunkSize, i + chunkSize);
+                eachAsync(arr, fn, finalFunc, chunkSize, i + chunkSize);
             });
-        } else if (callback) {
-            callback();
+        } else if (finalFunc) {
+            finalFunc();
         }
     }
 
@@ -161,14 +168,16 @@
                 point,
                 i;
 
-            for (i = 0; i < points.length; i = i + 1) {
-                point = points[i];
-                if (point && point.graphic) {
-                    point.graphic = point.graphic.destroy();
+            if (points) {
+                for (i = 0; i < points.length; i = i + 1) {
+                    point = points[i];
+                    if (point && point.graphic) {
+                        point.graphic = point.graphic.destroy();
+                    }
                 }
             }
 
-            each(['graph', 'area'], function (prop) {
+            each(['graph', 'area', 'tracker'], function (prop) {
                 if (series[prop]) {
                     series[prop] = series[prop].destroy();
                 }
@@ -180,15 +189,25 @@
          * to an SVG image element.
          */
         getContext: function () {
-            var width = this.chart.plotWidth,
-                height = this.chart.plotHeight;
+            var chart = this.chart,
+                width = chart.plotWidth,
+                height = chart.plotHeight,
+                ctx = this.ctx,
+                swapXY = function (proceed, x, y, a, b, c, d) {
+                    proceed.call(this, y, x, a, b, c, d);
+                };
 
             if (!this.canvas) {
                 this.canvas = document.createElement('canvas');
-                this.image = this.chart.renderer.image('', 0, 0, width, height).add(this.group);
-                this.ctx = this.canvas.getContext('2d');
+                this.image = chart.renderer.image('', 0, 0, width, height).add(this.group);
+                this.ctx = ctx = this.canvas.getContext('2d');
+                if (chart.inverted) {
+                    each(['moveTo', 'lineTo', 'rect', 'arc'], function (fn) {
+                        wrap(ctx, fn, swapXY);
+                    });
+                }
             } else {
-                this.ctx.clearRect(0, 0, width, height);
+                ctx.clearRect(0, 0, width, height);
             }
 
             this.canvas.setAttribute('width', width);
@@ -198,7 +217,7 @@
                 height: height
             });
 
-            return this.ctx;
+            return ctx;
         },
 
         /** 
@@ -308,18 +327,24 @@
                     // The k-d tree requires series points. Reduce the amount of points, since the time to build the 
                     // tree increases exponentially.
                     if (enableMouseTracking && !pointTaken[clientX + ',' + plotY]) {
+                        pointTaken[clientX + ',' + plotY] = true;
+
+                        if (chart.inverted) {
+                            clientX = xAxis.len - clientX;
+                            plotY = yAxis.len - plotY;
+                        }
+
                         points.push({
                             clientX: clientX,
                             plotX: clientX,
                             plotY: plotY,
                             i: cropStart + i
                         });
-                        pointTaken[clientX + ',' + plotY] = true;
                     }
                 };
 
             // If we are zooming out from SVG mode, destroy the graphics
-            if (this.points) {
+            if (this.points || this.graph) {
                 this.destroyGraphics();
             }
 
@@ -488,7 +513,7 @@
                 }
 
                 // Pass tests in Pointer. 
-                // TODO: Replace this with a single property, and replace when zooming in
+                // Replace this with a single property, and replace when zooming in
                 // below boostThreshold.
                 series.directTouch = false;
                 series.options.stickyTracking = true;
@@ -535,20 +560,32 @@
         sampling: true
     });
 
+    /**
+     * Return a full Point object based on the index. The boost module uses stripped point objects
+     * for performance reasons.
+     * @param   {Number} boostPoint A stripped-down point object
+     * @returns {Object}   A Point object as per http://api.highcharts.com/highcharts#Point
+     */
+    Series.prototype.getPoint = function (boostPoint) {
+        var point = boostPoint;
+
+        if (boostPoint && !(boostPoint instanceof this.pointClass)) {
+            point = (new this.pointClass()).init(this, this.options.data[boostPoint.i]);
+            point.dist = boostPoint.dist;
+            point.category = point.x;
+            point.plotX = boostPoint.plotX;
+            point.plotY = boostPoint.plotY;
+        }
+
+        return point;
+    };
+
     /**
      * Return a point instance from the k-d-tree
      */
     wrap(Series.prototype, 'searchPoint', function (proceed) {
-        var point = proceed.apply(this, [].slice.call(arguments, 1)),
-            ret = point;
-
-        if (point && !(point instanceof this.pointClass)) {
-            ret = (new this.pointClass()).init(this, this.options.data[point.i]);
-            ret.dist = point.dist;
-            ret.category = ret.x;
-            ret.plotX = point.plotX;
-            ret.plotY = point.plotY;
-        }
-        return ret;
+        return this.getPoint(
+            proceed.apply(this, [].slice.call(arguments, 1))
+        );
     });
-}(Highcharts, HighchartsAdapter));
+}));

data/app/assets/javascripts/highcharts/modules/broken-axis.js

@@ -1,20 +1,25 @@
 /**
- * Highcharts JS v4.1.9 (2015-10-07)
+ * Highcharts JS v4.1.10 (2015-12-07)
  * Highcharts Broken Axis module
  * 
- * Author: Stephane Vanraes, Torstein Honsi
  * License: www.highcharts.com/license
  */
 
-/*global HighchartsAdapter*/
-(function (H) {	
+(function (factory) {
+	if (typeof module === 'object' && module.exports) {
+		module.exports = factory;
+	} else {
+		factory(Highcharts);
+	}
+}(function (H) {
 
-	"use strict";
+	'use strict';
 
 	var pick = H.pick,
 		wrap = H.wrap,
+		each = H.each,
 		extend = H.extend,
-		fireEvent = HighchartsAdapter.fireEvent,
+		fireEvent = H.fireEvent,
 		Axis = H.Axis,
 		Series = H.Series;
 
@@ -207,11 +212,13 @@
 				}
 
 				breakArrayT.sort(function (a, b) {
+					var ret;
 					if (a.value === b.value) {
-						return (a.move === 'in' ? 0 : 1) - (b.move === 'in' ? 0 : 1);
+						ret = (a.move === 'in' ? 0 : 1) - (b.move === 'in' ? 0 : 1);
 					} else {
-						return a.value - b.value;
+						ret = a.value - b.value;
 					}
+					return ret;
 				});
 				
 				// Simplify the breaks
@@ -277,38 +284,44 @@
 
 	});
 
-	wrap(H.seriesTypes.column.prototype, 'drawPoints', function (proceed) {
+	function drawPointsWrapped(proceed) {
 		proceed.apply(this);
+		this.drawBreaks();
+	}
 
+	H.Series.prototype.drawBreaks = function () {
 		var series = this,
 			points = series.points,
-			yAxis = series.yAxis,
-			breaks = yAxis.breakArray || [],
-			threshold = pick(this.options.threshold, yAxis.min),
+			axis,
+			breaks,
+			threshold,
+			axisName = 'Axis',
 			eventName,
-			point,
-			brk,
-			i,
-			j,
 			y;
 
-		for (i = 0; i < points.length; i++) {
-			point = points[i];
-			y = point.stackY || point.y;
-			for (j = 0; j < breaks.length; j++) {
-				brk = breaks[j];
-				eventName = false;
+		each(['y', 'x'], function (key) {
+			axis = series[key + axisName];
+			breaks = axis.breakArray || [];
+			threshold = axis.isXAxis ? axis.min : pick(series.options.threshold, axis.min);
+			each(points, function (point) {
+				y = pick(point['stack' + key.toUpperCase()], point[key]);
+				each(breaks, function (brk) {
+					eventName = false;
 
-				if ((threshold < brk.from && y > brk.to) || (threshold > brk.from && y < brk.from)) { 
+					if ((threshold < brk.from && y > brk.to) || (threshold > brk.from && y < brk.from)) { 
 						eventName = 'pointBreak';
-				} else if ((threshold < brk.from && y > brk.from && y < brk.to) || (threshold > brk.from && y > brk.to && y < brk.from)) { // point falls inside the break
+					} else if ((threshold < brk.from && y > brk.from && y < brk.to) || (threshold > brk.from && y > brk.to && y < brk.from)) { // point falls inside the break
 						eventName = 'pointInBreak'; // docs
-				} 
-				if (eventName) {
-					fireEvent(yAxis, eventName, {point: point, brk: brk});
-				}
-			}
-		}
+					} 
+					if (eventName) {
+						fireEvent(axis, eventName, { point: point, brk: brk });
+					}
+				});
+			});
+		});
+	};
 
-	});
-}(Highcharts));
+	wrap(H.seriesTypes.column.prototype, 'drawPoints', drawPointsWrapped);
+	wrap(H.Series.prototype, 'drawPoints', drawPointsWrapped);
+
+}));

data/app/assets/javascripts/highcharts/modules/canvas-tools.js

@@ -2908,7 +2908,7 @@ if (CanvasRenderingContext2D) {
 		});
 	}
 }/**
- * @license Highcharts JS v4.1.9 (2015-10-07)
+ * @license Highcharts JS v4.1.10 (2015-12-07)
  * CanVGRenderer Extension module
  *
  * (c) 2011-2012 Torstein Honsi, Erik Olsson
@@ -2916,10 +2916,7 @@ if (CanvasRenderingContext2D) {
  * License: www.highcharts.com/license
  */
 
-// JSLint options:
-/*global Highcharts */
-
-(function (Highcharts) { // encapsulate
+(function (Highcharts) {
 	var UNDEFINED,
 		DIV = 'div',
 		ABSOLUTE = 'absolute',
@@ -2955,7 +2952,7 @@ if (CanvasRenderingContext2D) {
 				canvas,
 				initialHiddenStyle = { visibility: HIDDEN, position: ABSOLUTE };
 
-			this.init.apply(this, [container, chartWidth, chartHeight]);
+			this.init(container, chartWidth, chartHeight);
 
 			// add the canvas above it
 			canvas = createElement('canvas', {
@@ -3033,7 +3030,11 @@ if (CanvasRenderingContext2D) {
 				tooltipDiv.innerHTML = args.text;
 
 				// Compute the best position for the tooltip based on the divs size and container size.
-				position = chart.tooltip.getPosition(tooltipDiv.offsetWidth, tooltipDiv.offsetHeight, {plotX: args.x, plotY: args.y});
+				position = chart.tooltip.getPosition(
+					tooltipDiv.offsetWidth, 
+					tooltipDiv.offsetHeight, 
+					{ plotX: args.x, plotY: args.y }
+				);
 
 				css(tooltipDiv, {
 					visibility: VISIBLE,

data/app/assets/javascripts/highcharts/modules/data.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v4.1.9 (2015-10-07)
+ * @license Highcharts JS v4.1.10 (2015-12-07)
  * Data module
  *
  * (c) 2012-2014 Torstein Honsi
@@ -7,15 +7,19 @@
  * License: www.highcharts.com/license
  */
 
-// JSLint options:
-/*global jQuery, HighchartsAdapter */
-
-(function (Highcharts) {
+/*global jQuery */
+(function (factory) {
+	if (typeof module === 'object' && module.exports) {
+		module.exports = factory;
+	} else {
+		factory(Highcharts);
+	}
+}(function (Highcharts) {
 	
 	// Utilities
 	var each = Highcharts.each,
 		pick = Highcharts.pick,
-		inArray = HighchartsAdapter.inArray,
+		inArray = Highcharts.inArray,
 		splat = Highcharts.splat,
 		SeriesBuilder;
 	
@@ -28,740 +32,740 @@
 	// Set the prototype properties
 	Highcharts.extend(Data.prototype, {
 		
-	/**
-	 * Initialize the Data object with the given options
-	 */
-	init: function (options, chartOptions) {
-		this.options = options;
-		this.chartOptions = chartOptions;
-		this.columns = options.columns || this.rowsToColumns(options.rows) || [];
-		this.firstRowAsNames = pick(options.firstRowAsNames, true);
-		this.decimalRegex = options.decimalPoint && new RegExp('^([0-9]+)' + options.decimalPoint + '([0-9]+)$');
-
-		// This is a two-dimensional array holding the raw, trimmed string values
-		// with the same organisation as the columns array. It makes it possible
-		// for example to revert from interpreted timestamps to string-based
-		// categories.
-		this.rawColumns = [];
-
-		// No need to parse or interpret anything
-		if (this.columns.length) {
-			this.dataFound();
-
-		// Parse and interpret
-		} else {
+		/**
+		 * Initialize the Data object with the given options
+		 */
+		init: function (options, chartOptions) {
+			this.options = options;
+			this.chartOptions = chartOptions;
+			this.columns = options.columns || this.rowsToColumns(options.rows) || [];
+			this.firstRowAsNames = pick(options.firstRowAsNames, true);
+			this.decimalRegex = options.decimalPoint && new RegExp('^(-?[0-9]+)' + options.decimalPoint + '([0-9]+)$');
+
+			// This is a two-dimensional array holding the raw, trimmed string values
+			// with the same organisation as the columns array. It makes it possible
+			// for example to revert from interpreted timestamps to string-based
+			// categories.
+			this.rawColumns = [];
+
+			// No need to parse or interpret anything
+			if (this.columns.length) {
+				this.dataFound();
+
+			// Parse and interpret
+			} else {
 
-			// Parse a CSV string if options.csv is given
-			this.parseCSV();
-			
-			// Parse a HTML table if options.table is given
-			this.parseTable();
+				// Parse a CSV string if options.csv is given
+				this.parseCSV();
+				
+				// Parse a HTML table if options.table is given
+				this.parseTable();
 
-			// Parse a Google Spreadsheet 
-			this.parseGoogleSpreadsheet();	
-		}
+				// Parse a Google Spreadsheet 
+				this.parseGoogleSpreadsheet();	
+			}
 
-	},
+		},
 
-	/**
-	 * Get the column distribution. For example, a line series takes a single column for 
-	 * Y values. A range series takes two columns for low and high values respectively,
-	 * and an OHLC series takes four columns.
-	 */
-	getColumnDistribution: function () {
-		var chartOptions = this.chartOptions,
-			options = this.options,
-			xColumns = [],
-			getValueCount = function (type) {
-				return (Highcharts.seriesTypes[type || 'line'].prototype.pointArrayMap || [0]).length;
-			},
-			getPointArrayMap = function (type) {
-				return Highcharts.seriesTypes[type || 'line'].prototype.pointArrayMap;
-			},
-			globalType = chartOptions && chartOptions.chart && chartOptions.chart.type,
-			individualCounts = [],
-			seriesBuilders = [],
-			seriesIndex = 0,
-			i;
-
-		each((chartOptions && chartOptions.series) || [], function (series) {
-			individualCounts.push(getValueCount(series.type || globalType));
-		});
+		/**
+		 * Get the column distribution. For example, a line series takes a single column for 
+		 * Y values. A range series takes two columns for low and high values respectively,
+		 * and an OHLC series takes four columns.
+		 */
+		getColumnDistribution: function () {
+			var chartOptions = this.chartOptions,
+				options = this.options,
+				xColumns = [],
+				getValueCount = function (type) {
+					return (Highcharts.seriesTypes[type || 'line'].prototype.pointArrayMap || [0]).length;
+				},
+				getPointArrayMap = function (type) {
+					return Highcharts.seriesTypes[type || 'line'].prototype.pointArrayMap;
+				},
+				globalType = chartOptions && chartOptions.chart && chartOptions.chart.type,
+				individualCounts = [],
+				seriesBuilders = [],
+				seriesIndex = 0,
+				i;
+
+			each((chartOptions && chartOptions.series) || [], function (series) {
+				individualCounts.push(getValueCount(series.type || globalType));
+			});
 
-		// Collect the x-column indexes from seriesMapping
-		each((options && options.seriesMapping) || [], function (mapping) {
-			xColumns.push(mapping.x || 0);
-		});
+			// Collect the x-column indexes from seriesMapping
+			each((options && options.seriesMapping) || [], function (mapping) {
+				xColumns.push(mapping.x || 0);
+			});
 
-		// If there are no defined series with x-columns, use the first column as x column
-		if (xColumns.length === 0) {
-			xColumns.push(0);
-		}
+			// If there are no defined series with x-columns, use the first column as x column
+			if (xColumns.length === 0) {
+				xColumns.push(0);
+			}
 
-		// Loop all seriesMappings and constructs SeriesBuilders from
-		// the mapping options.
-		each((options && options.seriesMapping) || [], function (mapping) {
-			var builder = new SeriesBuilder(),
-				name,
-				numberOfValueColumnsNeeded = individualCounts[seriesIndex] || getValueCount(globalType),
-				seriesArr = (chartOptions && chartOptions.series) || [],
-				series = seriesArr[seriesIndex] || {},
-				pointArrayMap = getPointArrayMap(series.type || globalType) || ['y'];
-
-			// Add an x reader from the x property or from an undefined column
-			// if the property is not set. It will then be auto populated later.
-			builder.addColumnReader(mapping.x, 'x');
-
-			// Add all column mappings
-			for (name in mapping) {
-				if (mapping.hasOwnProperty(name) && name !== 'x') {
-					builder.addColumnReader(mapping[name], name);
+			// Loop all seriesMappings and constructs SeriesBuilders from
+			// the mapping options.
+			each((options && options.seriesMapping) || [], function (mapping) {
+				var builder = new SeriesBuilder(),
+					name,
+					numberOfValueColumnsNeeded = individualCounts[seriesIndex] || getValueCount(globalType),
+					seriesArr = (chartOptions && chartOptions.series) || [],
+					series = seriesArr[seriesIndex] || {},
+					pointArrayMap = getPointArrayMap(series.type || globalType) || ['y'];
+
+				// Add an x reader from the x property or from an undefined column
+				// if the property is not set. It will then be auto populated later.
+				builder.addColumnReader(mapping.x, 'x');
+
+				// Add all column mappings
+				for (name in mapping) {
+					if (mapping.hasOwnProperty(name) && name !== 'x') {
+						builder.addColumnReader(mapping[name], name);
+					}
 				}
-			}
 
-			// Add missing columns
-			for (i = 0; i < numberOfValueColumnsNeeded; i++) {
-				if (!builder.hasReader(pointArrayMap[i])) {
-					//builder.addNextColumnReader(pointArrayMap[i]);
-					// Create and add a column reader for the next free column index
-					builder.addColumnReader(undefined, pointArrayMap[i]);
+				// Add missing columns
+				for (i = 0; i < numberOfValueColumnsNeeded; i++) {
+					if (!builder.hasReader(pointArrayMap[i])) {
+						//builder.addNextColumnReader(pointArrayMap[i]);
+						// Create and add a column reader for the next free column index
+						builder.addColumnReader(undefined, pointArrayMap[i]);
+					}
 				}
-			}
 
-			seriesBuilders.push(builder);
-			seriesIndex++;
-		});
+				seriesBuilders.push(builder);
+				seriesIndex++;
+			});
 
-		var globalPointArrayMap = getPointArrayMap(globalType);
-		if (globalPointArrayMap === undefined) {
-			globalPointArrayMap = ['y'];
-		}
+			var globalPointArrayMap = getPointArrayMap(globalType);
+			if (globalPointArrayMap === undefined) {
+				globalPointArrayMap = ['y'];
+			}
 
-		this.valueCount = {
-			global: getValueCount(globalType),
-			xColumns: xColumns,
-			individual: individualCounts,
-			seriesBuilders: seriesBuilders,
-			globalPointArrayMap: globalPointArrayMap
-		};
-	},
+			this.valueCount = {
+				global: getValueCount(globalType),
+				xColumns: xColumns,
+				individual: individualCounts,
+				seriesBuilders: seriesBuilders,
+				globalPointArrayMap: globalPointArrayMap
+			};
+		},
 
-	/**
-	 * When the data is parsed into columns, either by CSV, table, GS or direct input,
-	 * continue with other operations.
-	 */
-	dataFound: function () {
-		
-		if (this.options.switchRowsAndColumns) {
-			this.columns = this.rowsToColumns(this.columns);
-		}
+		/**
+		 * When the data is parsed into columns, either by CSV, table, GS or direct input,
+		 * continue with other operations.
+		 */
+		dataFound: function () {
+			
+			if (this.options.switchRowsAndColumns) {
+				this.columns = this.rowsToColumns(this.columns);
+			}
 
-		// Interpret the info about series and columns
-		this.getColumnDistribution();
+			// Interpret the info about series and columns
+			this.getColumnDistribution();
 
-		// Interpret the values into right types
-		this.parseTypes();
-		
-		// Handle columns if a handleColumns callback is given
-		if (this.parsed() !== false) {
-		
-			// Complete if a complete callback is given
-			this.complete();
-		}
-		
-	},
-	
-	/**
-	 * Parse a CSV input string
-	 */
-	parseCSV: function () {
-		var self = this,
-			options = this.options,
-			csv = options.csv,
-			columns = this.columns,
-			startRow = options.startRow || 0,
-			endRow = options.endRow || Number.MAX_VALUE,
-			startColumn = options.startColumn || 0,
-			endColumn = options.endColumn || Number.MAX_VALUE,
-			itemDelimiter,
-			lines,
-			activeRowNo = 0;
+			// Interpret the values into right types
+			this.parseTypes();
 			
-		if (csv) {
+			// Handle columns if a handleColumns callback is given
+			if (this.parsed() !== false) {
 			
-			lines = csv
-				.replace(/\r\n/g, "\n") // Unix
-				.replace(/\r/g, "\n") // Mac
-				.split(options.lineDelimiter || "\n");
-
-			itemDelimiter = options.itemDelimiter || (csv.indexOf('\t') !== -1 ? '\t' : ',');
+				// Complete if a complete callback is given
+				this.complete();
+			}
 			
-			each(lines, function (line, rowNo) {
-				var trimmed = self.trim(line),
-					isComment = trimmed.indexOf('#') === 0,
-					isBlank = trimmed === '',
-					items;
+		},
+		
+		/**
+		 * Parse a CSV input string
+		 */
+		parseCSV: function () {
+			var self = this,
+				options = this.options,
+				csv = options.csv,
+				columns = this.columns,
+				startRow = options.startRow || 0,
+				endRow = options.endRow || Number.MAX_VALUE,
+				startColumn = options.startColumn || 0,
+				endColumn = options.endColumn || Number.MAX_VALUE,
+				itemDelimiter,
+				lines,
+				activeRowNo = 0;
+				
+			if (csv) {
+				
+				lines = csv
+					.replace(/\r\n/g, '\n') // Unix
+					.replace(/\r/g, '\n') // Mac
+					.split(options.lineDelimiter || '\n');
+
+				itemDelimiter = options.itemDelimiter || (csv.indexOf('\t') !== -1 ? '\t' : ',');
 				
-				if (rowNo >= startRow && rowNo <= endRow && !isComment && !isBlank) {
-					items = line.split(itemDelimiter);
-					each(items, function (item, colNo) {
-						if (colNo >= startColumn && colNo <= endColumn) {
-							if (!columns[colNo - startColumn]) {
-								columns[colNo - startColumn] = [];					
+				each(lines, function (line, rowNo) {
+					var trimmed = self.trim(line),
+						isComment = trimmed.indexOf('#') === 0,
+						isBlank = trimmed === '',
+						items;
+					
+					if (rowNo >= startRow && rowNo <= endRow && !isComment && !isBlank) {
+						items = line.split(itemDelimiter);
+						each(items, function (item, colNo) {
+							if (colNo >= startColumn && colNo <= endColumn) {
+								if (!columns[colNo - startColumn]) {
+									columns[colNo - startColumn] = [];					
+								}
+								
+								columns[colNo - startColumn][activeRowNo] = item;
 							}
-							
-							columns[colNo - startColumn][activeRowNo] = item;
-						}
-					});
-					activeRowNo += 1;
-				}
-			});
+						});
+						activeRowNo += 1;
+					}
+				});
 
-			this.dataFound();
-		}
-	},
-	
-	/**
-	 * Parse a HTML table
-	 */
-	parseTable: function () {
-		var options = this.options,
-			table = options.table,
-			columns = this.columns,
-			startRow = options.startRow || 0,
-			endRow = options.endRow || Number.MAX_VALUE,
-			startColumn = options.startColumn || 0,
-			endColumn = options.endColumn || Number.MAX_VALUE;
-
-		if (table) {
-			
-			if (typeof table === 'string') {
-				table = document.getElementById(table);
+				this.dataFound();
 			}
-			
-			each(table.getElementsByTagName('tr'), function (tr, rowNo) {
-				if (rowNo >= startRow && rowNo <= endRow) {
-					each(tr.children, function (item, colNo) {
-						if ((item.tagName === 'TD' || item.tagName === 'TH') && colNo >= startColumn && colNo <= endColumn) {
-							if (!columns[colNo - startColumn]) {
-								columns[colNo - startColumn] = [];					
-							}
-							
-							columns[colNo - startColumn][rowNo - startRow] = item.innerHTML;
-						}
-					});
+		},
+		
+		/**
+		 * Parse a HTML table
+		 */
+		parseTable: function () {
+			var options = this.options,
+				table = options.table,
+				columns = this.columns,
+				startRow = options.startRow || 0,
+				endRow = options.endRow || Number.MAX_VALUE,
+				startColumn = options.startColumn || 0,
+				endColumn = options.endColumn || Number.MAX_VALUE;
+
+			if (table) {
+				
+				if (typeof table === 'string') {
+					table = document.getElementById(table);
 				}
-			});
-
-			this.dataFound(); // continue
-		}
-	},
-
-	/**
-	 */
-	parseGoogleSpreadsheet: function () {
-		var self = this,
-			options = this.options,
-			googleSpreadsheetKey = options.googleSpreadsheetKey,
-			columns = this.columns,
-			startRow = options.startRow || 0,
-			endRow = options.endRow || Number.MAX_VALUE,
-			startColumn = options.startColumn || 0,
-			endColumn = options.endColumn || Number.MAX_VALUE,
-			gr, // google row
-			gc; // google column
-
-		if (googleSpreadsheetKey) {
-			jQuery.ajax({
-				dataType: 'json', 
-				url: 'https://spreadsheets.google.com/feeds/cells/' + 
-				  googleSpreadsheetKey + '/' + (options.googleSpreadsheetWorksheet || 'od6') +
-					  '/public/values?alt=json-in-script&callback=?',
-				error: options.error,
-				success: function (json) {
-					// Prepare the data from the spreadsheat
-					var cells = json.feed.entry,
-						cell,
-						cellCount = cells.length,
-						colCount = 0,
-						rowCount = 0,
-						i;
 				
-					// First, find the total number of columns and rows that 
-					// are actually filled with data
-					for (i = 0; i < cellCount; i++) {
-						cell = cells[i];
-						colCount = Math.max(colCount, cell.gs$cell.col);
-						rowCount = Math.max(rowCount, cell.gs$cell.row);			
+				each(table.getElementsByTagName('tr'), function (tr, rowNo) {
+					if (rowNo >= startRow && rowNo <= endRow) {
+						each(tr.children, function (item, colNo) {
+							if ((item.tagName === 'TD' || item.tagName === 'TH') && colNo >= startColumn && colNo <= endColumn) {
+								if (!columns[colNo - startColumn]) {
+									columns[colNo - startColumn] = [];					
+								}
+								
+								columns[colNo - startColumn][rowNo - startRow] = item.innerHTML;
+							}
+						});
 					}
-				
-					// Set up arrays containing the column data
-					for (i = 0; i < colCount; i++) {
-						if (i >= startColumn && i <= endColumn) {
-							// Create new columns with the length of either end-start or rowCount
-							columns[i - startColumn] = [];
-
-							// Setting the length to avoid jslint warning
-							columns[i - startColumn].length = Math.min(rowCount, endRow - startRow);
+				});
+
+				this.dataFound(); // continue
+			}
+		},
+
+		/**
+		 */
+		parseGoogleSpreadsheet: function () {
+			var self = this,
+				options = this.options,
+				googleSpreadsheetKey = options.googleSpreadsheetKey,
+				columns = this.columns,
+				startRow = options.startRow || 0,
+				endRow = options.endRow || Number.MAX_VALUE,
+				startColumn = options.startColumn || 0,
+				endColumn = options.endColumn || Number.MAX_VALUE,
+				gr, // google row
+				gc; // google column
+
+			if (googleSpreadsheetKey) {
+				jQuery.ajax({
+					dataType: 'json', 
+					url: 'https://spreadsheets.google.com/feeds/cells/' + 
+						googleSpreadsheetKey + '/' + (options.googleSpreadsheetWorksheet || 'od6') +
+						'/public/values?alt=json-in-script&callback=?',
+					error: options.error,
+					success: function (json) {
+						// Prepare the data from the spreadsheat
+						var cells = json.feed.entry,
+							cell,
+							cellCount = cells.length,
+							colCount = 0,
+							rowCount = 0,
+							i;
+					
+						// First, find the total number of columns and rows that 
+						// are actually filled with data
+						for (i = 0; i < cellCount; i++) {
+							cell = cells[i];
+							colCount = Math.max(colCount, cell.gs$cell.col);
+							rowCount = Math.max(rowCount, cell.gs$cell.row);			
 						}
-					}
 					
-					// Loop over the cells and assign the value to the right
-					// place in the column arrays
-					for (i = 0; i < cellCount; i++) {
-						cell = cells[i];
-						gr = cell.gs$cell.row - 1; // rows start at 1
-						gc = cell.gs$cell.col - 1; // columns start at 1
-
-						// If both row and col falls inside start and end
-						// set the transposed cell value in the newly created columns
-						if (gc >= startColumn && gc <= endColumn &&
-							gr >= startRow && gr <= endRow) {
-							columns[gc - startColumn][gr - startRow] = cell.content.$t;
+						// Set up arrays containing the column data
+						for (i = 0; i < colCount; i++) {
+							if (i >= startColumn && i <= endColumn) {
+								// Create new columns with the length of either end-start or rowCount
+								columns[i - startColumn] = [];
+
+								// Setting the length to avoid jslint warning
+								columns[i - startColumn].length = Math.min(rowCount, endRow - startRow);
+							}
+						}
+						
+						// Loop over the cells and assign the value to the right
+						// place in the column arrays
+						for (i = 0; i < cellCount; i++) {
+							cell = cells[i];
+							gr = cell.gs$cell.row - 1; // rows start at 1
+							gc = cell.gs$cell.col - 1; // columns start at 1
+
+							// If both row and col falls inside start and end
+							// set the transposed cell value in the newly created columns
+							if (gc >= startColumn && gc <= endColumn &&
+								gr >= startRow && gr <= endRow) {
+								columns[gc - startColumn][gr - startRow] = cell.content.$t;
+							}
 						}
+						self.dataFound();
 					}
-					self.dataFound();
+				});
+			}
+		},
+		
+		/**
+		 * Trim a string from whitespace
+		 */
+		trim: function (str, inside) {
+			if (typeof str === 'string') {
+				str = str.replace(/^\s+|\s+$/g, '');
+
+				// Clear white space insdie the string, like thousands separators
+				if (inside && /^[0-9\s]+$/.test(str)) { 
+					str = str.replace(/\s/g, '');
 				}
-			});
-		}
-	},
-	
-	/**
-	 * Trim a string from whitespace
-	 */
-	trim: function (str, inside) {
-		if (typeof str === 'string') {
-			str = str.replace(/^\s+|\s+$/g, '');
 
-			// Clear white space insdie the string, like thousands separators
-			if (inside && /^[0-9\s]+$/.test(str)) { 
-				str = str.replace(/\s/g, '');
+				if (this.decimalRegex) {
+					str = str.replace(this.decimalRegex, '$1.$2');
+				}
 			}
-
-			if (this.decimalRegex) {
-				str = str.replace(this.decimalRegex, '$1.$2');
+			return str;
+		},
+		
+		/**
+		 * Parse numeric cells in to number types and date types in to true dates.
+		 */
+		parseTypes: function () {
+			var columns = this.columns,
+				col = columns.length;
+
+			while (col--) {
+				this.parseColumn(columns[col], col);
 			}
-		}
-		return str;
-	},
-	
-	/**
-	 * Parse numeric cells in to number types and date types in to true dates.
-	 */
-	parseTypes: function () {
-		var columns = this.columns,
-			col = columns.length;
-
-		while (col--) {
-			this.parseColumn(columns[col], col);
-		}
 
-	},
+		},
 
-	/**
-	 * Parse a single column. Set properties like .isDatetime and .isNumeric.
-	 */
-	parseColumn: function (column, col) {
-		var rawColumns = this.rawColumns,
-			columns = this.columns, 
-			row = column.length,
-			val,
-			floatVal,
-			trimVal,
-			trimInsideVal,
-			firstRowAsNames = this.firstRowAsNames,
-			isXColumn = inArray(col, this.valueCount.xColumns) !== -1,
-			dateVal,
-			backup = [],
-			diff,
-			chartOptions = this.chartOptions,
-			descending,
-			columnTypes = this.options.columnTypes || [],
-			columnType = columnTypes[col],
-			forceCategory = isXColumn && ((chartOptions && chartOptions.xAxis && splat(chartOptions.xAxis)[0].type === 'category') || columnType === 'string');
-		
-		if (!rawColumns[col]) {
-			rawColumns[col] = [];
-		}
-		while (row--) {
-			val = backup[row] || column[row];
+		/**
+		 * Parse a single column. Set properties like .isDatetime and .isNumeric.
+		 */
+		parseColumn: function (column, col) {
+			var rawColumns = this.rawColumns,
+				columns = this.columns, 
+				row = column.length,
+				val,
+				floatVal,
+				trimVal,
+				trimInsideVal,
+				firstRowAsNames = this.firstRowAsNames,
+				isXColumn = inArray(col, this.valueCount.xColumns) !== -1,
+				dateVal,
+				backup = [],
+				diff,
+				chartOptions = this.chartOptions,
+				descending,
+				columnTypes = this.options.columnTypes || [],
+				columnType = columnTypes[col],
+				forceCategory = isXColumn && ((chartOptions && chartOptions.xAxis && splat(chartOptions.xAxis)[0].type === 'category') || columnType === 'string');
 			
-			trimVal = this.trim(val);
-			trimInsideVal = this.trim(val, true);
-			floatVal = parseFloat(trimInsideVal);
-
-			// Set it the first time
-			if (rawColumns[col][row] === undefined) {
-				rawColumns[col][row] = trimVal;
+			if (!rawColumns[col]) {
+				rawColumns[col] = [];
 			}
-			
-			// Disable number or date parsing by setting the X axis type to category
-			if (forceCategory || (row === 0 && firstRowAsNames)) {
-				column[row] = trimVal;
-
-			} else if (+trimInsideVal === floatVal) { // is numeric
-			
-				column[row] = floatVal;
+			while (row--) {
+				val = backup[row] || column[row];
 				
-				// If the number is greater than milliseconds in a year, assume datetime
-				if (floatVal > 365 * 24 * 3600 * 1000 && columnType !== 'float') {
-					column.isDatetime = true;
-				} else {
-					column.isNumeric = true;
-				}
+				trimVal = this.trim(val);
+				trimInsideVal = this.trim(val, true);
+				floatVal = parseFloat(trimInsideVal);
 
-				if (column[row + 1] !== undefined) {
-					descending = floatVal > column[row + 1];
+				// Set it the first time
+				if (rawColumns[col][row] === undefined) {
+					rawColumns[col][row] = trimVal;
 				}
-			
-			// String, continue to determine if it is a date string or really a string
-			} else {
-				dateVal = this.parseDate(val);
-				// Only allow parsing of dates if this column is an x-column
-				if (isXColumn && typeof dateVal === 'number' && !isNaN(dateVal) && columnType !== 'float') { // is date
-					backup[row] = val; 
-					column[row] = dateVal;
-					column.isDatetime = true;
-
-					// Check if the dates are uniformly descending or ascending. If they 
-					// are not, chances are that they are a different time format, so check
-					// for alternative.
+				
+				// Disable number or date parsing by setting the X axis type to category
+				if (forceCategory || (row === 0 && firstRowAsNames)) {
+					column[row] = trimVal;
+
+				} else if (+trimInsideVal === floatVal) { // is numeric
+				
+					column[row] = floatVal;
+					
+					// If the number is greater than milliseconds in a year, assume datetime
+					if (floatVal > 365 * 24 * 3600 * 1000 && columnType !== 'float') {
+						column.isDatetime = true;
+					} else {
+						column.isNumeric = true;
+					}
+
 					if (column[row + 1] !== undefined) {
-						diff = dateVal > column[row + 1];
-						if (diff !== descending && descending !== undefined) {
-							if (this.alternativeFormat) {
-								this.dateFormat = this.alternativeFormat;
-								row = column.length;
-								this.alternativeFormat = this.dateFormats[this.dateFormat].alternative;
-							} else {
-								column.unsorted = true;
-							}
-						}
-						descending = diff;
+						descending = floatVal > column[row + 1];
 					}
 				
-				} else { // string
-					column[row] = trimVal === '' ? null : trimVal;
-					if (row !== 0 && (column.isDatetime || column.isNumeric)) {
-						column.mixed = true;
+				// String, continue to determine if it is a date string or really a string
+				} else {
+					dateVal = this.parseDate(val);
+					// Only allow parsing of dates if this column is an x-column
+					if (isXColumn && typeof dateVal === 'number' && !isNaN(dateVal) && columnType !== 'float') { // is date
+						backup[row] = val; 
+						column[row] = dateVal;
+						column.isDatetime = true;
+
+						// Check if the dates are uniformly descending or ascending. If they 
+						// are not, chances are that they are a different time format, so check
+						// for alternative.
+						if (column[row + 1] !== undefined) {
+							diff = dateVal > column[row + 1];
+							if (diff !== descending && descending !== undefined) {
+								if (this.alternativeFormat) {
+									this.dateFormat = this.alternativeFormat;
+									row = column.length;
+									this.alternativeFormat = this.dateFormats[this.dateFormat].alternative;
+								} else {
+									column.unsorted = true;
+								}
+							}
+							descending = diff;
+						}
+					
+					} else { // string
+						column[row] = trimVal === '' ? null : trimVal;
+						if (row !== 0 && (column.isDatetime || column.isNumeric)) {
+							column.mixed = true;
+						}
 					}
 				}
 			}
-		}
 
-		// If strings are intermixed with numbers or dates in a parsed column, it is an indication
-		// that parsing went wrong or the data was not intended to display as numbers or dates and 
-		// parsing is too aggressive. Fall back to categories. Demonstrated in the 
-		// highcharts/demo/column-drilldown sample.
-		if (isXColumn && column.mixed) {
-			columns[col] = rawColumns[col];
-		}
+			// If strings are intermixed with numbers or dates in a parsed column, it is an indication
+			// that parsing went wrong or the data was not intended to display as numbers or dates and 
+			// parsing is too aggressive. Fall back to categories. Demonstrated in the 
+			// highcharts/demo/column-drilldown sample.
+			if (isXColumn && column.mixed) {
+				columns[col] = rawColumns[col];
+			}
 
-		// If the 0 column is date or number and descending, reverse all columns. 
-		if (isXColumn && descending && this.options.sort) {
-			for (col = 0; col < columns.length; col++) {
-				columns[col].reverse();
-				if (firstRowAsNames) {
-					columns[col].unshift(columns[col].pop());
+			// If the 0 column is date or number and descending, reverse all columns. 
+			if (isXColumn && descending && this.options.sort) {
+				for (col = 0; col < columns.length; col++) {
+					columns[col].reverse();
+					if (firstRowAsNames) {
+						columns[col].unshift(columns[col].pop());
+					}
 				}
 			}
-		}
-	},
-	
-	/**
-	 * A collection of available date formats, extendable from the outside to support
-	 * custom date formats.
-	 */
-	dateFormats: {
-		'YYYY-mm-dd': {
-			regex: /^([0-9]{4})[\-\/\.]([0-9]{2})[\-\/\.]([0-9]{2})$/,
-			parser: function (match) {
-				return Date.UTC(+match[1], match[2] - 1, +match[3]);
-			}
 		},
-		'dd/mm/YYYY': {
-			regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{4})$/,
-			parser: function (match) {
-				return Date.UTC(+match[3], match[2] - 1, +match[1]);
+		
+		/**
+		 * A collection of available date formats, extendable from the outside to support
+		 * custom date formats.
+		 */
+		dateFormats: {
+			'YYYY-mm-dd': {
+				regex: /^([0-9]{4})[\-\/\.]([0-9]{2})[\-\/\.]([0-9]{2})$/,
+				parser: function (match) {
+					return Date.UTC(+match[1], match[2] - 1, +match[3]);
+				}
 			},
-			alternative: 'mm/dd/YYYY' // different format with the same regex
-		},
-		'mm/dd/YYYY': {
-			regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{4})$/,
-			parser: function (match) {
-				return Date.UTC(+match[3], match[1] - 1, +match[2]);
-			}
-		},
-		'dd/mm/YY': {
-			regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{2})$/,
-			parser: function (match) {
-				return Date.UTC(+match[3] + 2000, match[2] - 1, +match[1]);
+			'dd/mm/YYYY': {
+				regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{4})$/,
+				parser: function (match) {
+					return Date.UTC(+match[3], match[2] - 1, +match[1]);
+				},
+				alternative: 'mm/dd/YYYY' // different format with the same regex
 			},
-			alternative: 'mm/dd/YY' // different format with the same regex
-		},
-		'mm/dd/YY': {
-			regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{2})$/,
-			parser: function (match) {
-				return Date.UTC(+match[3] + 2000, match[1] - 1, +match[2]);
+			'mm/dd/YYYY': {
+				regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{4})$/,
+				parser: function (match) {
+					return Date.UTC(+match[3], match[1] - 1, +match[2]);
+				}
+			},
+			'dd/mm/YY': {
+				regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{2})$/,
+				parser: function (match) {
+					return Date.UTC(+match[3] + 2000, match[2] - 1, +match[1]);
+				},
+				alternative: 'mm/dd/YY' // different format with the same regex
+			},
+			'mm/dd/YY': {
+				regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{2})$/,
+				parser: function (match) {
+					return Date.UTC(+match[3] + 2000, match[1] - 1, +match[2]);
+				}
 			}
-		}
-	},
-	
-	/**
-	 * Parse a date and return it as a number. Overridable through options.parseDate.
-	 */
-	parseDate: function (val) {
-		var parseDate = this.options.parseDate,
-			ret,
-			key,
-			format,
-			dateFormat = this.options.dateFormat || this.dateFormat,
-			match;
-
-		if (parseDate) {
-			ret = parseDate(val);
+		},
 		
-		} else if (typeof val === 'string') {
-			// Auto-detect the date format the first time
-			if (!dateFormat) {
-				for (key in this.dateFormats) {
-					format = this.dateFormats[key];
+		/**
+		 * Parse a date and return it as a number. Overridable through options.parseDate.
+		 */
+		parseDate: function (val) {
+			var parseDate = this.options.parseDate,
+				ret,
+				key,
+				format,
+				dateFormat = this.options.dateFormat || this.dateFormat,
+				match;
+
+			if (parseDate) {
+				ret = parseDate(val);
+			
+			} else if (typeof val === 'string') {
+				// Auto-detect the date format the first time
+				if (!dateFormat) {
+					for (key in this.dateFormats) {
+						format = this.dateFormats[key];
+						match = val.match(format.regex);
+						if (match) {
+							this.dateFormat = dateFormat = key;
+							this.alternativeFormat = format.alternative;
+							ret = format.parser(match);
+							break;
+						}
+					}
+				// Next time, use the one previously found
+				} else {
+					format = this.dateFormats[dateFormat];
 					match = val.match(format.regex);
 					if (match) {
-						this.dateFormat = dateFormat = key;
-						this.alternativeFormat = format.alternative;
 						ret = format.parser(match);
-						break;
 					}
 				}
-			// Next time, use the one previously found
-			} else {
-				format = this.dateFormats[dateFormat];
-				match = val.match(format.regex);
-				if (match) {
-					ret = format.parser(match);
-				}
-			}
-			// Fall back to Date.parse		
-			if (!match) {
-				match = Date.parse(val);
-				// External tools like Date.js and MooTools extend Date object and
-				// returns a date.
-				if (typeof match === 'object' && match !== null && match.getTime) {
-					ret = match.getTime() - match.getTimezoneOffset() * 60000;
-				
-				// Timestamp
-				} else if (typeof match === 'number' && !isNaN(match)) {
-					ret = match - (new Date(match)).getTimezoneOffset() * 60000;
+				// Fall back to Date.parse		
+				if (!match) {
+					match = Date.parse(val);
+					// External tools like Date.js and MooTools extend Date object and
+					// returns a date.
+					if (typeof match === 'object' && match !== null && match.getTime) {
+						ret = match.getTime() - match.getTimezoneOffset() * 60000;
+					
+					// Timestamp
+					} else if (typeof match === 'number' && !isNaN(match)) {
+						ret = match - (new Date(match)).getTimezoneOffset() * 60000;
+					}
 				}
 			}
-		}
-		return ret;
-	},
-	
-	/**
-	 * Reorganize rows into columns
-	 */
-	rowsToColumns: function (rows) {
-		var row,
-			rowsLength,
-			col,
-			colsLength,
-			columns;
-
-		if (rows) {
-			columns = [];
-			rowsLength = rows.length;
-			for (row = 0; row < rowsLength; row++) {
-				colsLength = rows[row].length;
-				for (col = 0; col < colsLength; col++) {
-					if (!columns[col]) {
-						columns[col] = [];
+			return ret;
+		},
+		
+		/**
+		 * Reorganize rows into columns
+		 */
+		rowsToColumns: function (rows) {
+			var row,
+				rowsLength,
+				col,
+				colsLength,
+				columns;
+
+			if (rows) {
+				columns = [];
+				rowsLength = rows.length;
+				for (row = 0; row < rowsLength; row++) {
+					colsLength = rows[row].length;
+					for (col = 0; col < colsLength; col++) {
+						if (!columns[col]) {
+							columns[col] = [];
+						}
+						columns[col][row] = rows[row][col];
 					}
-					columns[col][row] = rows[row][col];
 				}
 			}
-		}
-		return columns;
-	},
-	
-	/**
-	 * A hook for working directly on the parsed columns
-	 */
-	parsed: function () {
-		if (this.options.parsed) {
-			return this.options.parsed.call(this, this.columns);
-		}
-	},
-
-	getFreeIndexes: function (numberOfColumns, seriesBuilders) {
-		var s,
-			i,
-			freeIndexes = [],
-			freeIndexValues = [],
-			referencedIndexes;
-
-		// Add all columns as free
-		for (i = 0; i < numberOfColumns; i = i + 1) {
-			freeIndexes.push(true);
-		}
+			return columns;
+		},
+		
+		/**
+		 * A hook for working directly on the parsed columns
+		 */
+		parsed: function () {
+			if (this.options.parsed) {
+				return this.options.parsed.call(this, this.columns);
+			}
+		},
 
-		// Loop all defined builders and remove their referenced columns
-		for (s = 0; s < seriesBuilders.length; s = s + 1) {
-			referencedIndexes = seriesBuilders[s].getReferencedColumnIndexes();
+		getFreeIndexes: function (numberOfColumns, seriesBuilders) {
+			var s,
+				i,
+				freeIndexes = [],
+				freeIndexValues = [],
+				referencedIndexes;
 
-			for (i = 0; i < referencedIndexes.length; i = i + 1) {
-				freeIndexes[referencedIndexes[i]] = false;
+			// Add all columns as free
+			for (i = 0; i < numberOfColumns; i = i + 1) {
+				freeIndexes.push(true);
 			}
-		}
 
-		// Collect the values for the free indexes
-		for (i = 0; i < freeIndexes.length; i = i + 1) {
-			if (freeIndexes[i]) {
-				freeIndexValues.push(i);
-			}
-		}
+			// Loop all defined builders and remove their referenced columns
+			for (s = 0; s < seriesBuilders.length; s = s + 1) {
+				referencedIndexes = seriesBuilders[s].getReferencedColumnIndexes();
 
-		return freeIndexValues;
-	},
-	
-	/**
-	 * If a complete callback function is provided in the options, interpret the 
-	 * columns into a Highcharts options object.
-	 */
-	complete: function () {
-		
-		var columns = this.columns,
-			xColumns = [],
-			type,
-			options = this.options,
-			series,
-			data,
-			i,
-			j,
-			r,
-			seriesIndex,
-			chartOptions,
-			allSeriesBuilders = [],
-			builder,
-			freeIndexes,
-			typeCol,
-			index;
-
-		xColumns.length = columns.length;
-		if (options.complete || options.afterComplete) {
-
-			// Get the names and shift the top row
-			for (i = 0; i < columns.length; i++) {
-				if (this.firstRowAsNames) {
-					columns[i].name = columns[i].shift();
+				for (i = 0; i < referencedIndexes.length; i = i + 1) {
+					freeIndexes[referencedIndexes[i]] = false;
 				}
 			}
-			
-			// Use the next columns for series
-			series = [];
-			freeIndexes = this.getFreeIndexes(columns.length, this.valueCount.seriesBuilders);
 
-			// Populate defined series
-			for (seriesIndex = 0; seriesIndex < this.valueCount.seriesBuilders.length; seriesIndex++) {
-				builder = this.valueCount.seriesBuilders[seriesIndex];
-
-				// If the builder can be populated with remaining columns, then add it to allBuilders
-				if (builder.populateColumns(freeIndexes)) {
-					allSeriesBuilders.push(builder);
+			// Collect the values for the free indexes
+			for (i = 0; i < freeIndexes.length; i = i + 1) {
+				if (freeIndexes[i]) {
+					freeIndexValues.push(i);
 				}
 			}
 
-			// Populate dynamic series
-			while (freeIndexes.length > 0) {
-				builder = new SeriesBuilder();
-				builder.addColumnReader(0, 'x');
-				
-				// Mark index as used (not free)
-				index = inArray(0, freeIndexes);
-				if (index !== -1) {
-					freeIndexes.splice(index, 1);
+			return freeIndexValues;
+		},
+		
+		/**
+		 * If a complete callback function is provided in the options, interpret the 
+		 * columns into a Highcharts options object.
+		 */
+		complete: function () {
+			
+			var columns = this.columns,
+				xColumns = [],
+				type,
+				options = this.options,
+				series,
+				data,
+				i,
+				j,
+				r,
+				seriesIndex,
+				chartOptions,
+				allSeriesBuilders = [],
+				builder,
+				freeIndexes,
+				typeCol,
+				index;
+
+			xColumns.length = columns.length;
+			if (options.complete || options.afterComplete) {
+
+				// Get the names and shift the top row
+				for (i = 0; i < columns.length; i++) {
+					if (this.firstRowAsNames) {
+						columns[i].name = columns[i].shift();
+					}
 				}
+				
+				// Use the next columns for series
+				series = [];
+				freeIndexes = this.getFreeIndexes(columns.length, this.valueCount.seriesBuilders);
 
-				for (i = 0; i < this.valueCount.global; i++) {
-					// Create and add a column reader for the next free column index
-					builder.addColumnReader(undefined, this.valueCount.globalPointArrayMap[i]);
+				// Populate defined series
+				for (seriesIndex = 0; seriesIndex < this.valueCount.seriesBuilders.length; seriesIndex++) {
+					builder = this.valueCount.seriesBuilders[seriesIndex];
+
+					// If the builder can be populated with remaining columns, then add it to allBuilders
+					if (builder.populateColumns(freeIndexes)) {
+						allSeriesBuilders.push(builder);
+					}
 				}
 
-				// If the builder can be populated with remaining columns, then add it to allBuilders
-				if (builder.populateColumns(freeIndexes)) {
-					allSeriesBuilders.push(builder);
+				// Populate dynamic series
+				while (freeIndexes.length > 0) {
+					builder = new SeriesBuilder();
+					builder.addColumnReader(0, 'x');
+					
+					// Mark index as used (not free)
+					index = inArray(0, freeIndexes);
+					if (index !== -1) {
+						freeIndexes.splice(index, 1);
+					}
+
+					for (i = 0; i < this.valueCount.global; i++) {
+						// Create and add a column reader for the next free column index
+						builder.addColumnReader(undefined, this.valueCount.globalPointArrayMap[i]);
+					}
+
+					// If the builder can be populated with remaining columns, then add it to allBuilders
+					if (builder.populateColumns(freeIndexes)) {
+						allSeriesBuilders.push(builder);
+					}
 				}
-			}
 
-			// Get the data-type from the first series x column
-			if (allSeriesBuilders.length > 0 && allSeriesBuilders[0].readers.length > 0) {
-				typeCol = columns[allSeriesBuilders[0].readers[0].columnIndex];
-				if (typeCol !== undefined) {
-					if (typeCol.isDatetime) {
-						type = 'datetime';
-					} else if (!typeCol.isNumeric) {
-						type = 'category';
+				// Get the data-type from the first series x column
+				if (allSeriesBuilders.length > 0 && allSeriesBuilders[0].readers.length > 0) {
+					typeCol = columns[allSeriesBuilders[0].readers[0].columnIndex];
+					if (typeCol !== undefined) {
+						if (typeCol.isDatetime) {
+							type = 'datetime';
+						} else if (!typeCol.isNumeric) {
+							type = 'category';
+						}
 					}
 				}
-			}
-			// Axis type is category, then the "x" column should be called "name"
-			if (type === 'category') {
-				for (seriesIndex = 0; seriesIndex < allSeriesBuilders.length; seriesIndex++) {
-					builder = allSeriesBuilders[seriesIndex];
-					for (r = 0; r < builder.readers.length; r++) {
-						if (builder.readers[r].configName === 'x') {
-							builder.readers[r].configName = 'name';
+				// Axis type is category, then the "x" column should be called "name"
+				if (type === 'category') {
+					for (seriesIndex = 0; seriesIndex < allSeriesBuilders.length; seriesIndex++) {
+						builder = allSeriesBuilders[seriesIndex];
+						for (r = 0; r < builder.readers.length; r++) {
+							if (builder.readers[r].configName === 'x') {
+								builder.readers[r].configName = 'name';
+							}
 						}
 					}
 				}
-			}
 
-			// Read data for all builders
-			for (seriesIndex = 0; seriesIndex < allSeriesBuilders.length; seriesIndex++) {
-				builder = allSeriesBuilders[seriesIndex];
+				// Read data for all builders
+				for (seriesIndex = 0; seriesIndex < allSeriesBuilders.length; seriesIndex++) {
+					builder = allSeriesBuilders[seriesIndex];
 
-				// Iterate down the cells of each column and add data to the series
-				data = [];
-				for (j = 0; j < columns[0].length; j++) { // TODO: which column's length should we use here
-					data[j] = builder.read(columns, j);
-				}
+					// Iterate down the cells of each column and add data to the series
+					data = [];
+					for (j = 0; j < columns[0].length; j++) {
+						data[j] = builder.read(columns, j);
+					}
 
-				// Add the series
-				series[seriesIndex] = {
-					data: data
-				};
-				if (builder.name) {
-					series[seriesIndex].name = builder.name;
-				}
-				if (type === 'category') {
-					series[seriesIndex].turboThreshold = 0;
+					// Add the series
+					series[seriesIndex] = {
+						data: data
+					};
+					if (builder.name) {
+						series[seriesIndex].name = builder.name;
+					}
+					if (type === 'category') {
+						series[seriesIndex].turboThreshold = 0;
+					}
 				}
-			}
 
 
 
-			// Do the callback
-			chartOptions = {
-				series: series
-			};
-			if (type) {
-				chartOptions.xAxis = {
-					type: type
+				// Do the callback
+				chartOptions = {
+					series: series
 				};
-			}
-			
-			if (options.complete) {
-				options.complete(chartOptions);
-			}
+				if (type) {
+					chartOptions.xAxis = {
+						type: type
+					};
+				}
+				
+				if (options.complete) {
+					options.complete(chartOptions);
+				}
 
-			// The afterComplete hook is used internally to avoid conflict with the externally
-			// available complete option.
-			if (options.afterComplete) {
-				options.afterComplete(chartOptions);
+				// The afterComplete hook is used internally to avoid conflict with the externally
+				// available complete option.
+				if (options.afterComplete) {
+					options.afterComplete(chartOptions);
+				}
 			}
 		}
-	}
 	});
 	
 	// Register the Data prototype and data function on Highcharts
@@ -950,4 +954,4 @@
 
 
 
-}(Highcharts));
+}));