{"version":3,"file":"js/chunk-vendors-61174297.6b670c0f.js","mappings":"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","sources":["webpack://app/./node_modules/echarts/lib/data/helper/completeDimensions.js","webpack://app/./node_modules/echarts/lib/data/helper/createDimensions.js","webpack://app/./node_modules/echarts/lib/data/helper/dataProvider.js","webpack://app/./node_modules/echarts/lib/data/helper/dataStackHelper.js","webpack://app/./node_modules/echarts/lib/data/helper/dimensionHelper.js","webpack://app/./node_modules/echarts/lib/data/helper/linkList.js","webpack://app/./node_modules/echarts/lib/data/helper/sourceHelper.js","webpack://app/./node_modules/echarts/lib/data/helper/sourceType.js"],"sourcesContent":["\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _util = require(\"zrender/lib/core/util\");\n\nvar createHashMap = _util.createHashMap;\nvar each = _util.each;\nvar isString = _util.isString;\nvar defaults = _util.defaults;\nvar extend = _util.extend;\nvar isObject = _util.isObject;\nvar clone = _util.clone;\n\nvar _model = require(\"../../util/model\");\n\nvar normalizeToArray = _model.normalizeToArray;\n\nvar _sourceHelper = require(\"./sourceHelper\");\n\nvar guessOrdinal = _sourceHelper.guessOrdinal;\nvar BE_ORDINAL = _sourceHelper.BE_ORDINAL;\n\nvar Source = require(\"../Source\");\n\nvar _dimensionHelper = require(\"./dimensionHelper\");\n\nvar OTHER_DIMENSIONS = _dimensionHelper.OTHER_DIMENSIONS;\n\nvar DataDimensionInfo = require(\"../DataDimensionInfo\");\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * @deprecated\n * Use `echarts/data/helper/createDimensions` instead.\n */\n\n/**\n * @see {module:echarts/test/ut/spec/data/completeDimensions}\n *\n * This method builds the relationship between:\n * + \"what the coord sys or series requires (see `sysDims`)\",\n * + \"what the user defines (in `encode` and `dimensions`, see `opt.dimsDef` and `opt.encodeDef`)\"\n * + \"what the data source provids (see `source`)\".\n *\n * Some guess strategy will be adapted if user does not define something.\n * If no 'value' dimension specified, the first no-named dimension will be\n * named as 'value'.\n *\n * @param {Array.<string>} sysDims Necessary dimensions, like ['x', 'y'], which\n *      provides not only dim template, but also default order.\n *      properties: 'name', 'type', 'displayName'.\n *      `name` of each item provides default coord name.\n *      [{dimsDef: [string|Object, ...]}, ...] dimsDef of sysDim item provides default dim name, and\n *                                    provide dims count that the sysDim required.\n *      [{ordinalMeta}] can be specified.\n * @param {module:echarts/data/Source|Array|Object} source or data (for compatibal with pervious)\n * @param {Object} [opt]\n * @param {Array.<Object|string>} [opt.dimsDef] option.series.dimensions User defined dimensions\n *      For example: ['asdf', {name, type}, ...].\n * @param {Object|HashMap} [opt.encodeDef] option.series.encode {x: 2, y: [3, 1], tooltip: [1, 2], label: 3}\n * @param {Function} [opt.encodeDefaulter] Called if no `opt.encodeDef` exists.\n *      If not specified, auto find the next available data dim.\n *      param source {module:data/Source}\n *      param dimCount {number}\n *      return {Object} encode Never be `null/undefined`.\n * @param {string} [opt.generateCoord] Generate coord dim with the given name.\n *      If not specified, extra dim names will be:\n *      'value', 'value0', 'value1', ...\n * @param {number} [opt.generateCoordCount] By default, the generated dim name is `generateCoord`.\n *      If `generateCoordCount` specified, the generated dim names will be:\n *      `generateCoord` + 0, `generateCoord` + 1, ...\n *      can be Infinity, indicate that use all of the remain columns.\n * @param {number} [opt.dimCount] If not specified, guess by the first data item.\n * @return {Array.<module:data/DataDimensionInfo>}\n */\nfunction completeDimensions(sysDims, source, opt) {\n  if (!Source.isInstance(source)) {\n    source = Source.seriesDataToSource(source);\n  }\n\n  opt = opt || {};\n  sysDims = (sysDims || []).slice();\n  var dimsDef = (opt.dimsDef || []).slice();\n  var dataDimNameMap = createHashMap();\n  var coordDimNameMap = createHashMap(); // var valueCandidate;\n\n  var result = [];\n  var dimCount = getDimCount(source, sysDims, dimsDef, opt.dimCount); // Apply user defined dims (`name` and `type`) and init result.\n\n  for (var i = 0; i < dimCount; i++) {\n    var dimDefItem = dimsDef[i] = extend({}, isObject(dimsDef[i]) ? dimsDef[i] : {\n      name: dimsDef[i]\n    });\n    var userDimName = dimDefItem.name;\n    var resultItem = result[i] = new DataDimensionInfo(); // Name will be applied later for avoiding duplication.\n\n    if (userDimName != null && dataDimNameMap.get(userDimName) == null) {\n      // Only if `series.dimensions` is defined in option\n      // displayName, will be set, and dimension will be diplayed vertically in\n      // tooltip by default.\n      resultItem.name = resultItem.displayName = userDimName;\n      dataDimNameMap.set(userDimName, i);\n    }\n\n    dimDefItem.type != null && (resultItem.type = dimDefItem.type);\n    dimDefItem.displayName != null && (resultItem.displayName = dimDefItem.displayName);\n  }\n\n  var encodeDef = opt.encodeDef;\n\n  if (!encodeDef && opt.encodeDefaulter) {\n    encodeDef = opt.encodeDefaulter(source, dimCount);\n  }\n\n  encodeDef = createHashMap(encodeDef); // Set `coordDim` and `coordDimIndex` by `encodeDef` and normalize `encodeDef`.\n\n  encodeDef.each(function (dataDims, coordDim) {\n    dataDims = normalizeToArray(dataDims).slice(); // Note: It is allowed that `dataDims.length` is `0`, e.g., options is\n    // `{encode: {x: -1, y: 1}}`. Should not filter anything in\n    // this case.\n\n    if (dataDims.length === 1 && !isString(dataDims[0]) && dataDims[0] < 0) {\n      encodeDef.set(coordDim, false);\n      return;\n    }\n\n    var validDataDims = encodeDef.set(coordDim, []);\n    each(dataDims, function (resultDimIdx, idx) {\n      // The input resultDimIdx can be dim name or index.\n      isString(resultDimIdx) && (resultDimIdx = dataDimNameMap.get(resultDimIdx));\n\n      if (resultDimIdx != null && resultDimIdx < dimCount) {\n        validDataDims[idx] = resultDimIdx;\n        applyDim(result[resultDimIdx], coordDim, idx);\n      }\n    });\n  }); // Apply templetes and default order from `sysDims`.\n\n  var availDimIdx = 0;\n  each(sysDims, function (sysDimItem, sysDimIndex) {\n    var coordDim;\n    var sysDimItem;\n    var sysDimItemDimsDef;\n    var sysDimItemOtherDims;\n\n    if (isString(sysDimItem)) {\n      coordDim = sysDimItem;\n      sysDimItem = {};\n    } else {\n      coordDim = sysDimItem.name;\n      var ordinalMeta = sysDimItem.ordinalMeta;\n      sysDimItem.ordinalMeta = null;\n      sysDimItem = clone(sysDimItem);\n      sysDimItem.ordinalMeta = ordinalMeta; // `coordDimIndex` should not be set directly.\n\n      sysDimItemDimsDef = sysDimItem.dimsDef;\n      sysDimItemOtherDims = sysDimItem.otherDims;\n      sysDimItem.name = sysDimItem.coordDim = sysDimItem.coordDimIndex = sysDimItem.dimsDef = sysDimItem.otherDims = null;\n    }\n\n    var dataDims = encodeDef.get(coordDim); // negative resultDimIdx means no need to mapping.\n\n    if (dataDims === false) {\n      return;\n    }\n\n    var dataDims = normalizeToArray(dataDims); // dimensions provides default dim sequences.\n\n    if (!dataDims.length) {\n      for (var i = 0; i < (sysDimItemDimsDef && sysDimItemDimsDef.length || 1); i++) {\n        while (availDimIdx < result.length && result[availDimIdx].coordDim != null) {\n          availDimIdx++;\n        }\n\n        availDimIdx < result.length && dataDims.push(availDimIdx++);\n      }\n    } // Apply templates.\n\n\n    each(dataDims, function (resultDimIdx, coordDimIndex) {\n      var resultItem = result[resultDimIdx];\n      applyDim(defaults(resultItem, sysDimItem), coordDim, coordDimIndex);\n\n      if (resultItem.name == null && sysDimItemDimsDef) {\n        var sysDimItemDimsDefItem = sysDimItemDimsDef[coordDimIndex];\n        !isObject(sysDimItemDimsDefItem) && (sysDimItemDimsDefItem = {\n          name: sysDimItemDimsDefItem\n        });\n        resultItem.name = resultItem.displayName = sysDimItemDimsDefItem.name;\n        resultItem.defaultTooltip = sysDimItemDimsDefItem.defaultTooltip;\n      } // FIXME refactor, currently only used in case: {otherDims: {tooltip: false}}\n\n\n      sysDimItemOtherDims && defaults(resultItem.otherDims, sysDimItemOtherDims);\n    });\n  });\n\n  function applyDim(resultItem, coordDim, coordDimIndex) {\n    if (OTHER_DIMENSIONS.get(coordDim) != null) {\n      resultItem.otherDims[coordDim] = coordDimIndex;\n    } else {\n      resultItem.coordDim = coordDim;\n      resultItem.coordDimIndex = coordDimIndex;\n      coordDimNameMap.set(coordDim, true);\n    }\n  } // Make sure the first extra dim is 'value'.\n\n\n  var generateCoord = opt.generateCoord;\n  var generateCoordCount = opt.generateCoordCount;\n  var fromZero = generateCoordCount != null;\n  generateCoordCount = generateCoord ? generateCoordCount || 1 : 0;\n  var extra = generateCoord || 'value'; // Set dim `name` and other `coordDim` and other props.\n\n  for (var resultDimIdx = 0; resultDimIdx < dimCount; resultDimIdx++) {\n    var resultItem = result[resultDimIdx] = result[resultDimIdx] || new DataDimensionInfo();\n    var coordDim = resultItem.coordDim;\n\n    if (coordDim == null) {\n      resultItem.coordDim = genName(extra, coordDimNameMap, fromZero);\n      resultItem.coordDimIndex = 0;\n\n      if (!generateCoord || generateCoordCount <= 0) {\n        resultItem.isExtraCoord = true;\n      }\n\n      generateCoordCount--;\n    }\n\n    resultItem.name == null && (resultItem.name = genName(resultItem.coordDim, dataDimNameMap));\n\n    if (resultItem.type == null && (guessOrdinal(source, resultDimIdx, resultItem.name) === BE_ORDINAL.Must // Consider the case:\n    // {\n    //    dataset: {source: [\n    //        ['2001', 123],\n    //        ['2002', 456],\n    //        ...\n    //        ['The others', 987],\n    //    ]},\n    //    series: {type: 'pie'}\n    // }\n    // The first colum should better be treated as a \"ordinal\" although it\n    // might not able to be detected as an \"ordinal\" by `guessOrdinal`.\n    || resultItem.isExtraCoord && (resultItem.otherDims.itemName != null || resultItem.otherDims.seriesName != null))) {\n      resultItem.type = 'ordinal';\n    }\n  }\n\n  return result;\n} // ??? TODO\n// Originally detect dimCount by data[0]. Should we\n// optimize it to only by sysDims and dimensions and encode.\n// So only necessary dims will be initialized.\n// But\n// (1) custom series should be considered. where other dims\n// may be visited.\n// (2) sometimes user need to calcualte bubble size or use visualMap\n// on other dimensions besides coordSys needed.\n// So, dims that is not used by system, should be shared in storage?\n\n\nfunction getDimCount(source, sysDims, dimsDef, optDimCount) {\n  // Note that the result dimCount should not small than columns count\n  // of data, otherwise `dataDimNameMap` checking will be incorrect.\n  var dimCount = Math.max(source.dimensionsDetectCount || 1, sysDims.length, dimsDef.length, optDimCount || 0);\n  each(sysDims, function (sysDimItem) {\n    var sysDimItemDimsDef = sysDimItem.dimsDef;\n    sysDimItemDimsDef && (dimCount = Math.max(dimCount, sysDimItemDimsDef.length));\n  });\n  return dimCount;\n}\n\nfunction genName(name, map, fromZero) {\n  if (fromZero || map.get(name) != null) {\n    var i = 0;\n\n    while (map.get(name + i) != null) {\n      i++;\n    }\n\n    name += i;\n  }\n\n  map.set(name, true);\n  return name;\n}\n\nvar _default = completeDimensions;\nmodule.exports = _default;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar completeDimensions = require(\"./completeDimensions\");\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * Substitute `completeDimensions`.\n * `completeDimensions` is to be deprecated.\n */\n\n/**\n * @param {module:echarts/data/Source|module:echarts/data/List} source or data.\n * @param {Object|Array} [opt]\n * @param {Array.<string|Object>} [opt.coordDimensions=[]]\n * @param {number} [opt.dimensionsCount]\n * @param {string} [opt.generateCoord]\n * @param {string} [opt.generateCoordCount]\n * @param {Array.<string|Object>} [opt.dimensionsDefine=source.dimensionsDefine] Overwrite source define.\n * @param {Object|HashMap} [opt.encodeDefine=source.encodeDefine] Overwrite source define.\n * @param {Function} [opt.encodeDefaulter] Make default encode if user not specified.\n * @return {Array.<Object>} dimensionsInfo\n */\nfunction _default(source, opt) {\n  opt = opt || {};\n  return completeDimensions(opt.coordDimensions || [], source, {\n    dimsDef: opt.dimensionsDefine || source.dimensionsDefine,\n    encodeDef: opt.encodeDefine || source.encodeDefine,\n    dimCount: opt.dimensionsCount,\n    encodeDefaulter: opt.encodeDefaulter,\n    generateCoord: opt.generateCoord,\n    generateCoordCount: opt.generateCoordCount\n  });\n}\n\nmodule.exports = _default;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _config = require(\"../../config\");\n\nvar __DEV__ = _config.__DEV__;\n\nvar _util = require(\"zrender/lib/core/util\");\n\nvar isTypedArray = _util.isTypedArray;\nvar extend = _util.extend;\nvar assert = _util.assert;\nvar each = _util.each;\nvar isObject = _util.isObject;\n\nvar _model = require(\"../../util/model\");\n\nvar getDataItemValue = _model.getDataItemValue;\nvar isDataItemOption = _model.isDataItemOption;\n\nvar _number = require(\"../../util/number\");\n\nvar parseDate = _number.parseDate;\n\nvar Source = require(\"../Source\");\n\nvar _sourceType = require(\"./sourceType\");\n\nvar SOURCE_FORMAT_TYPED_ARRAY = _sourceType.SOURCE_FORMAT_TYPED_ARRAY;\nvar SOURCE_FORMAT_ARRAY_ROWS = _sourceType.SOURCE_FORMAT_ARRAY_ROWS;\nvar SOURCE_FORMAT_ORIGINAL = _sourceType.SOURCE_FORMAT_ORIGINAL;\nvar SOURCE_FORMAT_OBJECT_ROWS = _sourceType.SOURCE_FORMAT_OBJECT_ROWS;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n// TODO\n// ??? refactor? check the outer usage of data provider.\n// merge with defaultDimValueGetter?\n\n/**\n * If normal array used, mutable chunk size is supported.\n * If typed array used, chunk size must be fixed.\n */\nfunction DefaultDataProvider(source, dimSize) {\n  if (!Source.isInstance(source)) {\n    source = Source.seriesDataToSource(source);\n  }\n\n  this._source = source;\n  var data = this._data = source.data;\n  var sourceFormat = source.sourceFormat; // Typed array. TODO IE10+?\n\n  if (sourceFormat === SOURCE_FORMAT_TYPED_ARRAY) {\n    this._offset = 0;\n    this._dimSize = dimSize;\n    this._data = data;\n  }\n\n  var methods = providerMethods[sourceFormat === SOURCE_FORMAT_ARRAY_ROWS ? sourceFormat + '_' + source.seriesLayoutBy : sourceFormat];\n  extend(this, methods);\n}\n\nvar providerProto = DefaultDataProvider.prototype; // If data is pure without style configuration\n\nproviderProto.pure = false; // If data is persistent and will not be released after use.\n\nproviderProto.persistent = true; // ???! FIXME legacy data provider do not has method getSource\n\nproviderProto.getSource = function () {\n  return this._source;\n};\n\nvar providerMethods = {\n  'arrayRows_column': {\n    pure: true,\n    count: function () {\n      return Math.max(0, this._data.length - this._source.startIndex);\n    },\n    getItem: function (idx) {\n      return this._data[idx + this._source.startIndex];\n    },\n    appendData: appendDataSimply\n  },\n  'arrayRows_row': {\n    pure: true,\n    count: function () {\n      var row = this._data[0];\n      return row ? Math.max(0, row.length - this._source.startIndex) : 0;\n    },\n    getItem: function (idx) {\n      idx += this._source.startIndex;\n      var item = [];\n      var data = this._data;\n\n      for (var i = 0; i < data.length; i++) {\n        var row = data[i];\n        item.push(row ? row[idx] : null);\n      }\n\n      return item;\n    },\n    appendData: function () {\n      throw new Error('Do not support appendData when set seriesLayoutBy: \"row\".');\n    }\n  },\n  'objectRows': {\n    pure: true,\n    count: countSimply,\n    getItem: getItemSimply,\n    appendData: appendDataSimply\n  },\n  'keyedColumns': {\n    pure: true,\n    count: function () {\n      var dimName = this._source.dimensionsDefine[0].name;\n      var col = this._data[dimName];\n      return col ? col.length : 0;\n    },\n    getItem: function (idx) {\n      var item = [];\n      var dims = this._source.dimensionsDefine;\n\n      for (var i = 0; i < dims.length; i++) {\n        var col = this._data[dims[i].name];\n        item.push(col ? col[idx] : null);\n      }\n\n      return item;\n    },\n    appendData: function (newData) {\n      var data = this._data;\n      each(newData, function (newCol, key) {\n        var oldCol = data[key] || (data[key] = []);\n\n        for (var i = 0; i < (newCol || []).length; i++) {\n          oldCol.push(newCol[i]);\n        }\n      });\n    }\n  },\n  'original': {\n    count: countSimply,\n    getItem: getItemSimply,\n    appendData: appendDataSimply\n  },\n  'typedArray': {\n    persistent: false,\n    pure: true,\n    count: function () {\n      return this._data ? this._data.length / this._dimSize : 0;\n    },\n    getItem: function (idx, out) {\n      idx = idx - this._offset;\n      out = out || [];\n      var offset = this._dimSize * idx;\n\n      for (var i = 0; i < this._dimSize; i++) {\n        out[i] = this._data[offset + i];\n      }\n\n      return out;\n    },\n    appendData: function (newData) {\n      this._data = newData;\n    },\n    // Clean self if data is already used.\n    clean: function () {\n      // PENDING\n      this._offset += this.count();\n      this._data = null;\n    }\n  }\n};\n\nfunction countSimply() {\n  return this._data.length;\n}\n\nfunction getItemSimply(idx) {\n  return this._data[idx];\n}\n\nfunction appendDataSimply(newData) {\n  for (var i = 0; i < newData.length; i++) {\n    this._data.push(newData[i]);\n  }\n}\n\nvar rawValueGetters = {\n  arrayRows: getRawValueSimply,\n  objectRows: function (dataItem, dataIndex, dimIndex, dimName) {\n    return dimIndex != null ? dataItem[dimName] : dataItem;\n  },\n  keyedColumns: getRawValueSimply,\n  original: function (dataItem, dataIndex, dimIndex, dimName) {\n    // FIXME\n    // In some case (markpoint in geo (geo-map.html)), dataItem\n    // is {coord: [...]}\n    var value = getDataItemValue(dataItem);\n    return dimIndex == null || !(value instanceof Array) ? value : value[dimIndex];\n  },\n  typedArray: getRawValueSimply\n};\n\nfunction getRawValueSimply(dataItem, dataIndex, dimIndex, dimName) {\n  return dimIndex != null ? dataItem[dimIndex] : dataItem;\n}\n\nvar defaultDimValueGetters = {\n  arrayRows: getDimValueSimply,\n  objectRows: function (dataItem, dimName, dataIndex, dimIndex) {\n    return converDataValue(dataItem[dimName], this._dimensionInfos[dimName]);\n  },\n  keyedColumns: getDimValueSimply,\n  original: function (dataItem, dimName, dataIndex, dimIndex) {\n    // Performance sensitive, do not use modelUtil.getDataItemValue.\n    // If dataItem is an plain object with no value field, the var `value`\n    // will be assigned with the object, but it will be tread correctly\n    // in the `convertDataValue`.\n    var value = dataItem && (dataItem.value == null ? dataItem : dataItem.value); // If any dataItem is like { value: 10 }\n\n    if (!this._rawData.pure && isDataItemOption(dataItem)) {\n      this.hasItemOption = true;\n    }\n\n    return converDataValue(value instanceof Array ? value[dimIndex] // If value is a single number or something else not array.\n    : value, this._dimensionInfos[dimName]);\n  },\n  typedArray: function (dataItem, dimName, dataIndex, dimIndex) {\n    return dataItem[dimIndex];\n  }\n};\n\nfunction getDimValueSimply(dataItem, dimName, dataIndex, dimIndex) {\n  return converDataValue(dataItem[dimIndex], this._dimensionInfos[dimName]);\n}\n/**\n * This helper method convert value in data.\n * @param {string|number|Date} value\n * @param {Object|string} [dimInfo] If string (like 'x'), dimType defaults 'number'.\n *        If \"dimInfo.ordinalParseAndSave\", ordinal value can be parsed.\n */\n\n\nfunction converDataValue(value, dimInfo) {\n  // Performance sensitive.\n  var dimType = dimInfo && dimInfo.type;\n\n  if (dimType === 'ordinal') {\n    // If given value is a category string\n    var ordinalMeta = dimInfo && dimInfo.ordinalMeta;\n    return ordinalMeta ? ordinalMeta.parseAndCollect(value) : value;\n  }\n\n  if (dimType === 'time' // spead up when using timestamp\n  && typeof value !== 'number' && value != null && value !== '-') {\n    value = +parseDate(value);\n  } // dimType defaults 'number'.\n  // If dimType is not ordinal and value is null or undefined or NaN or '-',\n  // parse to NaN.\n\n\n  return value == null || value === '' ? NaN // If string (like '-'), using '+' parse to NaN\n  // If object, also parse to NaN\n  : +value;\n} // ??? FIXME can these logic be more neat: getRawValue, getRawDataItem,\n// Consider persistent.\n// Caution: why use raw value to display on label or tooltip?\n// A reason is to avoid format. For example time value we do not know\n// how to format is expected. More over, if stack is used, calculated\n// value may be 0.91000000001, which have brings trouble to display.\n// TODO: consider how to treat null/undefined/NaN when display?\n\n/**\n * @param {module:echarts/data/List} data\n * @param {number} dataIndex\n * @param {string|number} [dim] dimName or dimIndex\n * @return {Array.<number>|string|number} can be null/undefined.\n */\n\n\nfunction retrieveRawValue(data, dataIndex, dim) {\n  if (!data) {\n    return;\n  } // Consider data may be not persistent.\n\n\n  var dataItem = data.getRawDataItem(dataIndex);\n\n  if (dataItem == null) {\n    return;\n  }\n\n  var sourceFormat = data.getProvider().getSource().sourceFormat;\n  var dimName;\n  var dimIndex;\n  var dimInfo = data.getDimensionInfo(dim);\n\n  if (dimInfo) {\n    dimName = dimInfo.name;\n    dimIndex = dimInfo.index;\n  }\n\n  return rawValueGetters[sourceFormat](dataItem, dataIndex, dimIndex, dimName);\n}\n/**\n * Compatible with some cases (in pie, map) like:\n * data: [{name: 'xx', value: 5, selected: true}, ...]\n * where only sourceFormat is 'original' and 'objectRows' supported.\n *\n * ??? TODO\n * Supported detail options in data item when using 'arrayRows'.\n *\n * @param {module:echarts/data/List} data\n * @param {number} dataIndex\n * @param {string} attr like 'selected'\n */\n\n\nfunction retrieveRawAttr(data, dataIndex, attr) {\n  if (!data) {\n    return;\n  }\n\n  var sourceFormat = data.getProvider().getSource().sourceFormat;\n\n  if (sourceFormat !== SOURCE_FORMAT_ORIGINAL && sourceFormat !== SOURCE_FORMAT_OBJECT_ROWS) {\n    return;\n  }\n\n  var dataItem = data.getRawDataItem(dataIndex);\n\n  if (sourceFormat === SOURCE_FORMAT_ORIGINAL && !isObject(dataItem)) {\n    dataItem = null;\n  }\n\n  if (dataItem) {\n    return dataItem[attr];\n  }\n}\n\nexports.DefaultDataProvider = DefaultDataProvider;\nexports.defaultDimValueGetters = defaultDimValueGetters;\nexports.retrieveRawValue = retrieveRawValue;\nexports.retrieveRawAttr = retrieveRawAttr;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _util = require(\"zrender/lib/core/util\");\n\nvar each = _util.each;\nvar isString = _util.isString;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * Note that it is too complicated to support 3d stack by value\n * (have to create two-dimension inverted index), so in 3d case\n * we just support that stacked by index.\n *\n * @param {module:echarts/model/Series} seriesModel\n * @param {Array.<string|Object>} dimensionInfoList The same as the input of <module:echarts/data/List>.\n *        The input dimensionInfoList will be modified.\n * @param {Object} [opt]\n * @param {boolean} [opt.stackedCoordDimension=''] Specify a coord dimension if needed.\n * @param {boolean} [opt.byIndex=false]\n * @return {Object} calculationInfo\n * {\n *     stackedDimension: string\n *     stackedByDimension: string\n *     isStackedByIndex: boolean\n *     stackedOverDimension: string\n *     stackResultDimension: string\n * }\n */\nfunction enableDataStack(seriesModel, dimensionInfoList, opt) {\n  opt = opt || {};\n  var byIndex = opt.byIndex;\n  var stackedCoordDimension = opt.stackedCoordDimension; // Compatibal: when `stack` is set as '', do not stack.\n\n  var mayStack = !!(seriesModel && seriesModel.get('stack'));\n  var stackedByDimInfo;\n  var stackedDimInfo;\n  var stackResultDimension;\n  var stackedOverDimension;\n  each(dimensionInfoList, function (dimensionInfo, index) {\n    if (isString(dimensionInfo)) {\n      dimensionInfoList[index] = dimensionInfo = {\n        name: dimensionInfo\n      };\n    }\n\n    if (mayStack && !dimensionInfo.isExtraCoord) {\n      // Find the first ordinal dimension as the stackedByDimInfo.\n      if (!byIndex && !stackedByDimInfo && dimensionInfo.ordinalMeta) {\n        stackedByDimInfo = dimensionInfo;\n      } // Find the first stackable dimension as the stackedDimInfo.\n\n\n      if (!stackedDimInfo && dimensionInfo.type !== 'ordinal' && dimensionInfo.type !== 'time' && (!stackedCoordDimension || stackedCoordDimension === dimensionInfo.coordDim)) {\n        stackedDimInfo = dimensionInfo;\n      }\n    }\n  });\n\n  if (stackedDimInfo && !byIndex && !stackedByDimInfo) {\n    // Compatible with previous design, value axis (time axis) only stack by index.\n    // It may make sense if the user provides elaborately constructed data.\n    byIndex = true;\n  } // Add stack dimension, they can be both calculated by coordinate system in `unionExtent`.\n  // That put stack logic in List is for using conveniently in echarts extensions, but it\n  // might not be a good way.\n\n\n  if (stackedDimInfo) {\n    // Use a weird name that not duplicated with other names.\n    stackResultDimension = '__\\0ecstackresult';\n    stackedOverDimension = '__\\0ecstackedover'; // Create inverted index to fast query index by value.\n\n    if (stackedByDimInfo) {\n      stackedByDimInfo.createInvertedIndices = true;\n    }\n\n    var stackedDimCoordDim = stackedDimInfo.coordDim;\n    var stackedDimType = stackedDimInfo.type;\n    var stackedDimCoordIndex = 0;\n    each(dimensionInfoList, function (dimensionInfo) {\n      if (dimensionInfo.coordDim === stackedDimCoordDim) {\n        stackedDimCoordIndex++;\n      }\n    });\n    dimensionInfoList.push({\n      name: stackResultDimension,\n      coordDim: stackedDimCoordDim,\n      coordDimIndex: stackedDimCoordIndex,\n      type: stackedDimType,\n      isExtraCoord: true,\n      isCalculationCoord: true\n    });\n    stackedDimCoordIndex++;\n    dimensionInfoList.push({\n      name: stackedOverDimension,\n      // This dimension contains stack base (generally, 0), so do not set it as\n      // `stackedDimCoordDim` to avoid extent calculation, consider log scale.\n      coordDim: stackedOverDimension,\n      coordDimIndex: stackedDimCoordIndex,\n      type: stackedDimType,\n      isExtraCoord: true,\n      isCalculationCoord: true\n    });\n  }\n\n  return {\n    stackedDimension: stackedDimInfo && stackedDimInfo.name,\n    stackedByDimension: stackedByDimInfo && stackedByDimInfo.name,\n    isStackedByIndex: byIndex,\n    stackedOverDimension: stackedOverDimension,\n    stackResultDimension: stackResultDimension\n  };\n}\n/**\n * @param {module:echarts/data/List} data\n * @param {string} stackedDim\n */\n\n\nfunction isDimensionStacked(data, stackedDim\n/*, stackedByDim*/\n) {\n  // Each single series only maps to one pair of axis. So we do not need to\n  // check stackByDim, whatever stacked by a dimension or stacked by index.\n  return !!stackedDim && stackedDim === data.getCalculationInfo('stackedDimension'); // && (\n  //     stackedByDim != null\n  //         ? stackedByDim === data.getCalculationInfo('stackedByDimension')\n  //         : data.getCalculationInfo('isStackedByIndex')\n  // );\n}\n/**\n * @param {module:echarts/data/List} data\n * @param {string} targetDim\n * @param {string} [stackedByDim] If not input this parameter, check whether\n *                                stacked by index.\n * @return {string} dimension\n */\n\n\nfunction getStackedDimension(data, targetDim) {\n  return isDimensionStacked(data, targetDim) ? data.getCalculationInfo('stackResultDimension') : targetDim;\n}\n\nexports.enableDataStack = enableDataStack;\nexports.isDimensionStacked = isDimensionStacked;\nexports.getStackedDimension = getStackedDimension;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _util = require(\"zrender/lib/core/util\");\n\nvar each = _util.each;\nvar createHashMap = _util.createHashMap;\nvar assert = _util.assert;\n\nvar _config = require(\"../../config\");\n\nvar __DEV__ = _config.__DEV__;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\nvar OTHER_DIMENSIONS = createHashMap(['tooltip', 'label', 'itemName', 'itemId', 'seriesName']);\n\nfunction summarizeDimensions(data) {\n  var summary = {};\n  var encode = summary.encode = {};\n  var notExtraCoordDimMap = createHashMap();\n  var defaultedLabel = [];\n  var defaultedTooltip = []; // See the comment of `List.js#userOutput`.\n\n  var userOutput = summary.userOutput = {\n    dimensionNames: data.dimensions.slice(),\n    encode: {}\n  };\n  each(data.dimensions, function (dimName) {\n    var dimItem = data.getDimensionInfo(dimName);\n    var coordDim = dimItem.coordDim;\n\n    if (coordDim) {\n      var coordDimIndex = dimItem.coordDimIndex;\n      getOrCreateEncodeArr(encode, coordDim)[coordDimIndex] = dimName;\n\n      if (!dimItem.isExtraCoord) {\n        notExtraCoordDimMap.set(coordDim, 1); // Use the last coord dim (and label friendly) as default label,\n        // because when dataset is used, it is hard to guess which dimension\n        // can be value dimension. If both show x, y on label is not look good,\n        // and conventionally y axis is focused more.\n\n        if (mayLabelDimType(dimItem.type)) {\n          defaultedLabel[0] = dimName;\n        } // User output encode do not contain generated coords.\n        // And it only has index. User can use index to retrieve value from the raw item array.\n\n\n        getOrCreateEncodeArr(userOutput.encode, coordDim)[coordDimIndex] = dimItem.index;\n      }\n\n      if (dimItem.defaultTooltip) {\n        defaultedTooltip.push(dimName);\n      }\n    }\n\n    OTHER_DIMENSIONS.each(function (v, otherDim) {\n      var encodeArr = getOrCreateEncodeArr(encode, otherDim);\n      var dimIndex = dimItem.otherDims[otherDim];\n\n      if (dimIndex != null && dimIndex !== false) {\n        encodeArr[dimIndex] = dimItem.name;\n      }\n    });\n  });\n  var dataDimsOnCoord = [];\n  var encodeFirstDimNotExtra = {};\n  notExtraCoordDimMap.each(function (v, coordDim) {\n    var dimArr = encode[coordDim]; // ??? FIXME extra coord should not be set in dataDimsOnCoord.\n    // But should fix the case that radar axes: simplify the logic\n    // of `completeDimension`, remove `extraPrefix`.\n\n    encodeFirstDimNotExtra[coordDim] = dimArr[0]; // Not necessary to remove duplicate, because a data\n    // dim canot on more than one coordDim.\n\n    dataDimsOnCoord = dataDimsOnCoord.concat(dimArr);\n  });\n  summary.dataDimsOnCoord = dataDimsOnCoord;\n  summary.encodeFirstDimNotExtra = encodeFirstDimNotExtra;\n  var encodeLabel = encode.label; // FIXME `encode.label` is not recommanded, because formatter can not be set\n  // in this way. Use label.formatter instead. May be remove this approach someday.\n\n  if (encodeLabel && encodeLabel.length) {\n    defaultedLabel = encodeLabel.slice();\n  }\n\n  var encodeTooltip = encode.tooltip;\n\n  if (encodeTooltip && encodeTooltip.length) {\n    defaultedTooltip = encodeTooltip.slice();\n  } else if (!defaultedTooltip.length) {\n    defaultedTooltip = defaultedLabel.slice();\n  }\n\n  encode.defaultedLabel = defaultedLabel;\n  encode.defaultedTooltip = defaultedTooltip;\n  return summary;\n}\n\nfunction getOrCreateEncodeArr(encode, dim) {\n  if (!encode.hasOwnProperty(dim)) {\n    encode[dim] = [];\n  }\n\n  return encode[dim];\n}\n\nfunction getDimensionTypeByAxis(axisType) {\n  return axisType === 'category' ? 'ordinal' : axisType === 'time' ? 'time' : 'float';\n}\n\nfunction mayLabelDimType(dimType) {\n  // In most cases, ordinal and time do not suitable for label.\n  // Ordinal info can be displayed on axis. Time is too long.\n  return !(dimType === 'ordinal' || dimType === 'time');\n} // function findTheLastDimMayLabel(data) {\n//     // Get last value dim\n//     var dimensions = data.dimensions.slice();\n//     var valueType;\n//     var valueDim;\n//     while (dimensions.length && (\n//         valueDim = dimensions.pop(),\n//         valueType = data.getDimensionInfo(valueDim).type,\n//         valueType === 'ordinal' || valueType === 'time'\n//     )) {} // jshint ignore:line\n//     return valueDim;\n// }\n\n\nexports.OTHER_DIMENSIONS = OTHER_DIMENSIONS;\nexports.summarizeDimensions = summarizeDimensions;\nexports.getDimensionTypeByAxis = getDimensionTypeByAxis;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar zrUtil = require(\"zrender/lib/core/util\");\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/**\n * Link lists and struct (graph or tree)\n */\nvar each = zrUtil.each;\nvar DATAS = '\\0__link_datas';\nvar MAIN_DATA = '\\0__link_mainData'; // Caution:\n// In most case, either list or its shallow clones (see list.cloneShallow)\n// is active in echarts process. So considering heap memory consumption,\n// we do not clone tree or graph, but share them among list and its shallow clones.\n// But in some rare case, we have to keep old list (like do animation in chart). So\n// please take care that both the old list and the new list share the same tree/graph.\n\n/**\n * @param {Object} opt\n * @param {module:echarts/data/List} opt.mainData\n * @param {Object} [opt.struct] For example, instance of Graph or Tree.\n * @param {string} [opt.structAttr] designation: list[structAttr] = struct;\n * @param {Object} [opt.datas] {dataType: data},\n *                 like: {node: nodeList, edge: edgeList}.\n *                 Should contain mainData.\n * @param {Object} [opt.datasAttr] {dataType: attr},\n *                 designation: struct[datasAttr[dataType]] = list;\n */\n\nfunction linkList(opt) {\n  var mainData = opt.mainData;\n  var datas = opt.datas;\n\n  if (!datas) {\n    datas = {\n      main: mainData\n    };\n    opt.datasAttr = {\n      main: 'data'\n    };\n  }\n\n  opt.datas = opt.mainData = null;\n  linkAll(mainData, datas, opt); // Porxy data original methods.\n\n  each(datas, function (data) {\n    each(mainData.TRANSFERABLE_METHODS, function (methodName) {\n      data.wrapMethod(methodName, zrUtil.curry(transferInjection, opt));\n    });\n  }); // Beyond transfer, additional features should be added to `cloneShallow`.\n\n  mainData.wrapMethod('cloneShallow', zrUtil.curry(cloneShallowInjection, opt)); // Only mainData trigger change, because struct.update may trigger\n  // another changable methods, which may bring about dead lock.\n\n  each(mainData.CHANGABLE_METHODS, function (methodName) {\n    mainData.wrapMethod(methodName, zrUtil.curry(changeInjection, opt));\n  }); // Make sure datas contains mainData.\n\n  zrUtil.assert(datas[mainData.dataType] === mainData);\n}\n\nfunction transferInjection(opt, res) {\n  if (isMainData(this)) {\n    // Transfer datas to new main data.\n    var datas = zrUtil.extend({}, this[DATAS]);\n    datas[this.dataType] = res;\n    linkAll(res, datas, opt);\n  } else {\n    // Modify the reference in main data to point newData.\n    linkSingle(res, this.dataType, this[MAIN_DATA], opt);\n  }\n\n  return res;\n}\n\nfunction changeInjection(opt, res) {\n  opt.struct && opt.struct.update(this);\n  return res;\n}\n\nfunction cloneShallowInjection(opt, res) {\n  // cloneShallow, which brings about some fragilities, may be inappropriate\n  // to be exposed as an API. So for implementation simplicity we can make\n  // the restriction that cloneShallow of not-mainData should not be invoked\n  // outside, but only be invoked here.\n  each(res[DATAS], function (data, dataType) {\n    data !== res && linkSingle(data.cloneShallow(), dataType, res, opt);\n  });\n  return res;\n}\n/**\n * Supplement method to List.\n *\n * @public\n * @param {string} [dataType] If not specified, return mainData.\n * @return {module:echarts/data/List}\n */\n\n\nfunction getLinkedData(dataType) {\n  var mainData = this[MAIN_DATA];\n  return dataType == null || mainData == null ? mainData : mainData[DATAS][dataType];\n}\n\nfunction isMainData(data) {\n  return data[MAIN_DATA] === data;\n}\n\nfunction linkAll(mainData, datas, opt) {\n  mainData[DATAS] = {};\n  each(datas, function (data, dataType) {\n    linkSingle(data, dataType, mainData, opt);\n  });\n}\n\nfunction linkSingle(data, dataType, mainData, opt) {\n  mainData[DATAS][dataType] = data;\n  data[MAIN_DATA] = mainData;\n  data.dataType = dataType;\n\n  if (opt.struct) {\n    data[opt.structAttr] = opt.struct;\n    opt.struct[opt.datasAttr[dataType]] = data;\n  } // Supplement method.\n\n\n  data.getLinkedData = getLinkedData;\n}\n\nvar _default = linkList;\nmodule.exports = _default;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\nvar _config = require(\"../../config\");\n\nvar __DEV__ = _config.__DEV__;\n\nvar _model = require(\"../../util/model\");\n\nvar makeInner = _model.makeInner;\nvar getDataItemValue = _model.getDataItemValue;\n\nvar _util = require(\"zrender/lib/core/util\");\n\nvar createHashMap = _util.createHashMap;\nvar each = _util.each;\nvar map = _util.map;\nvar isArray = _util.isArray;\nvar isString = _util.isString;\nvar isObject = _util.isObject;\nvar isTypedArray = _util.isTypedArray;\nvar isArrayLike = _util.isArrayLike;\nvar extend = _util.extend;\nvar assert = _util.assert;\n\nvar Source = require(\"../Source\");\n\nvar _sourceType = require(\"./sourceType\");\n\nvar SOURCE_FORMAT_ORIGINAL = _sourceType.SOURCE_FORMAT_ORIGINAL;\nvar SOURCE_FORMAT_ARRAY_ROWS = _sourceType.SOURCE_FORMAT_ARRAY_ROWS;\nvar SOURCE_FORMAT_OBJECT_ROWS = _sourceType.SOURCE_FORMAT_OBJECT_ROWS;\nvar SOURCE_FORMAT_KEYED_COLUMNS = _sourceType.SOURCE_FORMAT_KEYED_COLUMNS;\nvar SOURCE_FORMAT_UNKNOWN = _sourceType.SOURCE_FORMAT_UNKNOWN;\nvar SOURCE_FORMAT_TYPED_ARRAY = _sourceType.SOURCE_FORMAT_TYPED_ARRAY;\nvar SERIES_LAYOUT_BY_ROW = _sourceType.SERIES_LAYOUT_BY_ROW;\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n// The result of `guessOrdinal`.\nvar BE_ORDINAL = {\n  Must: 1,\n  // Encounter string but not '-' and not number-like.\n  Might: 2,\n  // Encounter string but number-like.\n  Not: 3 // Other cases\n\n};\nvar inner = makeInner();\n/**\n * @see {module:echarts/data/Source}\n * @param {module:echarts/component/dataset/DatasetModel} datasetModel\n * @return {string} sourceFormat\n */\n\nfunction detectSourceFormat(datasetModel) {\n  var data = datasetModel.option.source;\n  var sourceFormat = SOURCE_FORMAT_UNKNOWN;\n\n  if (isTypedArray(data)) {\n    sourceFormat = SOURCE_FORMAT_TYPED_ARRAY;\n  } else if (isArray(data)) {\n    // FIXME Whether tolerate null in top level array?\n    if (data.length === 0) {\n      sourceFormat = SOURCE_FORMAT_ARRAY_ROWS;\n    }\n\n    for (var i = 0, len = data.length; i < len; i++) {\n      var item = data[i];\n\n      if (item == null) {\n        continue;\n      } else if (isArray(item)) {\n        sourceFormat = SOURCE_FORMAT_ARRAY_ROWS;\n        break;\n      } else if (isObject(item)) {\n        sourceFormat = SOURCE_FORMAT_OBJECT_ROWS;\n        break;\n      }\n    }\n  } else if (isObject(data)) {\n    for (var key in data) {\n      if (data.hasOwnProperty(key) && isArrayLike(data[key])) {\n        sourceFormat = SOURCE_FORMAT_KEYED_COLUMNS;\n        break;\n      }\n    }\n  } else if (data != null) {\n    throw new Error('Invalid data');\n  }\n\n  inner(datasetModel).sourceFormat = sourceFormat;\n}\n/**\n * [Scenarios]:\n * (1) Provide source data directly:\n *     series: {\n *         encode: {...},\n *         dimensions: [...]\n *         seriesLayoutBy: 'row',\n *         data: [[...]]\n *     }\n * (2) Refer to datasetModel.\n *     series: [{\n *         encode: {...}\n *         // Ignore datasetIndex means `datasetIndex: 0`\n *         // and the dimensions defination in dataset is used\n *     }, {\n *         encode: {...},\n *         seriesLayoutBy: 'column',\n *         datasetIndex: 1\n *     }]\n *\n * Get data from series itself or datset.\n * @return {module:echarts/data/Source} source\n */\n\n\nfunction getSource(seriesModel) {\n  return inner(seriesModel).source;\n}\n/**\n * MUST be called before mergeOption of all series.\n * @param {module:echarts/model/Global} ecModel\n */\n\n\nfunction resetSourceDefaulter(ecModel) {\n  // `datasetMap` is used to make default encode.\n  inner(ecModel).datasetMap = createHashMap();\n}\n/**\n * [Caution]:\n * MUST be called after series option merged and\n * before \"series.getInitailData()\" called.\n *\n * [The rule of making default encode]:\n * Category axis (if exists) alway map to the first dimension.\n * Each other axis occupies a subsequent dimension.\n *\n * [Why make default encode]:\n * Simplify the typing of encode in option, avoiding the case like that:\n * series: [{encode: {x: 0, y: 1}}, {encode: {x: 0, y: 2}}, {encode: {x: 0, y: 3}}],\n * where the \"y\" have to be manually typed as \"1, 2, 3, ...\".\n *\n * @param {module:echarts/model/Series} seriesModel\n */\n\n\nfunction prepareSource(seriesModel) {\n  var seriesOption = seriesModel.option;\n  var data = seriesOption.data;\n  var sourceFormat = isTypedArray(data) ? SOURCE_FORMAT_TYPED_ARRAY : SOURCE_FORMAT_ORIGINAL;\n  var fromDataset = false;\n  var seriesLayoutBy = seriesOption.seriesLayoutBy;\n  var sourceHeader = seriesOption.sourceHeader;\n  var dimensionsDefine = seriesOption.dimensions;\n  var datasetModel = getDatasetModel(seriesModel);\n\n  if (datasetModel) {\n    var datasetOption = datasetModel.option;\n    data = datasetOption.source;\n    sourceFormat = inner(datasetModel).sourceFormat;\n    fromDataset = true; // These settings from series has higher priority.\n\n    seriesLayoutBy = seriesLayoutBy || datasetOption.seriesLayoutBy;\n    sourceHeader == null && (sourceHeader = datasetOption.sourceHeader);\n    dimensionsDefine = dimensionsDefine || datasetOption.dimensions;\n  }\n\n  var completeResult = completeBySourceData(data, sourceFormat, seriesLayoutBy, sourceHeader, dimensionsDefine);\n  inner(seriesModel).source = new Source({\n    data: data,\n    fromDataset: fromDataset,\n    seriesLayoutBy: seriesLayoutBy,\n    sourceFormat: sourceFormat,\n    dimensionsDefine: completeResult.dimensionsDefine,\n    startIndex: completeResult.startIndex,\n    dimensionsDetectCount: completeResult.dimensionsDetectCount,\n    // Note: dataset option does not have `encode`.\n    encodeDefine: seriesOption.encode\n  });\n} // return {startIndex, dimensionsDefine, dimensionsCount}\n\n\nfunction completeBySourceData(data, sourceFormat, seriesLayoutBy, sourceHeader, dimensionsDefine) {\n  if (!data) {\n    return {\n      dimensionsDefine: normalizeDimensionsDefine(dimensionsDefine)\n    };\n  }\n\n  var dimensionsDetectCount;\n  var startIndex;\n\n  if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {\n    // Rule: Most of the first line are string: it is header.\n    // Caution: consider a line with 5 string and 1 number,\n    // it still can not be sure it is a head, because the\n    // 5 string may be 5 values of category columns.\n    if (sourceHeader === 'auto' || sourceHeader == null) {\n      arrayRowsTravelFirst(function (val) {\n        // '-' is regarded as null/undefined.\n        if (val != null && val !== '-') {\n          if (isString(val)) {\n            startIndex == null && (startIndex = 1);\n          } else {\n            startIndex = 0;\n          }\n        } // 10 is an experience number, avoid long loop.\n\n      }, seriesLayoutBy, data, 10);\n    } else {\n      startIndex = sourceHeader ? 1 : 0;\n    }\n\n    if (!dimensionsDefine && startIndex === 1) {\n      dimensionsDefine = [];\n      arrayRowsTravelFirst(function (val, index) {\n        dimensionsDefine[index] = val != null ? val : '';\n      }, seriesLayoutBy, data);\n    }\n\n    dimensionsDetectCount = dimensionsDefine ? dimensionsDefine.length : seriesLayoutBy === SERIES_LAYOUT_BY_ROW ? data.length : data[0] ? data[0].length : null;\n  } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {\n    if (!dimensionsDefine) {\n      dimensionsDefine = objectRowsCollectDimensions(data);\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {\n    if (!dimensionsDefine) {\n      dimensionsDefine = [];\n      each(data, function (colArr, key) {\n        dimensionsDefine.push(key);\n      });\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_ORIGINAL) {\n    var value0 = getDataItemValue(data[0]);\n    dimensionsDetectCount = isArray(value0) && value0.length || 1;\n  } else if (sourceFormat === SOURCE_FORMAT_TYPED_ARRAY) {}\n\n  return {\n    startIndex: startIndex,\n    dimensionsDefine: normalizeDimensionsDefine(dimensionsDefine),\n    dimensionsDetectCount: dimensionsDetectCount\n  };\n} // Consider dimensions defined like ['A', 'price', 'B', 'price', 'C', 'price'],\n// which is reasonable. But dimension name is duplicated.\n// Returns undefined or an array contains only object without null/undefiend or string.\n\n\nfunction normalizeDimensionsDefine(dimensionsDefine) {\n  if (!dimensionsDefine) {\n    // The meaning of null/undefined is different from empty array.\n    return;\n  }\n\n  var nameMap = createHashMap();\n  return map(dimensionsDefine, function (item, index) {\n    item = extend({}, isObject(item) ? item : {\n      name: item\n    }); // User can set null in dimensions.\n    // We dont auto specify name, othewise a given name may\n    // cause it be refered unexpectedly.\n\n    if (item.name == null) {\n      return item;\n    } // Also consider number form like 2012.\n\n\n    item.name += ''; // User may also specify displayName.\n    // displayName will always exists except user not\n    // specified or dim name is not specified or detected.\n    // (A auto generated dim name will not be used as\n    // displayName).\n\n    if (item.displayName == null) {\n      item.displayName = item.name;\n    }\n\n    var exist = nameMap.get(item.name);\n\n    if (!exist) {\n      nameMap.set(item.name, {\n        count: 1\n      });\n    } else {\n      item.name += '-' + exist.count++;\n    }\n\n    return item;\n  });\n}\n\nfunction arrayRowsTravelFirst(cb, seriesLayoutBy, data, maxLoop) {\n  maxLoop == null && (maxLoop = Infinity);\n\n  if (seriesLayoutBy === SERIES_LAYOUT_BY_ROW) {\n    for (var i = 0; i < data.length && i < maxLoop; i++) {\n      cb(data[i] ? data[i][0] : null, i);\n    }\n  } else {\n    var value0 = data[0] || [];\n\n    for (var i = 0; i < value0.length && i < maxLoop; i++) {\n      cb(value0[i], i);\n    }\n  }\n}\n\nfunction objectRowsCollectDimensions(data) {\n  var firstIndex = 0;\n  var obj;\n\n  while (firstIndex < data.length && !(obj = data[firstIndex++])) {} // jshint ignore: line\n\n\n  if (obj) {\n    var dimensions = [];\n    each(obj, function (value, key) {\n      dimensions.push(key);\n    });\n    return dimensions;\n  }\n}\n/**\n * [The strategy of the arrengment of data dimensions for dataset]:\n * \"value way\": all axes are non-category axes. So series one by one take\n *     several (the number is coordSysDims.length) dimensions from dataset.\n *     The result of data arrengment of data dimensions like:\n *     | ser0_x | ser0_y | ser1_x | ser1_y | ser2_x | ser2_y |\n * \"category way\": at least one axis is category axis. So the the first data\n *     dimension is always mapped to the first category axis and shared by\n *     all of the series. The other data dimensions are taken by series like\n *     \"value way\" does.\n *     The result of data arrengment of data dimensions like:\n *     | ser_shared_x | ser0_y | ser1_y | ser2_y |\n *\n * @param {Array.<Object|string>} coordDimensions [{name: <string>, type: <string>, dimsDef: <Array>}, ...]\n * @param {module:model/Series} seriesModel\n * @param {module:data/Source} source\n * @return {Object} encode Never be `null/undefined`.\n */\n\n\nfunction makeSeriesEncodeForAxisCoordSys(coordDimensions, seriesModel, source) {\n  var encode = {};\n  var datasetModel = getDatasetModel(seriesModel); // Currently only make default when using dataset, util more reqirements occur.\n\n  if (!datasetModel || !coordDimensions) {\n    return encode;\n  }\n\n  var encodeItemName = [];\n  var encodeSeriesName = [];\n  var ecModel = seriesModel.ecModel;\n  var datasetMap = inner(ecModel).datasetMap;\n  var key = datasetModel.uid + '_' + source.seriesLayoutBy;\n  var baseCategoryDimIndex;\n  var categoryWayValueDimStart;\n  coordDimensions = coordDimensions.slice();\n  each(coordDimensions, function (coordDimInfo, coordDimIdx) {\n    !isObject(coordDimInfo) && (coordDimensions[coordDimIdx] = {\n      name: coordDimInfo\n    });\n\n    if (coordDimInfo.type === 'ordinal' && baseCategoryDimIndex == null) {\n      baseCategoryDimIndex = coordDimIdx;\n      categoryWayValueDimStart = getDataDimCountOnCoordDim(coordDimensions[coordDimIdx]);\n    }\n\n    encode[coordDimInfo.name] = [];\n  });\n  var datasetRecord = datasetMap.get(key) || datasetMap.set(key, {\n    categoryWayDim: categoryWayValueDimStart,\n    valueWayDim: 0\n  }); // TODO\n  // Auto detect first time axis and do arrangement.\n\n  each(coordDimensions, function (coordDimInfo, coordDimIdx) {\n    var coordDimName = coordDimInfo.name;\n    var count = getDataDimCountOnCoordDim(coordDimInfo); // In value way.\n\n    if (baseCategoryDimIndex == null) {\n      var start = datasetRecord.valueWayDim;\n      pushDim(encode[coordDimName], start, count);\n      pushDim(encodeSeriesName, start, count);\n      datasetRecord.valueWayDim += count; // ??? TODO give a better default series name rule?\n      // especially when encode x y specified.\n      // consider: when mutiple series share one dimension\n      // category axis, series name should better use\n      // the other dimsion name. On the other hand, use\n      // both dimensions name.\n    } // In category way, the first category axis.\n    else if (baseCategoryDimIndex === coordDimIdx) {\n        pushDim(encode[coordDimName], 0, count);\n        pushDim(encodeItemName, 0, count);\n      } // In category way, the other axis.\n      else {\n          var start = datasetRecord.categoryWayDim;\n          pushDim(encode[coordDimName], start, count);\n          pushDim(encodeSeriesName, start, count);\n          datasetRecord.categoryWayDim += count;\n        }\n  });\n\n  function pushDim(dimIdxArr, idxFrom, idxCount) {\n    for (var i = 0; i < idxCount; i++) {\n      dimIdxArr.push(idxFrom + i);\n    }\n  }\n\n  function getDataDimCountOnCoordDim(coordDimInfo) {\n    var dimsDef = coordDimInfo.dimsDef;\n    return dimsDef ? dimsDef.length : 1;\n  }\n\n  encodeItemName.length && (encode.itemName = encodeItemName);\n  encodeSeriesName.length && (encode.seriesName = encodeSeriesName);\n  return encode;\n}\n/**\n * Work for data like [{name: ..., value: ...}, ...].\n *\n * @param {module:model/Series} seriesModel\n * @param {module:data/Source} source\n * @return {Object} encode Never be `null/undefined`.\n */\n\n\nfunction makeSeriesEncodeForNameBased(seriesModel, source, dimCount) {\n  var encode = {};\n  var datasetModel = getDatasetModel(seriesModel); // Currently only make default when using dataset, util more reqirements occur.\n\n  if (!datasetModel) {\n    return encode;\n  }\n\n  var sourceFormat = source.sourceFormat;\n  var dimensionsDefine = source.dimensionsDefine;\n  var potentialNameDimIndex;\n\n  if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS || sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {\n    each(dimensionsDefine, function (dim, idx) {\n      if ((isObject(dim) ? dim.name : dim) === 'name') {\n        potentialNameDimIndex = idx;\n      }\n    });\n  } // idxResult: {v, n}.\n\n\n  var idxResult = function () {\n    var idxRes0 = {};\n    var idxRes1 = {};\n    var guessRecords = []; // 5 is an experience value.\n\n    for (var i = 0, len = Math.min(5, dimCount); i < len; i++) {\n      var guessResult = doGuessOrdinal(source.data, sourceFormat, source.seriesLayoutBy, dimensionsDefine, source.startIndex, i);\n      guessRecords.push(guessResult);\n      var isPureNumber = guessResult === BE_ORDINAL.Not; // [Strategy of idxRes0]: find the first BE_ORDINAL.Not as the value dim,\n      // and then find a name dim with the priority:\n      // \"BE_ORDINAL.Might|BE_ORDINAL.Must\" > \"other dim\" > \"the value dim itself\".\n\n      if (isPureNumber && idxRes0.v == null && i !== potentialNameDimIndex) {\n        idxRes0.v = i;\n      }\n\n      if (idxRes0.n == null || idxRes0.n === idxRes0.v || !isPureNumber && guessRecords[idxRes0.n] === BE_ORDINAL.Not) {\n        idxRes0.n = i;\n      }\n\n      if (fulfilled(idxRes0) && guessRecords[idxRes0.n] !== BE_ORDINAL.Not) {\n        return idxRes0;\n      } // [Strategy of idxRes1]: if idxRes0 not satisfied (that is, no BE_ORDINAL.Not),\n      // find the first BE_ORDINAL.Might as the value dim,\n      // and then find a name dim with the priority:\n      // \"other dim\" > \"the value dim itself\".\n      // That is for backward compat: number-like (e.g., `'3'`, `'55'`) can be\n      // treated as number.\n\n\n      if (!isPureNumber) {\n        if (guessResult === BE_ORDINAL.Might && idxRes1.v == null && i !== potentialNameDimIndex) {\n          idxRes1.v = i;\n        }\n\n        if (idxRes1.n == null || idxRes1.n === idxRes1.v) {\n          idxRes1.n = i;\n        }\n      }\n    }\n\n    function fulfilled(idxResult) {\n      return idxResult.v != null && idxResult.n != null;\n    }\n\n    return fulfilled(idxRes0) ? idxRes0 : fulfilled(idxRes1) ? idxRes1 : null;\n  }();\n\n  if (idxResult) {\n    encode.value = idxResult.v; // `potentialNameDimIndex` has highest priority.\n\n    var nameDimIndex = potentialNameDimIndex != null ? potentialNameDimIndex : idxResult.n; // By default, label use itemName in charts.\n    // So we dont set encodeLabel here.\n\n    encode.itemName = [nameDimIndex];\n    encode.seriesName = [nameDimIndex];\n  }\n\n  return encode;\n}\n/**\n * If return null/undefined, indicate that should not use datasetModel.\n */\n\n\nfunction getDatasetModel(seriesModel) {\n  var option = seriesModel.option; // Caution: consider the scenario:\n  // A dataset is declared and a series is not expected to use the dataset,\n  // and at the beginning `setOption({series: { noData })` (just prepare other\n  // option but no data), then `setOption({series: {data: [...]}); In this case,\n  // the user should set an empty array to avoid that dataset is used by default.\n\n  var thisData = option.data;\n\n  if (!thisData) {\n    return seriesModel.ecModel.getComponent('dataset', option.datasetIndex || 0);\n  }\n}\n/**\n * The rule should not be complex, otherwise user might not\n * be able to known where the data is wrong.\n * The code is ugly, but how to make it neat?\n *\n * @param {module:echars/data/Source} source\n * @param {number} dimIndex\n * @return {BE_ORDINAL} guess result.\n */\n\n\nfunction guessOrdinal(source, dimIndex) {\n  return doGuessOrdinal(source.data, source.sourceFormat, source.seriesLayoutBy, source.dimensionsDefine, source.startIndex, dimIndex);\n} // dimIndex may be overflow source data.\n// return {BE_ORDINAL}\n\n\nfunction doGuessOrdinal(data, sourceFormat, seriesLayoutBy, dimensionsDefine, startIndex, dimIndex) {\n  var result; // Experience value.\n\n  var maxLoop = 5;\n\n  if (isTypedArray(data)) {\n    return BE_ORDINAL.Not;\n  } // When sourceType is 'objectRows' or 'keyedColumns', dimensionsDefine\n  // always exists in source.\n\n\n  var dimName;\n  var dimType;\n\n  if (dimensionsDefine) {\n    var dimDefItem = dimensionsDefine[dimIndex];\n\n    if (isObject(dimDefItem)) {\n      dimName = dimDefItem.name;\n      dimType = dimDefItem.type;\n    } else if (isString(dimDefItem)) {\n      dimName = dimDefItem;\n    }\n  }\n\n  if (dimType != null) {\n    return dimType === 'ordinal' ? BE_ORDINAL.Must : BE_ORDINAL.Not;\n  }\n\n  if (sourceFormat === SOURCE_FORMAT_ARRAY_ROWS) {\n    if (seriesLayoutBy === SERIES_LAYOUT_BY_ROW) {\n      var sample = data[dimIndex];\n\n      for (var i = 0; i < (sample || []).length && i < maxLoop; i++) {\n        if ((result = detectValue(sample[startIndex + i])) != null) {\n          return result;\n        }\n      }\n    } else {\n      for (var i = 0; i < data.length && i < maxLoop; i++) {\n        var row = data[startIndex + i];\n\n        if (row && (result = detectValue(row[dimIndex])) != null) {\n          return result;\n        }\n      }\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_OBJECT_ROWS) {\n    if (!dimName) {\n      return BE_ORDINAL.Not;\n    }\n\n    for (var i = 0; i < data.length && i < maxLoop; i++) {\n      var item = data[i];\n\n      if (item && (result = detectValue(item[dimName])) != null) {\n        return result;\n      }\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS) {\n    if (!dimName) {\n      return BE_ORDINAL.Not;\n    }\n\n    var sample = data[dimName];\n\n    if (!sample || isTypedArray(sample)) {\n      return BE_ORDINAL.Not;\n    }\n\n    for (var i = 0; i < sample.length && i < maxLoop; i++) {\n      if ((result = detectValue(sample[i])) != null) {\n        return result;\n      }\n    }\n  } else if (sourceFormat === SOURCE_FORMAT_ORIGINAL) {\n    for (var i = 0; i < data.length && i < maxLoop; i++) {\n      var item = data[i];\n      var val = getDataItemValue(item);\n\n      if (!isArray(val)) {\n        return BE_ORDINAL.Not;\n      }\n\n      if ((result = detectValue(val[dimIndex])) != null) {\n        return result;\n      }\n    }\n  }\n\n  function detectValue(val) {\n    var beStr = isString(val); // Consider usage convenience, '1', '2' will be treated as \"number\".\n    // `isFinit('')` get `true`.\n\n    if (val != null && isFinite(val) && val !== '') {\n      return beStr ? BE_ORDINAL.Might : BE_ORDINAL.Not;\n    } else if (beStr && val !== '-') {\n      return BE_ORDINAL.Must;\n    }\n  }\n\n  return BE_ORDINAL.Not;\n}\n\nexports.BE_ORDINAL = BE_ORDINAL;\nexports.detectSourceFormat = detectSourceFormat;\nexports.getSource = getSource;\nexports.resetSourceDefaulter = resetSourceDefaulter;\nexports.prepareSource = prepareSource;\nexports.makeSeriesEncodeForAxisCoordSys = makeSeriesEncodeForAxisCoordSys;\nexports.makeSeriesEncodeForNameBased = makeSeriesEncodeForNameBased;\nexports.guessOrdinal = guessOrdinal;","\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n\n/*\n* Licensed to the Apache Software Foundation (ASF) under one\n* or more contributor license agreements.  See the NOTICE file\n* distributed with this work for additional information\n* regarding copyright ownership.  The ASF licenses this file\n* to you under the Apache License, Version 2.0 (the\n* \"License\"); you may not use this file except in compliance\n* with the License.  You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing,\n* software distributed under the License is distributed on an\n* \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n* KIND, either express or implied.  See the License for the\n* specific language governing permissions and limitations\n* under the License.\n*/\n// Avoid typo.\nvar SOURCE_FORMAT_ORIGINAL = 'original';\nvar SOURCE_FORMAT_ARRAY_ROWS = 'arrayRows';\nvar SOURCE_FORMAT_OBJECT_ROWS = 'objectRows';\nvar SOURCE_FORMAT_KEYED_COLUMNS = 'keyedColumns';\nvar SOURCE_FORMAT_UNKNOWN = 'unknown'; // ??? CHANGE A NAME\n\nvar SOURCE_FORMAT_TYPED_ARRAY = 'typedArray';\nvar SERIES_LAYOUT_BY_COLUMN = 'column';\nvar SERIES_LAYOUT_BY_ROW = 'row';\nexports.SOURCE_FORMAT_ORIGINAL = SOURCE_FORMAT_ORIGINAL;\nexports.SOURCE_FORMAT_ARRAY_ROWS = SOURCE_FORMAT_ARRAY_ROWS;\nexports.SOURCE_FORMAT_OBJECT_ROWS = SOURCE_FORMAT_OBJECT_ROWS;\nexports.SOURCE_FORMAT_KEYED_COLUMNS = SOURCE_FORMAT_KEYED_COLUMNS;\nexports.SOURCE_FORMAT_UNKNOWN = SOURCE_FORMAT_UNKNOWN;\nexports.SOURCE_FORMAT_TYPED_ARRAY = SOURCE_FORMAT_TYPED_ARRAY;\nexports.SERIES_LAYOUT_BY_COLUMN = SERIES_LAYOUT_BY_COLUMN;\nexports.SERIES_LAYOUT_BY_ROW = SERIES_LAYOUT_BY_ROW;"],"names":["_util","createHashMap","each","isString","defaults","extend","isObject","clone","_model","normalizeToArray","_sourceHelper","guessOrdinal","BE_ORDINAL","Source","_dimensionHelper","OTHER_DIMENSIONS","DataDimensionInfo","completeDimensions","sysDims","source","opt","isInstance","seriesDataToSource","slice","dimsDef","dataDimNameMap","coordDimNameMap","result","dimCount","getDimCount","i","dimDefItem","name","userDimName","resultItem","get","displayName","set","type","encodeDef","encodeDefaulter","dataDims","coordDim","length","validDataDims","resultDimIdx","idx","applyDim","availDimIdx","coordDimIndex","otherDims","sysDimItem","sysDimIndex","sysDimItemDimsDef","sysDimItemOtherDims","ordinalMeta","push","sysDimItemDimsDefItem","defaultTooltip","generateCoord","generateCoordCount","fromZero","extra","genName","isExtraCoord","Must","itemName","seriesName","optDimCount","Math","max","dimensionsDetectCount","map","_default","module","exports","coordDimensions","dimensionsDefine","encodeDefine","dimensionsCount","_config","__DEV__","isTypedArray","assert","getDataItemValue","isDataItemOption","_number","parseDate","_sourceType","SOURCE_FORMAT_TYPED_ARRAY","SOURCE_FORMAT_ARRAY_ROWS","SOURCE_FORMAT_ORIGINAL","SOURCE_FORMAT_OBJECT_ROWS","DefaultDataProvider","dimSize","this","_source","data","_data","sourceFormat","_offset","_dimSize","methods","providerMethods","seriesLayoutBy","providerProto","prototype","pure","persistent","getSource","count","startIndex","getItem","appendData","appendDataSimply","row","item","Error","countSimply","getItemSimply","dimName","col","dims","newData","newCol","key","oldCol","out","offset","clean","rawValueGetters","arrayRows","getRawValueSimply","objectRows","dataItem","dataIndex","dimIndex","keyedColumns","original","value","Array","typedArray","defaultDimValueGetters","getDimValueSimply","converDataValue","_dimensionInfos","_rawData","hasItemOption","dimInfo","dimType","parseAndCollect","NaN","retrieveRawValue","dim","getRawDataItem","getProvider","getDimensionInfo","index","retrieveRawAttr","attr","enableDataStack","seriesModel","dimensionInfoList","stackedByDimInfo","stackedDimInfo","stackResultDimension","stackedOverDimension","byIndex","stackedCoordDimension","mayStack","dimensionInfo","createInvertedIndices","stackedDimCoordDim","stackedDimType","stackedDimCoordIndex","isCalculationCoord","stackedDimension","stackedByDimension","isStackedByIndex","isDimensionStacked","stackedDim","getCalculationInfo","getStackedDimension","targetDim","summarizeDimensions","summary","encode","notExtraCoordDimMap","defaultedLabel","defaultedTooltip","userOutput","dimensionNames","dimensions","dimItem","getOrCreateEncodeArr","mayLabelDimType","v","otherDim","encodeArr","dataDimsOnCoord","encodeFirstDimNotExtra","dimArr","concat","encodeLabel","label","encodeTooltip","tooltip","hasOwnProperty","getDimensionTypeByAxis","axisType","zrUtil","DATAS","MAIN_DATA","linkList","mainData","datas","main","datasAttr","linkAll","TRANSFERABLE_METHODS","methodName","wrapMethod","curry","transferInjection","cloneShallowInjection","CHANGABLE_METHODS","changeInjection","dataType","res","isMainData","linkSingle","struct","update","cloneShallow","getLinkedData","structAttr","makeInner","isArray","isArrayLike","SOURCE_FORMAT_KEYED_COLUMNS","SOURCE_FORMAT_UNKNOWN","SERIES_LAYOUT_BY_ROW","Might","Not","inner","detectSourceFormat","datasetModel","option","len","resetSourceDefaulter","ecModel","datasetMap","prepareSource","seriesOption","fromDataset","sourceHeader","getDatasetModel","datasetOption","completeResult","completeBySourceData","normalizeDimensionsDefine","arrayRowsTravelFirst","val","objectRowsCollectDimensions","colArr","value0","nameMap","exist","cb","maxLoop","Infinity","obj","firstIndex","makeSeriesEncodeForAxisCoordSys","baseCategoryDimIndex","categoryWayValueDimStart","encodeItemName","encodeSeriesName","uid","coordDimInfo","coordDimIdx","getDataDimCountOnCoordDim","datasetRecord","categoryWayDim","valueWayDim","pushDim","dimIdxArr","idxFrom","idxCount","coordDimName","start","makeSeriesEncodeForNameBased","potentialNameDimIndex","idxResult","idxRes0","idxRes1","guessRecords","min","guessResult","doGuessOrdinal","isPureNumber","n","fulfilled","nameDimIndex","thisData","getComponent","datasetIndex","sample","detectValue","beStr","isFinite","SERIES_LAYOUT_BY_COLUMN"],"sourceRoot":""}