ps-toolkit-ui 0.0.209 → 0.0.210

package/src/assets/plugins/highcharts/code/modules/data.src.js

@@ -0,0 +1,2383 @@
+/**
+ * @license Highcharts JS v9.3.3 (2022-02-01)
+ *
+ * Data module
+ *
+ * (c) 2012-2021 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+(function (factory) {
+    if (typeof module === 'object' && module.exports) {
+        factory['default'] = factory;
+        module.exports = factory;
+    } else if (typeof define === 'function' && define.amd) {
+        define('highcharts/modules/data', ['highcharts'], function (Highcharts) {
+            factory(Highcharts);
+            factory.Highcharts = Highcharts;
+            return factory;
+        });
+    } else {
+        factory(typeof Highcharts !== 'undefined' ? Highcharts : undefined);
+    }
+}(function (Highcharts) {
+    var _modules = Highcharts ? Highcharts._modules : {};
+    function _registerModule(obj, path, args, fn) {
+        if (!obj.hasOwnProperty(path)) {
+            obj[path] = fn.apply(null, args);
+        }
+    }
+    _registerModule(_modules, 'Core/HttpUtilities.js', [_modules['Core/Globals.js'], _modules['Core/Utilities.js']], function (G, U) {
+        /* *
+         *
+         *  (c) 2010-2021 Christer Vasseng, Torstein Honsi
+         *
+         *  License: www.highcharts.com/license
+         *
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+         *
+         * */
+        var doc = G.doc;
+        var createElement = U.createElement,
+            discardElement = U.discardElement,
+            merge = U.merge,
+            objectEach = U.objectEach;
+        /**
+         * Perform an Ajax call.
+         *
+         * @function Highcharts.ajax
+         *
+         * @param {Partial<Highcharts.AjaxSettingsObject>} attr
+         *        The Ajax settings to use.
+         *
+         * @return {false|undefined}
+         *         Returns false, if error occured.
+         */
+        function ajax(attr) {
+            var options = merge(true, {
+                    url: false,
+                    type: 'get',
+                    dataType: 'json',
+                    success: false,
+                    error: false,
+                    data: false,
+                    headers: {}
+                },
+                attr),
+                headers = {
+                    json: 'application/json',
+                    xml: 'application/xml',
+                    text: 'text/plain',
+                    octet: 'application/octet-stream'
+                },
+                r = new XMLHttpRequest();
+            /**
+             * @private
+             * @param {XMLHttpRequest} xhr
+             * Internal request object.
+             * @param {string|Error} err
+             * Occured error.
+             */
+            function handleError(xhr, err) {
+                if (options.error) {
+                    options.error(xhr, err);
+                }
+                else {
+                    // @todo Maybe emit a highcharts error event here
+                }
+            }
+            if (!options.url) {
+                return false;
+            }
+            r.open(options.type.toUpperCase(), options.url, true);
+            if (!options.headers['Content-Type']) {
+                r.setRequestHeader('Content-Type', headers[options.dataType] || headers.text);
+            }
+            objectEach(options.headers, function (val, key) {
+                r.setRequestHeader(key, val);
+            });
+            // @todo lacking timeout handling
+            r.onreadystatechange = function () {
+                var res;
+                if (r.readyState === 4) {
+                    if (r.status === 200) {
+                        res = r.responseText;
+                        if (options.dataType === 'json') {
+                            try {
+                                res = JSON.parse(res);
+                            }
+                            catch (e) {
+                                return handleError(r, e);
+                            }
+                        }
+                        return options.success && options.success(res);
+                    }
+                    handleError(r, r.responseText);
+                }
+            };
+            try {
+                options.data = JSON.stringify(options.data);
+            }
+            catch (e) {
+                // empty
+            }
+            r.send(options.data || true);
+        }
+        /**
+         * Get a JSON resource over XHR, also supporting CORS without preflight.
+         *
+         * @function Highcharts.getJSON
+         * @param {string} url
+         *        The URL to load.
+         * @param {Function} success
+         *        The success callback. For error handling, use the `Highcharts.ajax`
+         *        function instead.
+         */
+        function getJSON(url, success) {
+            HttpUtilities.ajax({
+                url: url,
+                success: success,
+                dataType: 'json',
+                headers: {
+                    // Override the Content-Type to avoid preflight problems with CORS
+                    // in the Highcharts demos
+                    'Content-Type': 'text/plain'
+                }
+            });
+        }
+        /**
+         * The post utility
+         *
+         * @private
+         * @function Highcharts.post
+         *
+         * @param {string} url
+         * Post URL
+         *
+         * @param {Object} data
+         * Post data
+         *
+         * @param {Highcharts.Dictionary<string>} [formAttributes]
+         * Additional attributes for the post request
+         */
+        function post(url, data, formAttributes) {
+            // create the form
+            var form = createElement('form',
+                merge({
+                    method: 'post',
+                    action: url,
+                    enctype: 'multipart/form-data'
+                },
+                formAttributes), {
+                    display: 'none'
+                },
+                doc.body);
+            // add the data
+            objectEach(data, function (val, name) {
+                createElement('input', {
+                    type: 'hidden',
+                    name: name,
+                    value: val
+                }, null, form);
+            });
+            // submit
+            form.submit();
+            // clean up
+            discardElement(form);
+        }
+        /* *
+         *
+         *  Default Export
+         *
+         * */
+        var HttpUtilities = {
+                ajax: ajax,
+                getJSON: getJSON,
+                post: post
+            };
+        /**
+         * @interface Highcharts.AjaxSettingsObject
+         */ /**
+        * The payload to send.
+        *
+        * @name Highcharts.AjaxSettingsObject#data
+        * @type {string|Highcharts.Dictionary<any>}
+        */ /**
+        * The data type expected.
+        * @name Highcharts.AjaxSettingsObject#dataType
+        * @type {"json"|"xml"|"text"|"octet"}
+        */ /**
+        * Function to call on error.
+        * @name Highcharts.AjaxSettingsObject#error
+        * @type {Function}
+        */ /**
+        * The headers; keyed on header name.
+        * @name Highcharts.AjaxSettingsObject#headers
+        * @type {Highcharts.Dictionary<string>}
+        */ /**
+        * Function to call on success.
+        * @name Highcharts.AjaxSettingsObject#success
+        * @type {Function}
+        */ /**
+        * The HTTP method to use. For example GET or POST.
+        * @name Highcharts.AjaxSettingsObject#type
+        * @type {string}
+        */ /**
+        * The URL to call.
+        * @name Highcharts.AjaxSettingsObject#url
+        * @type {string}
+        */
+        (''); // keeps doclets above in JS file
+
+        return HttpUtilities;
+    });
+    _registerModule(_modules, 'Extensions/Data.js', [_modules['Core/Chart/Chart.js'], _modules['Core/Globals.js'], _modules['Core/HttpUtilities.js'], _modules['Core/Series/Point.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Core/Utilities.js']], function (Chart, G, HU, Point, SeriesRegistry, U) {
+        /* *
+         *
+         *  Data module
+         *
+         *  (c) 2012-2021 Torstein Honsi
+         *
+         *  License: www.highcharts.com/license
+         *
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+         *
+         * */
+        var doc = G.doc;
+        var ajax = HU.ajax;
+        var seriesTypes = SeriesRegistry.seriesTypes;
+        var addEvent = U.addEvent,
+            defined = U.defined,
+            extend = U.extend,
+            fireEvent = U.fireEvent,
+            isNumber = U.isNumber,
+            merge = U.merge,
+            objectEach = U.objectEach,
+            pick = U.pick,
+            splat = U.splat;
+        /**
+         * Callback function to modify the CSV before parsing it by the data module.
+         *
+         * @callback Highcharts.DataBeforeParseCallbackFunction
+         *
+         * @param {string} csv
+         *        The CSV to modify.
+         *
+         * @return {string}
+         *         The CSV to parse.
+         */
+        /**
+         * Callback function that gets called after parsing data.
+         *
+         * @callback Highcharts.DataCompleteCallbackFunction
+         *
+         * @param {Highcharts.Options} chartOptions
+         *        The chart options that were used.
+         */
+        /**
+         * Callback function that returns the correspondig Date object to a match.
+         *
+         * @callback Highcharts.DataDateFormatCallbackFunction
+         *
+         * @param {Array<number>} match
+         *
+         * @return {number}
+         */
+        /**
+         * Structure for alternative date formats to parse.
+         *
+         * @interface Highcharts.DataDateFormatObject
+         */ /**
+        * @name Highcharts.DataDateFormatObject#alternative
+        * @type {string|undefined}
+        */ /**
+        * @name Highcharts.DataDateFormatObject#parser
+        * @type {Highcharts.DataDateFormatCallbackFunction}
+        */ /**
+        * @name Highcharts.DataDateFormatObject#regex
+        * @type {global.RegExp}
+        */
+        /**
+         * Possible types for a data item in a column or row.
+         *
+         * @typedef {number|string|null} Highcharts.DataValueType
+         */
+        /**
+         * Callback function to parse string representations of dates into
+         * JavaScript timestamps (milliseconds since 1.1.1970).
+         *
+         * @callback Highcharts.DataParseDateCallbackFunction
+         *
+         * @param {string} dateValue
+         *
+         * @return {number}
+         *         Timestamp (milliseconds since 1.1.1970) as integer for Date class.
+         */
+        /**
+         * Callback function to access the parsed columns, the two-dimentional
+         * input data array directly, before they are interpreted into series
+         * data and categories.
+         *
+         * @callback Highcharts.DataParsedCallbackFunction
+         *
+         * @param {Array<Array<*>>} columns
+         *        The parsed columns by the data module.
+         *
+         * @return {boolean|undefined}
+         *         Return `false` to stop completion, or call `this.complete()` to
+         *         continue async.
+         */
+        /**
+         * The Data module provides a simplified interface for adding data to
+         * a chart from sources like CVS, HTML tables or grid views. See also
+         * the [tutorial article on the Data module](
+         * https://www.highcharts.com/docs/working-with-data/data-module).
+         *
+         * It requires the `modules/data.js` file to be loaded.
+         *
+         * Please note that the default way of adding data in Highcharts, without
+         * the need of a module, is through the [series._type_.data](#series.line.data)
+         * option.
+         *
+         * @sample {highcharts} highcharts/demo/column-parsed/
+         *         HTML table
+         * @sample {highcharts} highcharts/data/csv/
+         *         CSV
+         *
+         * @since     4.0
+         * @requires  modules/data
+         * @apioption data
+         */
+        /**
+         * A callback function to modify the CSV before parsing it. Return the modified
+         * string.
+         *
+         * @sample {highcharts} highcharts/demo/line-ajax/
+         *         Modify CSV before parse
+         *
+         * @type      {Highcharts.DataBeforeParseCallbackFunction}
+         * @since     6.1
+         * @apioption data.beforeParse
+         */
+        /**
+         * A two-dimensional array representing the input data on tabular form.
+         * This input can be used when the data is already parsed, for example
+         * from a grid view component. Each cell can be a string or number.
+         * If not switchRowsAndColumns is set, the columns are interpreted as
+         * series.
+         *
+         * @see [data.rows](#data.rows)
+         *
+         * @sample {highcharts} highcharts/data/columns/
+         *         Columns
+         *
+         * @type      {Array<Array<Highcharts.DataValueType>>}
+         * @since     4.0
+         * @apioption data.columns
+         */
+        /**
+         * The callback that is evaluated when the data is finished loading,
+         * optionally from an external source, and parsed. The first argument
+         * passed is a finished chart options object, containing the series.
+         * These options can be extended with additional options and passed
+         * directly to the chart constructor.
+         *
+         * @see [data.parsed](#data.parsed)
+         *
+         * @sample {highcharts} highcharts/data/complete/
+         *         Modify data on complete
+         *
+         * @type      {Highcharts.DataCompleteCallbackFunction}
+         * @since     4.0
+         * @apioption data.complete
+         */
+        /**
+         * A comma delimited string to be parsed. Related options are [startRow](
+         * #data.startRow), [endRow](#data.endRow), [startColumn](#data.startColumn)
+         * and [endColumn](#data.endColumn) to delimit what part of the table
+         * is used. The [lineDelimiter](#data.lineDelimiter) and [itemDelimiter](
+         * #data.itemDelimiter) options define the CSV delimiter formats.
+         *
+         * The built-in CSV parser doesn't support all flavours of CSV, so in
+         * some cases it may be necessary to use an external CSV parser. See
+         * [this example](https://jsfiddle.net/highcharts/u59176h4/) of parsing
+         * CSV through the MIT licensed [Papa Parse](http://papaparse.com/)
+         * library.
+         *
+         * @sample {highcharts} highcharts/data/csv/
+         *         Data from CSV
+         *
+         * @type      {string}
+         * @since     4.0
+         * @apioption data.csv
+         */
+        /**
+         * Which of the predefined date formats in Date.prototype.dateFormats
+         * to use to parse date values. Defaults to a best guess based on what
+         * format gives valid and ordered dates. Valid options include: `YYYY/mm/dd`,
+         * `dd/mm/YYYY`, `mm/dd/YYYY`, `dd/mm/YY`, `mm/dd/YY`.
+         *
+         * @see [data.parseDate](#data.parseDate)
+         *
+         * @sample {highcharts} highcharts/data/dateformat-auto/
+         *         Best guess date format
+         *
+         * @type       {string}
+         * @since      4.0
+         * @validvalue ["YYYY/mm/dd", "dd/mm/YYYY", "mm/dd/YYYY", "dd/mm/YYYY",
+         *             "dd/mm/YY", "mm/dd/YY"]
+         * @apioption  data.dateFormat
+         */
+        /**
+         * The decimal point used for parsing numbers in the CSV.
+         *
+         * If both this and data.delimiter is set to `undefined`, the parser will
+         * attempt to deduce the decimal point automatically.
+         *
+         * @sample {highcharts} highcharts/data/delimiters/
+         *         Comma as decimal point
+         *
+         * @type      {string}
+         * @default   .
+         * @since     4.1.0
+         * @apioption data.decimalPoint
+         */
+        /**
+         * In tabular input data, the last column (indexed by 0) to use. Defaults
+         * to the last column containing data.
+         *
+         * @sample {highcharts} highcharts/data/start-end/
+         *         Limited data
+         *
+         * @type      {number}
+         * @since     4.0
+         * @apioption data.endColumn
+         */
+        /**
+         * In tabular input data, the last row (indexed by 0) to use. Defaults
+         * to the last row containing data.
+         *
+         * @sample {highcharts} highcharts/data/start-end/
+         *         Limited data
+         *
+         * @type      {number}
+         * @since     4.0.4
+         * @apioption data.endRow
+         */
+        /**
+         * Whether to use the first row in the data set as series names.
+         *
+         * @sample {highcharts} highcharts/data/start-end/
+         *         Don't get series names from the CSV
+         * @sample {highstock} highcharts/data/start-end/
+         *         Don't get series names from the CSV
+         *
+         * @type      {boolean}
+         * @default   true
+         * @since     4.1.0
+         * @product   highcharts highstock gantt
+         * @apioption data.firstRowAsNames
+         */
+        /**
+         * The Google Spreadsheet API key required for access generated at [API Services
+         * / Credentials](https://console.cloud.google.com/apis/credentials). See a
+         * comprehensive tutorial for setting up the key at the
+         * [Hands-On Data Visualization](https://handsondataviz.org/google-sheets-api-key.html)
+         * book website.
+         *
+         * @sample {highcharts} highcharts/data/google-spreadsheet/
+         *         Load a Google Spreadsheet
+         *
+         * @type      {string}
+         * @since     9.2.2
+         * @apioption data.googleAPIKey
+         */
+        /**
+         * The key or `spreadsheetId` value for a Google Spreadsheet to load. See
+         * [developers.google.com](https://developers.google.com/sheets/api/guides/concepts)
+         * for how to find the `spreadsheetId`.
+         *
+         * In order for Google Sheets to load, a valid [googleAPIKey](#data.googleAPIKey)
+         * must also be given.
+         *
+         * @sample {highcharts} highcharts/data/google-spreadsheet/
+         *         Load a Google Spreadsheet
+         *
+         * @type      {string}
+         * @since     4.0
+         * @apioption data.googleSpreadsheetKey
+         */
+        /**
+         * The Google Spreadsheet `range` to use in combination with
+         * [googleSpreadsheetKey](#data.googleSpreadsheetKey). See
+         * [developers.google.com](https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets.values/get)
+         * for details.
+         *
+         * If given, it takes precedence over `startColumn`, `endColumn`, `startRow` and
+         * `endRow`.
+         *
+         * @example
+         * googleSpreadsheetRange: 'Fruit Consumption' // Load a named worksheet
+         * googleSpreadsheetRange: 'A:Z' // Load columns A to Z
+         *
+         * @sample {highcharts} highcharts/data/google-spreadsheet/
+         *         Load a Google Spreadsheet
+         *
+         * @type      {string|undefined}
+         * @since     9.2.2
+         * @apioption data.googleSpreadsheetRange
+         */
+        /**
+         * No longer works since v9.2.2, that uses Google Sheets API v4. Instead, use
+         * the [googleSpreadsheetRange](#data.googleSpreadsheetRange) option to load a
+         * specific sheet.
+         *
+         * @deprecated
+         * @type      {string}
+         * @since     4.0
+         * @apioption data.googleSpreadsheetWorksheet
+         */
+        /**
+         * Item or cell delimiter for parsing CSV. Defaults to the tab character
+         * `\t` if a tab character is found in the CSV string, if not it defaults
+         * to `,`.
+         *
+         * If this is set to false or undefined, the parser will attempt to deduce
+         * the delimiter automatically.
+         *
+         * @sample {highcharts} highcharts/data/delimiters/
+         *         Delimiters
+         *
+         * @type      {string}
+         * @since     4.0
+         * @apioption data.itemDelimiter
+         */
+        /**
+         * Line delimiter for parsing CSV.
+         *
+         * @sample {highcharts} highcharts/data/delimiters/
+         *         Delimiters
+         *
+         * @type      {string}
+         * @default   \n
+         * @since     4.0
+         * @apioption data.lineDelimiter
+         */
+        /**
+         * A callback function to access the parsed columns, the two-dimentional
+         * input data array directly, before they are interpreted into series
+         * data and categories. Return `false` to stop completion, or call
+         * `this.complete()` to continue async.
+         *
+         * @see [data.complete](#data.complete)
+         *
+         * @sample {highcharts} highcharts/data/parsed/
+         *         Modify data after parse
+         *
+         * @type      {Highcharts.DataParsedCallbackFunction}
+         * @since     4.0
+         * @apioption data.parsed
+         */
+        /**
+         * A callback function to parse string representations of dates into
+         * JavaScript timestamps. Should return an integer timestamp on success.
+         *
+         * @see [dateFormat](#data.dateFormat)
+         *
+         * @type      {Highcharts.DataParseDateCallbackFunction}
+         * @since     4.0
+         * @apioption data.parseDate
+         */
+        /**
+         * The same as the columns input option, but defining rows intead of
+         * columns.
+         *
+         * @see [data.columns](#data.columns)
+         *
+         * @sample {highcharts} highcharts/data/rows/
+         *         Data in rows
+         *
+         * @type      {Array<Array<Highcharts.DataValueType>>}
+         * @since     4.0
+         * @apioption data.rows
+         */
+        /**
+         * An array containing dictionaries for each series. A dictionary exists of
+         * Point property names as the key and the CSV column index as the value.
+         *
+         * @sample {highcharts} highcharts/data/seriesmapping-label/
+         *         Label from data set
+         *
+         * @type      {Array<Highcharts.Dictionary<number>>}
+         * @since     4.0.4
+         * @apioption data.seriesMapping
+         */
+        /**
+         * In tabular input data, the first column (indexed by 0) to use.
+         *
+         * @sample {highcharts} highcharts/data/start-end/
+         *         Limited data
+         *
+         * @type      {number}
+         * @default   0
+         * @since     4.0
+         * @apioption data.startColumn
+         */
+        /**
+         * In tabular input data, the first row (indexed by 0) to use.
+         *
+         * @sample {highcharts} highcharts/data/start-end/
+         *         Limited data
+         *
+         * @type      {number}
+         * @default   0
+         * @since     4.0
+         * @apioption data.startRow
+         */
+        /**
+         * Switch rows and columns of the input data, so that `this.columns`
+         * effectively becomes the rows of the data set, and the rows are interpreted
+         * as series.
+         *
+         * @sample {highcharts} highcharts/data/switchrowsandcolumns/
+         *         Switch rows and columns
+         *
+         * @type      {boolean}
+         * @default   false
+         * @since     4.0
+         * @apioption data.switchRowsAndColumns
+         */
+        /**
+         * An HTML table or the id of such to be parsed as input data. Related
+         * options are `startRow`, `endRow`, `startColumn` and `endColumn` to
+         * delimit what part of the table is used.
+         *
+         * @sample {highcharts} highcharts/demo/column-parsed/
+         *         Parsed table
+         *
+         * @type      {string|global.HTMLElement}
+         * @since     4.0
+         * @apioption data.table
+         */
+        /**
+         * An URL to a remote CSV dataset. Will be fetched when the chart is created
+         * using Ajax.
+         *
+         * @sample highcharts/data/livedata-columns
+         *         Categorized bar chart with CSV and live polling
+         * @sample highcharts/data/livedata-csv
+         *         Time based line chart with CSV and live polling
+         *
+         * @type      {string}
+         * @apioption data.csvURL
+         */
+        /**
+         * A URL to a remote JSON dataset, structured as a row array.
+         * Will be fetched when the chart is created using Ajax.
+         *
+         * @sample highcharts/data/livedata-rows
+         *         Rows with live polling
+         *
+         * @type      {string}
+         * @apioption data.rowsURL
+         */
+        /**
+         * A URL to a remote JSON dataset, structured as a column array.
+         * Will be fetched when the chart is created using Ajax.
+         *
+         * @sample highcharts/data/livedata-columns
+         *         Columns with live polling
+         *
+         * @type      {string}
+         * @apioption data.columnsURL
+         */
+        /**
+         * Sets the refresh rate for data polling when importing remote dataset by
+         * setting [data.csvURL](data.csvURL), [data.rowsURL](data.rowsURL),
+         * [data.columnsURL](data.columnsURL), or
+         * [data.googleSpreadsheetKey](data.googleSpreadsheetKey).
+         *
+         * Note that polling must be enabled by setting
+         * [data.enablePolling](data.enablePolling) to true.
+         *
+         * The value is the number of seconds between pollings.
+         * It cannot be set to less than 1 second.
+         *
+         * @sample highcharts/demo/live-data
+         *         Live data with user set refresh rate
+         *
+         * @default   1
+         * @type      {number}
+         * @apioption data.dataRefreshRate
+         */
+        /**
+         * Enables automatic refetching of remote datasets every _n_ seconds (defined by
+         * setting [data.dataRefreshRate](data.dataRefreshRate)).
+         *
+         * Only works when either [data.csvURL](data.csvURL),
+         * [data.rowsURL](data.rowsURL), [data.columnsURL](data.columnsURL), or
+         * [data.googleSpreadsheetKey](data.googleSpreadsheetKey).
+         *
+         * @sample highcharts/demo/live-data
+         *         Live data
+         * @sample highcharts/data/livedata-columns
+         *         Categorized bar chart with CSV and live polling
+         *
+         * @type      {boolean}
+         * @default   false
+         * @apioption data.enablePolling
+         */
+        /* eslint-disable valid-jsdoc */
+        /**
+         * The Data class
+         *
+         * @requires module:modules/data
+         *
+         * @class
+         * @name Highcharts.Data
+         *
+         * @param {Highcharts.DataOptions} dataOptions
+         *
+         * @param {Highcharts.Options} [chartOptions]
+         *
+         * @param {Highcharts.Chart} [chart]
+         */
+        var Data = /** @class */ (function () {
+                /* *
+                 *
+                 *  Constructors
+                 *
+                 * */
+                function Data(dataOptions, chartOptions, chart) {
+                    this.chart = void 0;
+                this.chartOptions = void 0;
+                this.firstRowAsNames = void 0;
+                this.rawColumns = void 0;
+                this.options = void 0;
+                /**
+                 * A collection of available date formats, extendable from the outside to
+                 * support custom date formats.
+                 *
+                 * @name Highcharts.Data#dateFormats
+                 * @type {Highcharts.Dictionary<Highcharts.DataDateFormatObject>}
+                 */
+                this.dateFormats = {
+                    'YYYY/mm/dd': {
+                        regex: /^([0-9]{4})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{1,2})$/,
+                        parser: function (match) {
+                            return (match ?
+                                Date.UTC(+match[1], match[2] - 1, +match[3]) :
+                                NaN);
+                        }
+                    },
+                    'dd/mm/YYYY': {
+                        regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{4})$/,
+                        parser: function (match) {
+                            return (match ?
+                                Date.UTC(+match[3], match[2] - 1, +match[1]) :
+                                NaN);
+                        },
+                        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 (match ?
+                                Date.UTC(+match[3], match[1] - 1, +match[2]) :
+                                NaN);
+                        }
+                    },
+                    'dd/mm/YY': {
+                        regex: /^([0-9]{1,2})[\-\/\.]([0-9]{1,2})[\-\/\.]([0-9]{2})$/,
+                        parser: function (match) {
+                            if (!match) {
+                                return NaN;
+                            }
+                            var year = +match[3],
+                                d = new Date();
+                            if (year > (d.getFullYear() - 2000)) {
+                                year += 1900;
+                            }
+                            else {
+                                year += 2000;
+                            }
+                            return Date.UTC(year, 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 (match ?
+                                Date.UTC(+match[3] + 2000, match[1] - 1, +match[2]) :
+                                NaN);
+                        }
+                    }
+                };
+                this.init(dataOptions, chartOptions, chart);
+            }
+            /* *
+             *
+             *  Functions
+             *
+             * */
+            /**
+             * Initialize the Data object with the given options
+             *
+             * @private
+             * @function Highcharts.Data#init
+             */
+            Data.prototype.init = function (options, chartOptions, chart) {
+                var decimalPoint = options.decimalPoint,
+                    hasData;
+                if (chartOptions) {
+                    this.chartOptions = chartOptions;
+                }
+                if (chart) {
+                    this.chart = chart;
+                }
+                if (decimalPoint !== '.' && decimalPoint !== ',') {
+                    decimalPoint = void 0;
+                }
+                this.options = options;
+                this.columns = (options.columns ||
+                    this.rowsToColumns(options.rows) ||
+                    []);
+                this.firstRowAsNames = pick(options.firstRowAsNames, this.firstRowAsNames, true);
+                this.decimalRegex = (decimalPoint &&
+                    new RegExp('^(-?[0-9]+)' + 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();
+                    hasData = true;
+                }
+                if (this.hasURLOption(options)) {
+                    clearTimeout(this.liveDataTimeout);
+                    hasData = false;
+                }
+                if (!hasData) {
+                    // Fetch live data
+                    hasData = this.fetchLiveData();
+                }
+                if (!hasData) {
+                    // Parse a CSV string if options.csv is given. The parseCSV function
+                    // returns a columns array, if it has no length, we have no data
+                    hasData = Boolean(this.parseCSV().length);
+                }
+                if (!hasData) {
+                    // Parse a HTML table if options.table is given
+                    hasData = Boolean(this.parseTable().length);
+                }
+                if (!hasData) {
+                    // Parse a Google Spreadsheet
+                    hasData = this.parseGoogleSpreadsheet();
+                }
+                if (!hasData && options.afterComplete) {
+                    options.afterComplete();
+                }
+            };
+            Data.prototype.hasURLOption = function (options) {
+                return Boolean(options &&
+                    (options.rowsURL || options.csvURL || options.columnsURL));
+            };
+            /**
+             * 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.
+             *
+             * @function Highcharts.Data#getColumnDistribution
+             */
+            Data.prototype.getColumnDistribution = function () {
+                var chartOptions = this.chartOptions,
+                    options = this.options,
+                    xColumns = [],
+                    getValueCount = function (type) {
+                        return (seriesTypes[type || 'line'].prototype.pointArrayMap || [0]).length;
+                }, getPointArrayMap = function (type) {
+                    return seriesTypes[type || 'line'].prototype.pointArrayMap;
+                }, globalType = (chartOptions &&
+                    chartOptions.chart &&
+                    chartOptions.chart.type), individualCounts = [], seriesBuilders = [], seriesIndex = 0, 
+                // If no series mapping is defined, check if the series array is
+                // defined with types.
+                seriesMapping = ((options && options.seriesMapping) ||
+                    (chartOptions &&
+                        chartOptions.series &&
+                        chartOptions.series.map(function () {
+                            return { x: 0 };
+                        })) ||
+                    []), i;
+                ((chartOptions && chartOptions.series) || []).forEach(function (series) {
+                    individualCounts.push(getValueCount(series.type || globalType));
+                });
+                // Collect the x-column indexes from seriesMapping
+                seriesMapping.forEach(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);
+                }
+                // Loop all seriesMappings and constructs SeriesBuilders from
+                // the mapping options.
+                seriesMapping.forEach(function (mapping) {
+                    var builder = new SeriesBuilder(),
+                        numberOfValueColumnsNeeded = individualCounts[seriesIndex] ||
+                            getValueCount(globalType),
+                        seriesArr = (chartOptions && chartOptions.series) || [],
+                        series = seriesArr[seriesIndex] || {},
+                        defaultPointArrayMap = getPointArrayMap(series.type || globalType),
+                        pointArrayMap = defaultPointArrayMap || ['y'];
+                    if (
+                    // User-defined x.mapping
+                    defined(mapping.x) ||
+                        // All non cartesian don't need 'x'
+                        series.isCartesian ||
+                        // Except pie series:
+                        !defaultPointArrayMap) {
+                        // 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
+                    objectEach(mapping, function (val, name) {
+                        if (name !== 'x') {
+                            builder.addColumnReader(val, name);
+                        }
+                    });
+                    // Add missing columns
+                    for (i = 0; i < numberOfValueColumnsNeeded; i++) {
+                        if (!builder.hasReader(pointArrayMap[i])) {
+                            // Create and add a column reader for the next free column
+                            // index
+                            builder.addColumnReader(void 0, pointArrayMap[i]);
+                        }
+                    }
+                    seriesBuilders.push(builder);
+                    seriesIndex++;
+                });
+                var globalPointArrayMap = getPointArrayMap(globalType);
+                if (typeof globalPointArrayMap === 'undefined') {
+                    globalPointArrayMap = ['y'];
+                }
+                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.
+             *
+             * @private
+             * @function Highcharts.Data#dataFound
+             */
+            Data.prototype.dataFound = function () {
+                if (this.options.switchRowsAndColumns) {
+                    this.columns = this.rowsToColumns(this.columns);
+                }
+                // 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
+             *
+             * @function Highcharts.Data#parseCSV
+             */
+            Data.prototype.parseCSV = function (inOptions) {
+                var self = this, options = inOptions || this.options, csv = options.csv, columns, startRow = (typeof options.startRow !== 'undefined' && options.startRow ?
+                        options.startRow :
+                        0), endRow = options.endRow || Number.MAX_VALUE, startColumn = (typeof options.startColumn !== 'undefined' &&
+                        options.startColumn) ? options.startColumn : 0, endColumn = options.endColumn || Number.MAX_VALUE, itemDelimiter, lines, rowIt = 0, 
+                    // activeRowNo = 0,
+                    dataTypes = [], 
+                    // We count potential delimiters in the prepass, and use the
+                    // result as the basis of half-intelligent guesses.
+                    potDelimiters = {
+                        ',': 0,
+                        ';': 0,
+                        '\t': 0
+                    };
+                columns = this.columns = [];
+                /*
+                    This implementation is quite verbose. It will be shortened once
+                    it's stable and passes all the test.
+
+                    It's also not written with speed in mind, instead everything is
+                    very seggregated, and there a several redundant loops.
+                    This is to make it easier to stabilize the code initially.
+
+                    We do a pre-pass on the first 4 rows to make some intelligent
+                    guesses on the set. Guessed delimiters are in this pass counted.
+
+                    Auto detecting delimiters
+                        - If we meet a quoted string, the next symbol afterwards
+                          (that's not \s, \t) is the delimiter
+                        - If we meet a date, the next symbol afterwards is the delimiter
+
+                    Date formats
+                        - If we meet a column with date formats, check all of them to
+                          see if one of the potential months crossing 12. If it does,
+                          we now know the format
+
+                    It would make things easier to guess the delimiter before
+                    doing the actual parsing.
+
+                    General rules:
+                        - Quoting is allowed, e.g: "Col 1",123,321
+                        - Quoting is optional, e.g.: Col1,123,321
+                        - Doubble quoting is escaping, e.g. "Col ""Hello world""",123
+                        - Spaces are considered part of the data: Col1 ,123
+                        - New line is always the row delimiter
+                        - Potential column delimiters are , ; \t
+                        - First row may optionally contain headers
+                        - The last row may or may not have a row delimiter
+                        - Comments are optionally supported, in which case the comment
+                          must start at the first column, and the rest of the line will
+                          be ignored
+                */
+                /**
+                 * Parse a single row.
+                 * @private
+                 */
+                function parseRow(columnStr, rowNumber, noAdd, callbacks) {
+                    var i = 0, c = '', cl = '', cn = '', token = '', actualColumn = 0, column = 0;
+                    /**
+                     * @private
+                     */
+                    function read(j) {
+                        c = columnStr[j];
+                        cl = columnStr[j - 1];
+                        cn = columnStr[j + 1];
+                    }
+                    /**
+                     * @private
+                     */
+                    function pushType(type) {
+                        if (dataTypes.length < column + 1) {
+                            dataTypes.push([type]);
+                        }
+                        if (dataTypes[column][dataTypes[column].length - 1] !== type) {
+                            dataTypes[column].push(type);
+                        }
+                    }
+                    /**
+                     * @private
+                     */
+                    function push() {
+                        if (startColumn > actualColumn || actualColumn > endColumn) {
+                            // Skip this column, but increment the column count (#7272)
+                            ++actualColumn;
+                            token = '';
+                            return;
+                        }
+                        if (!isNaN(parseFloat(token)) && isFinite(token)) {
+                            token = parseFloat(token);
+                            pushType('number');
+                        }
+                        else if (!isNaN(Date.parse(token))) {
+                            token = token.replace(/\//g, '-');
+                            pushType('date');
+                        }
+                        else {
+                            pushType('string');
+                        }
+                        if (columns.length < column + 1) {
+                            columns.push([]);
+                        }
+                        if (!noAdd) {
+                            // Don't push - if there's a varrying amount of columns
+                            // for each row, pushing will skew everything down n slots
+                            columns[column][rowNumber] = token;
+                        }
+                        token = '';
+                        ++column;
+                        ++actualColumn;
+                    }
+                    if (!columnStr.trim().length) {
+                        return;
+                    }
+                    if (columnStr.trim()[0] === '#') {
+                        return;
+                    }
+                    for (; i < columnStr.length; i++) {
+                        read(i);
+                        if (c === '"') {
+                            read(++i);
+                            while (i < columnStr.length) {
+                                if (c === '"' && cl !== '"' && cn !== '"') {
+                                    break;
+                                }
+                                if (c !== '"' || (c === '"' && cl !== '"')) {
+                                    token += c;
+                                }
+                                read(++i);
+                            }
+                            // Perform "plugin" handling
+                        }
+                        else if (callbacks && callbacks[c]) {
+                            if (callbacks[c](c, token)) {
+                                push();
+                            }
+                            // Delimiter - push current token
+                        }
+                        else if (c === itemDelimiter) {
+                            push();
+                            // Actual column data
+                        }
+                        else {
+                            token += c;
+                        }
+                    }
+                    push();
+                }
+                /**
+                 * Attempt to guess the delimiter. We do a separate parse pass here
+                 * because we need to count potential delimiters softly without making
+                 * any assumptions.
+                 * @private
+                 */
+                function guessDelimiter(lines) {
+                    var points = 0,
+                        commas = 0,
+                        guessed = false;
+                    lines.some(function (columnStr, i) {
+                        var inStr = false,
+                            c,
+                            cn,
+                            cl,
+                            token = '';
+                        // We should be able to detect dateformats within 13 rows
+                        if (i > 13) {
+                            return true;
+                        }
+                        for (var j = 0; j < columnStr.length; j++) {
+                            c = columnStr[j];
+                            cn = columnStr[j + 1];
+                            cl = columnStr[j - 1];
+                            if (c === '#') {
+                                // Skip the rest of the line - it's a comment
+                                return;
+                            }
+                            if (c === '"') {
+                                if (inStr) {
+                                    if (cl !== '"' && cn !== '"') {
+                                        while (cn === ' ' && j < columnStr.length) {
+                                            cn = columnStr[++j];
+                                        }
+                                        // After parsing a string, the next non-blank
+                                        // should be a delimiter if the CSV is properly
+                                        // formed.
+                                        if (typeof potDelimiters[cn] !== 'undefined') {
+                                            potDelimiters[cn]++;
+                                        }
+                                        inStr = false;
+                                    }
+                                }
+                                else {
+                                    inStr = true;
+                                }
+                            }
+                            else if (typeof potDelimiters[c] !== 'undefined') {
+                                token = token.trim();
+                                if (!isNaN(Date.parse(token))) {
+                                    potDelimiters[c]++;
+                                }
+                                else if (isNaN(token) ||
+                                    !isFinite(token)) {
+                                    potDelimiters[c]++;
+                                }
+                                token = '';
+                            }
+                            else {
+                                token += c;
+                            }
+                            if (c === ',') {
+                                commas++;
+                            }
+                            if (c === '.') {
+                                points++;
+                            }
+                        }
+                    });
+                    // Count the potential delimiters.
+                    // This could be improved by checking if the number of delimiters
+                    // equals the number of columns - 1
+                    if (potDelimiters[';'] > potDelimiters[',']) {
+                        guessed = ';';
+                    }
+                    else if (potDelimiters[','] > potDelimiters[';']) {
+                        guessed = ',';
+                    }
+                    else {
+                        // No good guess could be made..
+                        guessed = ',';
+                    }
+                    // Try to deduce the decimal point if it's not explicitly set.
+                    // If both commas or points is > 0 there is likely an issue
+                    if (!options.decimalPoint) {
+                        if (points > commas) {
+                            options.decimalPoint = '.';
+                        }
+                        else {
+                            options.decimalPoint = ',';
+                        }
+                        // Apply a new decimal regex based on the presumed decimal sep.
+                        self.decimalRegex = new RegExp('^(-?[0-9]+)' +
+                            options.decimalPoint +
+                            '([0-9]+)$');
+                    }
+                    return guessed;
+                }
+                /**
+                 * Tries to guess the date format
+                 *  - Check if either month candidate exceeds 12
+                 *  - Check if year is missing (use current year)
+                 *  - Check if a shortened year format is used (e.g. 1/1/99)
+                 *  - If no guess can be made, the user must be prompted
+                 * data is the data to deduce a format based on
+                 * @private
+                 */
+                function deduceDateFormat(data, limit) {
+                    var format = 'YYYY/mm/dd',
+                        thing,
+                        guessedFormat = [],
+                        calculatedFormat,
+                        i = 0,
+                        madeDeduction = false, 
+                        // candidates = {},
+                        stable = [],
+                        max = [],
+                        j;
+                    if (!limit || limit > data.length) {
+                        limit = data.length;
+                    }
+                    for (; i < limit; i++) {
+                        if (typeof data[i] !== 'undefined' &&
+                            data[i] && data[i].length) {
+                            thing = data[i]
+                                .trim()
+                                .replace(/\//g, ' ')
+                                .replace(/\-/g, ' ')
+                                .replace(/\./g, ' ')
+                                .split(' ');
+                            guessedFormat = [
+                                '',
+                                '',
+                                ''
+                            ];
+                            for (j = 0; j < thing.length; j++) {
+                                if (j < guessedFormat.length) {
+                                    thing[j] = parseInt(thing[j], 10);
+                                    if (thing[j]) {
+                                        max[j] = (!max[j] || max[j] < thing[j]) ?
+                                            thing[j] :
+                                            max[j];
+                                        if (typeof stable[j] !== 'undefined') {
+                                            if (stable[j] !== thing[j]) {
+                                                stable[j] = false;
+                                            }
+                                        }
+                                        else {
+                                            stable[j] = thing[j];
+                                        }
+                                        if (thing[j] > 31) {
+                                            if (thing[j] < 100) {
+                                                guessedFormat[j] = 'YY';
+                                            }
+                                            else {
+                                                guessedFormat[j] = 'YYYY';
+                                            }
+                                            // madeDeduction = true;
+                                        }
+                                        else if (thing[j] > 12 &&
+                                            thing[j] <= 31) {
+                                            guessedFormat[j] = 'dd';
+                                            madeDeduction = true;
+                                        }
+                                        else if (!guessedFormat[j].length) {
+                                            guessedFormat[j] = 'mm';
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (madeDeduction) {
+                        // This handles a few edge cases with hard to guess dates
+                        for (j = 0; j < stable.length; j++) {
+                            if (stable[j] !== false) {
+                                if (max[j] > 12 &&
+                                    guessedFormat[j] !== 'YY' &&
+                                    guessedFormat[j] !== 'YYYY') {
+                                    guessedFormat[j] = 'YY';
+                                }
+                            }
+                            else if (max[j] > 12 && guessedFormat[j] === 'mm') {
+                                guessedFormat[j] = 'dd';
+                            }
+                        }
+                        // If the middle one is dd, and the last one is dd,
+                        // the last should likely be year.
+                        if (guessedFormat.length === 3 &&
+                            guessedFormat[1] === 'dd' &&
+                            guessedFormat[2] === 'dd') {
+                            guessedFormat[2] = 'YY';
+                        }
+                        calculatedFormat = guessedFormat.join('/');
+                        // If the caculated format is not valid, we need to present an
+                        // error.
+                        if (!(options.dateFormats || self.dateFormats)[calculatedFormat]) {
+                            // This should emit an event instead
+                            fireEvent('deduceDateFailed');
+                            return format;
+                        }
+                        return calculatedFormat;
+                    }
+                    return format;
+                }
+                /**
+                 * @todo
+                 * Figure out the best axis types for the data
+                 * - If the first column is a number, we're good
+                 * - If the first column is a date, set to date/time
+                 * - If the first column is a string, set to categories
+                 * @private
+                 */
+                function deduceAxisTypes() {
+                }
+                if (csv && options.beforeParse) {
+                    csv = options.beforeParse.call(this, csv);
+                }
+                if (csv) {
+                    lines = csv
+                        .replace(/\r\n/g, '\n') // Unix
+                        .replace(/\r/g, '\n') // Mac
+                        .split(options.lineDelimiter || '\n');
+                    if (!startRow || startRow < 0) {
+                        startRow = 0;
+                    }
+                    if (!endRow || endRow >= lines.length) {
+                        endRow = lines.length - 1;
+                    }
+                    if (options.itemDelimiter) {
+                        itemDelimiter = options.itemDelimiter;
+                    }
+                    else {
+                        itemDelimiter = null;
+                        itemDelimiter = guessDelimiter(lines);
+                    }
+                    var offset = 0;
+                    for (rowIt = startRow; rowIt <= endRow; rowIt++) {
+                        if (lines[rowIt][0] === '#') {
+                            offset++;
+                        }
+                        else {
+                            parseRow(lines[rowIt], rowIt - startRow - offset);
+                        }
+                    }
+                    // //Make sure that there's header columns for everything
+                    // columns.forEach(function (col) {
+                    // });
+                    deduceAxisTypes();
+                    if ((!options.columnTypes || options.columnTypes.length === 0) &&
+                        dataTypes.length &&
+                        dataTypes[0].length &&
+                        dataTypes[0][1] === 'date' &&
+                        !options.dateFormat) {
+                        options.dateFormat = deduceDateFormat(columns[0]);
+                    }
+                    // lines.forEach(function (line, rowNo) {
+                    //    let trimmed = self.trim(line),
+                    //        isComment = trimmed.indexOf('#') === 0,
+                    //        isBlank = trimmed === '',
+                    //        items;
+                    //    if (
+                    //        rowNo >= startRow &&
+                    //        rowNo <= endRow &&
+                    //        !isComment && !isBlank
+                    //    ) {
+                    //        items = line.split(itemDelimiter);
+                    //        items.forEach(function (item, colNo) {
+                    //            if (colNo >= startColumn && colNo <= endColumn) {
+                    //                if (!columns[colNo - startColumn]) {
+                    //                    columns[colNo - startColumn] = [];
+                    //                }
+                    //                columns[colNo - startColumn][activeRowNo] = item;
+                    //            }
+                    //        });
+                    //        activeRowNo += 1;
+                    //    }
+                    // });
+                    //
+                    this.dataFound();
+                }
+                return columns;
+            };
+            /**
+             * Parse a HTML table
+             *
+             * @function Highcharts.Data#parseTable
+             */
+            Data.prototype.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 = doc.getElementById(table);
+                    }
+                    [].forEach.call(table.getElementsByTagName('tr'), function (tr, rowNo) {
+                        if (rowNo >= startRow && rowNo <= endRow) {
+                            [].forEach.call(tr.children, function (item, colNo) {
+                                var row = columns[colNo - startColumn];
+                                var i = 1;
+                                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;
+                                    // Loop over all previous indices and make sure
+                                    // they are nulls, not undefined.
+                                    while (rowNo - startRow >= i &&
+                                        row[rowNo - startRow - i] === void 0) {
+                                        row[rowNo - startRow - i] = null;
+                                        i++;
+                                    }
+                                }
+                            });
+                        }
+                    });
+                    this.dataFound(); // continue
+                }
+                return columns;
+            };
+            /**
+             * Fetch or refetch live data
+             *
+             * @function Highcharts.Data#fetchLiveData
+             *
+             * @return {boolean}
+             *         The URLs that were tried can be found in the options
+             */
+            Data.prototype.fetchLiveData = function () {
+                var data = this,
+                    chart = this.chart,
+                    options = this.options,
+                    maxRetries = 3,
+                    currentRetries = 0,
+                    pollingEnabled = options.enablePolling,
+                    updateIntervalMs = (options.dataRefreshRate || 2) * 1000,
+                    originalOptions = merge(options);
+                if (!this.hasURLOption(options)) {
+                    return false;
+                }
+                // Do not allow polling more than once a second
+                if (updateIntervalMs < 1000) {
+                    updateIntervalMs = 1000;
+                }
+                delete options.csvURL;
+                delete options.rowsURL;
+                delete options.columnsURL;
+                /**
+                 * @private
+                 */
+                function performFetch(initialFetch) {
+                    /**
+                     * Helper function for doing the data fetch + polling.
+                     * @private
+                     */
+                    function request(url, done, tp) {
+                        if (!url ||
+                            !/^(http|\/|\.\/|\.\.\/)/.test(url)) {
+                            if (url && options.error) {
+                                options.error('Invalid URL');
+                            }
+                            return false;
+                        }
+                        if (initialFetch) {
+                            clearTimeout(data.liveDataTimeout);
+                            chart.liveDataURL = url;
+                        }
+                        /**
+                         * @private
+                         */
+                        function poll() {
+                            // Poll
+                            if (pollingEnabled && chart.liveDataURL === url) {
+                                // We need to stop doing this if the URL has changed
+                                data.liveDataTimeout =
+                                    setTimeout(performFetch, updateIntervalMs);
+                            }
+                        }
+                        ajax({
+                            url: url,
+                            dataType: tp || 'json',
+                            success: function (res) {
+                                if (chart && chart.series) {
+                                    done(res);
+                                }
+                                poll();
+                            },
+                            error: function (xhr, text) {
+                                if (++currentRetries < maxRetries) {
+                                    poll();
+                                }
+                                return options.error && options.error(text, xhr);
+                            }
+                        });
+                        return true;
+                    }
+                    if (!request(originalOptions.csvURL, function (res) {
+                        chart.update({
+                            data: {
+                                csv: res
+                            }
+                        });
+                    }, 'text')) {
+                        if (!request(originalOptions.rowsURL, function (res) {
+                            chart.update({
+                                data: {
+                                    rows: res
+                                }
+                            });
+                        })) {
+                            request(originalOptions.columnsURL, function (res) {
+                                chart.update({
+                                    data: {
+                                        columns: res
+                                    }
+                                });
+                            });
+                        }
+                    }
+                }
+                performFetch(true);
+                return this.hasURLOption(options);
+            };
+            /**
+             * Parse a Google spreadsheet.
+             *
+             * @function Highcharts.Data#parseGoogleSpreadsheet
+             *
+             * @return {boolean}
+             *         Always returns false, because it is an intermediate fetch.
+             */
+            Data.prototype.parseGoogleSpreadsheet = function () {
+                var data = this,
+                    options = this.options,
+                    googleSpreadsheetKey = options.googleSpreadsheetKey,
+                    chart = this.chart,
+                    refreshRate = Math.max((options.dataRefreshRate || 2) * 1000, 4000);
+                /**
+                 * Form the `values` field after range settings, unless the
+                 * googleSpreadsheetRange option is set.
+                 */
+                var getRange = function () {
+                        if (options.googleSpreadsheetRange) {
+                            return options.googleSpreadsheetRange;
+                    }
+                    var alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+                    var start = (alphabet.charAt(options.startColumn || 0) || 'A') +
+                            ((options.startRow || 0) + 1);
+                    var end = alphabet.charAt(pick(options.endColumn, -1)) || 'ZZ';
+                    if (defined(options.endRow)) {
+                        end += options.endRow + 1;
+                    }
+                    return start + ":" + end;
+                };
+                /**
+                 * Fetch the actual spreadsheet using XMLHttpRequest.
+                 * @private
+                 */
+                function fetchSheet(fn) {
+                    var url = [
+                            'https://sheets.googleapis.com/v4/spreadsheets',
+                            googleSpreadsheetKey,
+                            'values',
+                            getRange(),
+                            '?alt=json&' +
+                                'majorDimension=COLUMNS&' +
+                                'valueRenderOption=UNFORMATTED_VALUE&' +
+                                'dateTimeRenderOption=FORMATTED_STRING&' +
+                                'key=' + options.googleAPIKey
+                        ].join('/');
+                    ajax({
+                        url: url,
+                        dataType: 'json',
+                        success: function (json) {
+                            fn(json);
+                            if (options.enablePolling) {
+                                setTimeout(function () {
+                                    fetchSheet(fn);
+                                }, refreshRate);
+                            }
+                        },
+                        error: function (xhr, text) {
+                            return options.error && options.error(text, xhr);
+                        }
+                    });
+                }
+                if (googleSpreadsheetKey) {
+                    delete options.googleSpreadsheetKey;
+                    fetchSheet(function (json) {
+                        // Prepare the data from the spreadsheat
+                        var columns = json.values;
+                        if (!columns || columns.length === 0) {
+                            return false;
+                        }
+                        // Find the maximum row count in order to extend shorter columns
+                        var rowCount = columns.reduce(function (rowCount,
+                            column) { return Math.max(rowCount,
+                            column.length); }, 0);
+                        // Insert null for empty spreadsheet cells (#5298)
+                        columns.forEach(function (column) {
+                            for (var i = 0; i < rowCount; i++) {
+                                if (typeof column[i] === 'undefined') {
+                                    column[i] = null;
+                                }
+                            }
+                        });
+                        if (chart && chart.series) {
+                            chart.update({
+                                data: {
+                                    columns: columns
+                                }
+                            });
+                        }
+                        else { // #8245
+                            data.columns = columns;
+                            data.dataFound();
+                        }
+                    });
+                }
+                // This is an intermediate fetch, so always return false.
+                return false;
+            };
+            /**
+             * Trim a string from whitespaces.
+             *
+             * @function Highcharts.Data#trim
+             *
+             * @param {string} str
+             *        String to trim
+             *
+             * @param {boolean} [inside=false]
+             *        Remove all spaces between numbers.
+             *
+             * @return {string}
+             *         Trimed string
+             */
+            Data.prototype.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');
+                    }
+                }
+                return str;
+            };
+            /**
+             * Parse numeric cells in to number types and date types in to true dates.
+             *
+             * @function Highcharts.Data#parseTypes
+             */
+            Data.prototype.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.
+             *
+             * @function Highcharts.Data#parseColumn
+             *
+             * @param {Array<Highcharts.DataValueType>} column
+             *        Column to parse
+             *
+             * @param {number} col
+             *        Column index
+             */
+            Data.prototype.parseColumn = function (column, col) {
+                var rawColumns = this.rawColumns,
+                    columns = this.columns,
+                    row = column.length,
+                    val,
+                    floatVal,
+                    trimVal,
+                    trimInsideVal,
+                    firstRowAsNames = this.firstRowAsNames,
+                    isXColumn = this.valueCount.xColumns.indexOf(col) !== -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];
+                    trimVal = this.trim(val);
+                    trimInsideVal = this.trim(val, true);
+                    floatVal = parseFloat(trimInsideVal);
+                    // Set it the first time
+                    if (typeof rawColumns[col][row] === 'undefined') {
+                        rawColumns[col][row] = trimVal;
+                    }
+                    // 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 (typeof column[row + 1] !== 'undefined') {
+                            descending = floatVal > column[row + 1];
+                        }
+                        // String, continue to determine if it is a date string or really a
+                        // string
+                    }
+                    else {
+                        if (trimVal && trimVal.length) {
+                            dateVal = this.parseDate(val);
+                        }
+                        // Only allow parsing of dates if this column is an x-column
+                        if (isXColumn && isNumber(dateVal) && columnType !== 'float') {
+                            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 (typeof column[row + 1] !== 'undefined') {
+                                diff = dateVal > column[row + 1];
+                                if (diff !== descending &&
+                                    typeof 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 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());
+                        }
+                    }
+                }
+            };
+            /**
+             * Parse a date and return it as a number. Overridable through
+             * `options.parseDate`.
+             *
+             * @function Highcharts.Data#parseDate
+             */
+            Data.prototype.parseDate = function (val) {
+                var parseDate = this.options.parseDate;
+                var 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) { // eslint-disable-line guard-for-in
+                            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];
+                        if (!format) {
+                            // The selected format is invalid
+                            format = this.dateFormats['YYYY/mm/dd'];
+                        }
+                        match = val.match(format.regex);
+                        if (match) {
+                            ret = format.parser(match);
+                        }
+                    }
+                    // Fall back to Date.parse
+                    if (!match) {
+                        if (val.match(/:.+(GMT|UTC|[Z+-])/)) {
+                            val = val
+                                .replace(/\s*(?:GMT|UTC)?([+-])(\d\d)(\d\d)$/, '$1$2:$3')
+                                .replace(/(?:\s+|GMT|UTC)([+-])/, '$1')
+                                .replace(/(\d)\s*(?:GMT|UTC|Z)$/, '$1+00:00');
+                        }
+                        match = Date.parse(val);
+                        // External tools like Date.js and MooTools extend Date object
+                        // and return a date.
+                        if (typeof match === 'object' &&
+                            match !== null &&
+                            match.getTime) {
+                            ret = (match.getTime() -
+                                match.getTimezoneOffset() *
+                                    60000);
+                            // Timestamp
+                        }
+                        else if (isNumber(match)) {
+                            ret = match - (new Date(match)).getTimezoneOffset() * 60000;
+                        }
+                    }
+                }
+                return ret;
+            };
+            /**
+             * Reorganize rows into columns.
+             *
+             * @function Highcharts.Data#rowsToColumns
+             */
+            Data.prototype.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];
+                        }
+                    }
+                }
+                return columns;
+            };
+            /**
+             * Get the parsed data in a form that we can apply directly to the
+             * `series.data` config. Array positions can be mapped using the
+             * `series.keys` option.
+             *
+             * @example
+             * const data = Highcharts.data({
+             *   csv: document.getElementById('data').innerHTML
+             * }).getData();
+             *
+             * @function Highcharts.Data#getData
+             *
+             * @return {Array<Array<(number|string)>>|undefined} Data rows
+             */
+            Data.prototype.getData = function () {
+                if (this.columns) {
+                    return this.rowsToColumns(this.columns).slice(1);
+                }
+            };
+            /**
+             * A hook for working directly on the parsed columns
+             *
+             * @function Highcharts.Data#parsed
+             */
+            Data.prototype.parsed = function () {
+                if (this.options.parsed) {
+                    return this.options.parsed.call(this, this.columns);
+                }
+            };
+            /**
+             * @private
+             * @function Highcharts.Data#getFreeIndexes
+             */
+            Data.prototype.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);
+                }
+                // Loop all defined builders and remove their referenced columns
+                for (s = 0; s < seriesBuilders.length; s = s + 1) {
+                    referencedIndexes = seriesBuilders[s].getReferencedColumnIndexes();
+                    for (i = 0; i < referencedIndexes.length; i = i + 1) {
+                        freeIndexes[referencedIndexes[i]] = false;
+                    }
+                }
+                // Collect the values for the free indexes
+                for (i = 0; i < freeIndexes.length; i = i + 1) {
+                    if (freeIndexes[i]) {
+                        freeIndexValues.push(i);
+                    }
+                }
+                return freeIndexValues;
+            };
+            /**
+             * If a complete callback function is provided in the options, interpret the
+             * columns into a Highcharts options object.
+             *
+             * @function Highcharts.Data#complete
+             */
+            Data.prototype.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
+                    if (this.firstRowAsNames) {
+                        for (i = 0; i < columns.length; i++) {
+                            var curCol = columns[i];
+                            if (!defined(curCol.name)) {
+                                curCol.name = pick(curCol.shift(), '').toString();
+                            }
+                        }
+                    }
+                    // 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);
+                        }
+                    }
+                    // Populate dynamic series
+                    while (freeIndexes.length > 0) {
+                        builder = new SeriesBuilder();
+                        builder.addColumnReader(0, 'x');
+                        // Mark index as used (not free)
+                        index = freeIndexes.indexOf(0);
+                        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(void 0, 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 (typeof 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';
+                                }
+                            }
+                        }
+                    }
+                    // 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++) {
+                            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;
+                        }
+                    }
+                    // Do the callback
+                    chartOptions = {
+                        series: series
+                    };
+                    if (type) {
+                        chartOptions.xAxis = {
+                            type: type
+                        };
+                        if (type === 'category') {
+                            chartOptions.xAxis.uniqueNames = false;
+                        }
+                    }
+                    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);
+                    }
+                }
+            };
+            /**
+             * Updates the chart with new data options.
+             *
+             * @function Highcharts.Data#update
+             *
+             * @param {Highcharts.DataOptions} options
+             *
+             * @param {boolean} [redraw=true]
+             */
+            Data.prototype.update = function (options, redraw) {
+                var chart = this.chart;
+                if (options) {
+                    // Set the complete handler
+                    options.afterComplete = function (dataOptions) {
+                        // Avoid setting axis options unless the type changes. Running
+                        // Axis.update will cause the whole structure to be destroyed
+                        // and rebuilt, and animation is lost.
+                        if (dataOptions) {
+                            if (dataOptions.xAxis &&
+                                chart.xAxis[0] &&
+                                dataOptions.xAxis.type ===
+                                    chart.xAxis[0].options.type) {
+                                delete dataOptions.xAxis;
+                            }
+                            // @todo looks not right:
+                            chart.update(dataOptions, redraw, true);
+                        }
+                    };
+                    // Apply it
+                    merge(true, chart.options.data, options);
+                    this.init(chart.options.data);
+                }
+            };
+            return Data;
+        }());
+        // Register the Data prototype and data function on Highcharts
+        // Highcharts.Data = Data as any;
+        /**
+         * Creates a data object to parse data for a chart.
+         *
+         * @function Highcharts.data
+         */
+        G.data = function (dataOptions, chartOptions, chart) {
+            return new G.Data(dataOptions, chartOptions, chart);
+        };
+        // Extend Chart.init so that the Chart constructor accepts a new configuration
+        // option group, data.
+        addEvent(Chart, 'init', function (e) {
+            var chart = this, // eslint-disable-line no-invalid-this
+                userOptions = (e.args[0] || {}),
+                callback = e.args[1];
+            if (userOptions && userOptions.data && !chart.hasDataDef) {
+                chart.hasDataDef = true;
+                /**
+                 * The data parser for this chart.
+                 *
+                 * @name Highcharts.Chart#data
+                 * @type {Highcharts.Data|undefined}
+                 */
+                chart.data = new G.Data(extend(userOptions.data, {
+                    afterComplete: function (dataOptions) {
+                        var i,
+                            series;
+                        // Merge series configs
+                        if (Object.hasOwnProperty.call(userOptions, 'series')) {
+                            if (typeof userOptions.series === 'object') {
+                                i = Math.max(userOptions.series.length, dataOptions && dataOptions.series ?
+                                    dataOptions.series.length :
+                                    0);
+                                while (i--) {
+                                    series = userOptions.series[i] || {};
+                                    userOptions.series[i] = merge(series, dataOptions && dataOptions.series ?
+                                        dataOptions.series[i] :
+                                        {});
+                                }
+                            }
+                            else { // Allow merging in dataOptions.series (#2856)
+                                delete userOptions.series;
+                            }
+                        }
+                        // Do the merge
+                        userOptions = merge(dataOptions, userOptions);
+                        // Run chart.init again
+                        chart.init(userOptions, callback);
+                    }
+                }), userOptions, chart);
+                e.preventDefault();
+            }
+        });
+        /**
+         * Creates a new SeriesBuilder. A SeriesBuilder consists of a number
+         * of ColumnReaders that reads columns and give them a name.
+         * Ex: A series builder can be constructed to read column 3 as 'x' and
+         * column 7 and 8 as 'y1' and 'y2'.
+         * The output would then be points/rows of the form {x: 11, y1: 22, y2: 33}
+         *
+         * The name of the builder is taken from the second column. In the above
+         * example it would be the column with index 7.
+         *
+         * @private
+         * @class
+         * @name SeriesBuilder
+         */
+        var SeriesBuilder = /** @class */ (function () {
+                function SeriesBuilder() {
+                    /* eslint-disable no-invalid-this */
+                    this.readers = [];
+                this.pointIsArray = true;
+                /* eslint-enable no-invalid-this */
+                this.name = void 0;
+            }
+            /**
+             * Populates readers with column indexes. A reader can be added without
+             * a specific index and for those readers the index is taken sequentially
+             * from the free columns (this is handled by the ColumnCursor instance).
+             *
+             * @function SeriesBuilder#populateColumns
+             */
+            SeriesBuilder.prototype.populateColumns = function (freeIndexes) {
+                var builder = this,
+                    enoughColumns = true;
+                // Loop each reader and give it an index if its missing.
+                // The freeIndexes.shift() will return undefined if there
+                // are no more columns.
+                builder.readers.forEach(function (reader) {
+                    if (typeof reader.columnIndex === 'undefined') {
+                        reader.columnIndex = freeIndexes.shift();
+                    }
+                });
+                // Now, all readers should have columns mapped. If not
+                // then return false to signal that this series should
+                // not be added.
+                builder.readers.forEach(function (reader) {
+                    if (typeof reader.columnIndex === 'undefined') {
+                        enoughColumns = false;
+                    }
+                });
+                return enoughColumns;
+            };
+            /**
+             * Reads a row from the dataset and returns a point or array depending
+             * on the names of the readers.
+             *
+             * @function SeriesBuilder#read<T>
+             */
+            SeriesBuilder.prototype.read = function (columns, rowIndex) {
+                var builder = this,
+                    pointIsArray = builder.pointIsArray,
+                    point = pointIsArray ? [] : {},
+                    columnIndexes;
+                // Loop each reader and ask it to read its value.
+                // Then, build an array or point based on the readers names.
+                builder.readers.forEach(function (reader) {
+                    var value = columns[reader.columnIndex][rowIndex];
+                    if (pointIsArray) {
+                        point.push(value);
+                    }
+                    else {
+                        if (reader.configName.indexOf('.') > 0) {
+                            // Handle nested property names
+                            Point.prototype.setNestedProperty(point, value, reader.configName);
+                        }
+                        else {
+                            point[reader.configName] = value;
+                        }
+                    }
+                });
+                // The name comes from the first column (excluding the x column)
+                if (typeof this.name === 'undefined' && builder.readers.length >= 2) {
+                    columnIndexes = builder.getReferencedColumnIndexes();
+                    if (columnIndexes.length >= 2) {
+                        // remove the first one (x col)
+                        columnIndexes.shift();
+                        // Sort the remaining
+                        columnIndexes.sort(function (a, b) {
+                            return a - b;
+                        });
+                        // Now use the lowest index as name column
+                        this.name = columns[columnIndexes.shift()].name;
+                    }
+                }
+                return point;
+            };
+            /**
+             * Creates and adds ColumnReader from the given columnIndex and configName.
+             * ColumnIndex can be undefined and in that case the reader will be given
+             * an index when columns are populated.
+             *
+             * @function SeriesBuilder#addColumnReader
+             */
+            SeriesBuilder.prototype.addColumnReader = function (columnIndex, configName) {
+                this.readers.push({
+                    columnIndex: columnIndex,
+                    configName: configName
+                });
+                if (!(configName === 'x' ||
+                    configName === 'y' ||
+                    typeof configName === 'undefined')) {
+                    this.pointIsArray = false;
+                }
+            };
+            /**
+             * Returns an array of column indexes that the builder will use when
+             * reading data.
+             *
+             * @function SeriesBuilder#getReferencedColumnIndexes
+             */
+            SeriesBuilder.prototype.getReferencedColumnIndexes = function () {
+                var i,
+                    referencedColumnIndexes = [],
+                    columnReader;
+                for (i = 0; i < this.readers.length; i = i + 1) {
+                    columnReader = this.readers[i];
+                    if (typeof columnReader.columnIndex !== 'undefined') {
+                        referencedColumnIndexes.push(columnReader.columnIndex);
+                    }
+                }
+                return referencedColumnIndexes;
+            };
+            /**
+             * Returns true if the builder has a reader for the given configName.
+             *
+             * @function SeriesBuider#hasReader
+             */
+            SeriesBuilder.prototype.hasReader = function (configName) {
+                var i,
+                    columnReader;
+                for (i = 0; i < this.readers.length; i = i + 1) {
+                    columnReader = this.readers[i];
+                    if (columnReader.configName === configName) {
+                        return true;
+                    }
+                }
+                // Else return undefined
+            };
+            return SeriesBuilder;
+        }());
+        G.Data = Data;
+
+        return G.Data;
+    });
+    _registerModule(_modules, 'masters/modules/data.src.js', [_modules['Core/Globals.js'], _modules['Core/HttpUtilities.js'], _modules['Extensions/Data.js']], function (Highcharts, HttpUtilities, Data) {
+
+        var G = Highcharts;
+        // Functions
+        G.ajax = HttpUtilities.ajax;
+        G.getJSON = HttpUtilities.getJSON;
+        G.post = HttpUtilities.post;
+        // Classes
+        G.Data = Data;
+        G.HttpUtilities = HttpUtilities;
+
+    });
+}));