{"version":3,"sources":["webpack:///./node_modules/echarts/lib/data/helper/sourceHelper.js","webpack:///./node_modules/echarts/lib/data/helper/dataProvider.js","webpack:///./node_modules/echarts/lib/data/helper/dimensionHelper.js","webpack:///./node_modules/echarts/lib/data/DataDimensionInfo.js","webpack:///./node_modules/echarts/lib/data/List.js","webpack:///./node_modules/echarts/lib/data/DataDiffer.js","webpack:///./node_modules/echarts/lib/data/helper/completeDimensions.js","webpack:///./node_modules/echarts/lib/data/OrdinalMeta.js","webpack:///./node_modules/echarts/lib/data/helper/sourceType.js","webpack:///./node_modules/echarts/lib/data/helper/createDimensions.js","webpack:///./node_modules/echarts/lib/data/Source.js","webpack:///./node_modules/echarts/lib/data/helper/dataStackHelper.js"],"names":["_config","_model","__DEV__","makeInner","getDataItemValue","_util","createHashMap","each","map","isArray","isString","isObject","isTypedArray","isArrayLike","extend","Source","assert","_sourceType","SOURCE_FORMAT_ORIGINAL","SOURCE_FORMAT_ARRAY_ROWS","SOURCE_FORMAT_OBJECT_ROWS","SOURCE_FORMAT_KEYED_COLUMNS","SOURCE_FORMAT_UNKNOWN","SOURCE_FORMAT_TYPED_ARRAY","SERIES_LAYOUT_BY_ROW","BE_ORDINAL","Must","Might","Not","inner","detectSourceFormat","datasetModel","data","option","source","sourceFormat","length","i","len","item","key","hasOwnProperty","Error","getSource","seriesModel","resetSourceDefaulter","ecModel","datasetMap","prepareSource","seriesOption","fromDataset","seriesLayoutBy","sourceHeader","dimensionsDefine","dimensions","getDatasetModel","datasetOption","completeResult","completeBySourceData","startIndex","dimensionsDetectCount","encodeDefine","encode","normalizeDimensionsDefine","arrayRowsTravelFirst","val","index","objectRowsCollectDimensions","colArr","push","value0","nameMap","name","displayName","exist","get","count","set","cb","maxLoop","Infinity","obj","firstIndex","value","makeSeriesEncodeForAxisCoordSys","coordDimensions","baseCategoryDimIndex","categoryWayValueDimStart","encodeItemName","encodeSeriesName","uid","slice","coordDimInfo","coordDimIdx","type","getDataDimCountOnCoordDim","datasetRecord","categoryWayDim","valueWayDim","pushDim","dimIdxArr","idxFrom","idxCount","dimsDef","coordDimName","start","itemName","seriesName","makeSeriesEncodeForNameBased","dimCount","potentialNameDimIndex","dim","idx","idxResult","idxRes0","idxRes1","guessRecords","Math","min","guessResult","doGuessOrdinal","isPureNumber","v","n","fulfilled","nameDimIndex","thisData","getComponent","datasetIndex","guessOrdinal","dimIndex","result","dimName","dimType","dimDefItem","sample","detectValue","row","beStr","isFinite","exports","isDataItemOption","_number","parseDate","DefaultDataProvider","dimSize","isInstance","seriesDataToSource","this","_source","_data","_offset","_dimSize","methods","providerMethods","providerProto","prototype","pure","persistent","max","getItem","appendData","appendDataSimply","countSimply","getItemSimply","col","dims","newData","newCol","oldCol","out","offset","clean","rawValueGetters","arrayRows","getRawValueSimply","objectRows","dataItem","dataIndex","keyedColumns","original","Array","typedArray","defaultDimValueGetters","getDimValueSimply","converDataValue","_dimensionInfos","_rawData","hasItemOption","dimInfo","ordinalMeta","parseAndCollect","NaN","retrieveRawValue","getRawDataItem","getProvider","getDimensionInfo","retrieveRawAttr","attr","OTHER_DIMENSIONS","summarizeDimensions","summary","notExtraCoordDimMap","defaultedLabel","defaultedTooltip","userOutput","dimensionNames","dimItem","coordDim","coordDimIndex","getOrCreateEncodeArr","isExtraCoord","mayLabelDimType","defaultTooltip","otherDim","encodeArr","otherDims","dataDimsOnCoord","encodeFirstDimNotExtra","dimArr","concat","encodeLabel","label","encodeTooltip","tooltip","getDimensionTypeByAxis","axisType","zrUtil","DataDimensionInfo","opt","_default","module","Model","DataDiffer","_dataProvider","_dimensionHelper","UNDEFINED","INDEX_NOT_FOUND","ID_PREFIX","dataCtors","Float64Array","Int32Array","CtorUint32Array","Uint32Array","CtorInt32Array","CtorUint16Array","Uint16Array","getIndicesCtor","list","_rawCount","cloneChunk","originalChunk","Ctor","constructor","TRANSFERABLE_PROPERTIES","CLONE_PROPERTIES","transferProperties","target","__wrappedMethods","propName","clone","_calculationInfo","List","hostModel","dimensionInfos","invertedIndicesMap","dimensionInfo","dimensionName","createInvertedIndices","dataType","_indices","_count","_storage","_nameList","_idList","_optionModels","_visual","_layout","_itemVisuals","hasItemVisual","_itemLayouts","_graphicEls","_chunkSize","_chunkCount","_rawExtent","_extent","_approximateExtent","_dimensionsSummary","_invertedIndicesMap","listProto","prepareChunks","storage","chunkSize","chunkCount","end","DataCtor","lastChunkIndex","resizeChunkArray","newStore","j","k","prepareInvertedIndex","invertedIndices","categories","getRawValueFromStore","rawIndex","chunkIndex","floor","chunkOffset","chunk","getRawIndexWithoutIndices","getRawIndexWithIndices","getId","id","_idDimIdx","normalizeDimensions","cloneListForMapAndSample","excludeDimensions","allDimensions","originalStorage","indexOf","cloneDimStore","getInitialExtent","originalDimStore","newDimStore","getDimension","isNaN","getDimensionsOnCoord","mapDimension","dimensionsSummary","initData","nameList","dimValueGetter","notProvider","_nameRepeatCount","defaultDimValueGetter","_dimValueGetter","_dimValueGetterArrayRows","_initDataFromProvider","rawData","appendValues","values","names","dimLen","rawExtent","originalChunkCount","emptyDataItem","sourceIdx","dimRawExtent","nameDimIdx","dimensionInfoMap","idList","nameRepeatCount","_nameDimIdx","itemId","dimStorage","nameDim","nameDimChunk","getIndices","indices","thisCount","newIndices","buffer","getRawIndex","chunkStore","getByRawIndex","rawIdx","dimStore","_getFast","getValues","hasValue","getDataExtent","dimData","initialExtent","dimExtent","currEnd","useRaw","getApproximateExtent","setApproximateExtent","extent","getCalculationInfo","setCalculationInfo","getSum","sum","getMedian","dimDataArray","sortedDimDataArray","sort","a","b","rawIndexOf","indexOfName","getName","indexOfRawIndex","rawDataIndex","left","right","mid","indicesOfNearest","maxDistance","nearestIndices","minDist","minDiff","nearestIndicesLen","diff","dist","abs","context","contextCompat","call","apply","filterSelf","dim0","keep","selectRange","range","originalCount","quickFinished","chunkStorage","dimStorage2","min2","max2","chunkStorage2","val2","dimk","mapArray","arguments","tmpRetValue","dataCount","retValue","rawExtentOnDim","downSample","dimension","rate","sampleValue","sampleIndex","targetStorage","frameValues","frameSize","dataIdx","originalChunkIndex","originalChunkOffset","sampleFrameIdx","sampleChunkIndex","sampleChunkOffset","getItemModel","otherList","thisList","getVisual","visual","setVisual","setLayout","getLayout","getItemLayout","setItemLayout","layout","merge","clearItemLayouts","getItemVisual","ignoreParent","itemVisual","setItemVisual","clearAllVisual","setItemDataAndSeriesIndex","child","seriesIndex","setItemGraphicEl","el","traverse","getItemGraphicEl","eachItemGraphicEl","cloneShallow","dimensionInfoList","wrapMethod","methodName","injectFunction","originalMethod","res","TRANSFERABLE_METHODS","CHANGABLE_METHODS","defaultKeyGetter","oldArr","newArr","oldKeyGetter","newKeyGetter","_old","_new","_oldKeyGetter","_newKeyGetter","initIndexMap","arr","keyArr","keyGetterName","dataDiffer","existence","add","func","_add","update","_update","remove","_remove","execute","oldDataIndexMap","newDataIndexMap","oldDataKeyArr","newDataKeyArr","shift","defaults","normalizeToArray","_sourceHelper","completeDimensions","sysDims","dataDimNameMap","coordDimNameMap","getDimCount","userDimName","resultItem","encodeDef","encodeDefaulter","dataDims","validDataDims","resultDimIdx","applyDim","availDimIdx","sysDimItem","sysDimIndex","sysDimItemDimsDef","sysDimItemOtherDims","sysDimItemDimsDefItem","generateCoord","generateCoordCount","fromZero","extra","genName","optDimCount","OrdinalMeta","_needCollect","needCollect","_deduplication","deduplication","_map","createByAxisModel","axisModel","dedplication","proto","getOrCreateMap","getOrdinal","category","SERIES_LAYOUT_BY_COLUMN","dimensionsCount","_clazz","enableClassCheck","fields","enableDataStack","stackedByDimInfo","stackedDimInfo","stackResultDimension","stackedOverDimension","byIndex","stackedCoordDimension","mayStack","stackedDimCoordDim","stackedDimType","stackedDimCoordIndex","isCalculationCoord","stackedDimension","stackedByDimension","isStackedByIndex","isDimensionStacked","stackedDim","getStackedDimension","targetDim"],"mappings":"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","file":"js/chunk-6e02c4d0.42733b55.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 _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\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 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 * @class\n * @param {Object|DataDimensionInfo} [opt] All of the fields will be shallow copied.\n */\nfunction DataDimensionInfo(opt) {\n  if (opt != null) {\n    zrUtil.extend(this, opt);\n  }\n  /**\n   * Dimension name.\n   * Mandatory.\n   * @type {string}\n   */\n  // this.name;\n\n  /**\n   * The origin name in dimsDef, see source helper.\n   * If displayName given, the tooltip will displayed vertically.\n   * Optional.\n   * @type {string}\n   */\n  // this.displayName;\n\n  /**\n   * Which coordSys dimension this dimension mapped to.\n   * A `coordDim` can be a \"coordSysDim\" that the coordSys required\n   * (for example, an item in `coordSysDims` of `model/referHelper#CoordSysInfo`),\n   * or an generated \"extra coord name\" if does not mapped to any \"coordSysDim\"\n   * (That is determined by whether `isExtraCoord` is `true`).\n   * Mandatory.\n   * @type {string}\n   */\n  // this.coordDim;\n\n  /**\n   * The index of this dimension in `series.encode[coordDim]`.\n   * Mandatory.\n   * @type {number}\n   */\n  // this.coordDimIndex;\n\n  /**\n   * Dimension type. The enumerable values are the key of\n   * `dataCtors` of `data/List`.\n   * Optional.\n   * @type {string}\n   */\n  // this.type;\n\n  /**\n   * This index of this dimension info in `data/List#_dimensionInfos`.\n   * Mandatory after added to `data/List`.\n   * @type {number}\n   */\n  // this.index;\n\n  /**\n   * The format of `otherDims` is:\n   * ```js\n   * {\n   *     tooltip: number optional,\n   *     label: number optional,\n   *     itemName: number optional,\n   *     seriesName: number optional,\n   * }\n   * ```\n   *\n   * A `series.encode` can specified these fields:\n   * ```js\n   * encode: {\n   *     // \"3, 1, 5\" is the index of data dimension.\n   *     tooltip: [3, 1, 5],\n   *     label: [0, 3],\n   *     ...\n   * }\n   * ```\n   * `otherDims` is the parse result of the `series.encode` above, like:\n   * ```js\n   * // Suppose the index of this data dimension is `3`.\n   * this.otherDims = {\n   *     // `3` is at the index `0` of the `encode.tooltip`\n   *     tooltip: 0,\n   *     // `3` is at the index `1` of the `encode.tooltip`\n   *     label: 1\n   * };\n   * ```\n   *\n   * This prop should never be `null`/`undefined` after initialized.\n   * @type {Object}\n   */\n\n\n  this.otherDims = {};\n  /**\n   * Be `true` if this dimension is not mapped to any \"coordSysDim\" that the\n   * \"coordSys\" required.\n   * Mandatory.\n   * @type {boolean}\n   */\n  // this.isExtraCoord;\n\n  /**\n   * @type {module:data/OrdinalMeta}\n   */\n  // this.ordinalMeta;\n\n  /**\n   * Whether to create inverted indices.\n   * @type {boolean}\n   */\n  // this.createInvertedIndices;\n}\n\n;\nvar _default = DataDimensionInfo;\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 zrUtil = require(\"zrender/lib/core/util\");\n\nvar Model = require(\"../model/Model\");\n\nvar DataDiffer = require(\"./DataDiffer\");\n\nvar Source = require(\"./Source\");\n\nvar _dataProvider = require(\"./helper/dataProvider\");\n\nvar defaultDimValueGetters = _dataProvider.defaultDimValueGetters;\nvar DefaultDataProvider = _dataProvider.DefaultDataProvider;\n\nvar _dimensionHelper = require(\"./helper/dimensionHelper\");\n\nvar summarizeDimensions = _dimensionHelper.summarizeDimensions;\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/* global Float64Array, Int32Array, Uint32Array, Uint16Array */\n\n/**\n * List for data storage\n * @module echarts/data/List\n */\nvar isObject = zrUtil.isObject;\nvar UNDEFINED = 'undefined';\nvar INDEX_NOT_FOUND = -1; // Use prefix to avoid index to be the same as otherIdList[idx],\n// which will cause weird udpate animation.\n\nvar ID_PREFIX = 'e\\0\\0';\nvar dataCtors = {\n  'float': typeof Float64Array === UNDEFINED ? Array : Float64Array,\n  'int': typeof Int32Array === UNDEFINED ? Array : Int32Array,\n  // Ordinal data type can be string or int\n  'ordinal': Array,\n  'number': Array,\n  'time': Array\n}; // Caution: MUST not use `new CtorUint32Array(arr, 0, len)`, because the Ctor of array is\n// different from the Ctor of typed array.\n\nvar CtorUint32Array = typeof Uint32Array === UNDEFINED ? Array : Uint32Array;\nvar CtorInt32Array = typeof Int32Array === UNDEFINED ? Array : Int32Array;\nvar CtorUint16Array = typeof Uint16Array === UNDEFINED ? Array : Uint16Array;\n\nfunction getIndicesCtor(list) {\n  // The possible max value in this._indicies is always this._rawCount despite of filtering.\n  return list._rawCount > 65535 ? CtorUint32Array : CtorUint16Array;\n}\n\nfunction cloneChunk(originalChunk) {\n  var Ctor = originalChunk.constructor; // Only shallow clone is enough when Array.\n\n  return Ctor === Array ? originalChunk.slice() : new Ctor(originalChunk);\n}\n\nvar TRANSFERABLE_PROPERTIES = ['hasItemOption', '_nameList', '_idList', '_invertedIndicesMap', '_rawData', '_chunkSize', '_chunkCount', '_dimValueGetter', '_count', '_rawCount', '_nameDimIdx', '_idDimIdx'];\nvar CLONE_PROPERTIES = ['_extent', '_approximateExtent', '_rawExtent'];\n\nfunction transferProperties(target, source) {\n  zrUtil.each(TRANSFERABLE_PROPERTIES.concat(source.__wrappedMethods || []), function (propName) {\n    if (source.hasOwnProperty(propName)) {\n      target[propName] = source[propName];\n    }\n  });\n  target.__wrappedMethods = source.__wrappedMethods;\n  zrUtil.each(CLONE_PROPERTIES, function (propName) {\n    target[propName] = zrUtil.clone(source[propName]);\n  });\n  target._calculationInfo = zrUtil.extend(source._calculationInfo);\n}\n/**\n * @constructor\n * @alias module:echarts/data/List\n *\n * @param {Array.<string|Object|module:data/DataDimensionInfo>} dimensions\n *      For example, ['someDimName', {name: 'someDimName', type: 'someDimType'}, ...].\n *      Dimensions should be concrete names like x, y, z, lng, lat, angle, radius\n * @param {module:echarts/model/Model} hostModel\n */\n\n\nvar List = function (dimensions, hostModel) {\n  dimensions = dimensions || ['x', 'y'];\n  var dimensionInfos = {};\n  var dimensionNames = [];\n  var invertedIndicesMap = {};\n\n  for (var i = 0; i < dimensions.length; i++) {\n    // Use the original dimensions[i], where other flag props may exists.\n    var dimensionInfo = dimensions[i];\n\n    if (zrUtil.isString(dimensionInfo)) {\n      dimensionInfo = new DataDimensionInfo({\n        name: dimensionInfo\n      });\n    } else if (!(dimensionInfo instanceof DataDimensionInfo)) {\n      dimensionInfo = new DataDimensionInfo(dimensionInfo);\n    }\n\n    var dimensionName = dimensionInfo.name;\n    dimensionInfo.type = dimensionInfo.type || 'float';\n\n    if (!dimensionInfo.coordDim) {\n      dimensionInfo.coordDim = dimensionName;\n      dimensionInfo.coordDimIndex = 0;\n    }\n\n    dimensionInfo.otherDims = dimensionInfo.otherDims || {};\n    dimensionNames.push(dimensionName);\n    dimensionInfos[dimensionName] = dimensionInfo;\n    dimensionInfo.index = i;\n\n    if (dimensionInfo.createInvertedIndices) {\n      invertedIndicesMap[dimensionName] = [];\n    }\n  }\n  /**\n   * @readOnly\n   * @type {Array.<string>}\n   */\n\n\n  this.dimensions = dimensionNames;\n  /**\n   * Infomation of each data dimension, like data type.\n   * @type {Object}\n   */\n\n  this._dimensionInfos = dimensionInfos;\n  /**\n   * @type {module:echarts/model/Model}\n   */\n\n  this.hostModel = hostModel;\n  /**\n   * @type {module:echarts/model/Model}\n   */\n\n  this.dataType;\n  /**\n   * Indices stores the indices of data subset after filtered.\n   * This data subset will be used in chart.\n   * @type {Array.<number>}\n   * @readOnly\n   */\n\n  this._indices = null;\n  this._count = 0;\n  this._rawCount = 0;\n  /**\n   * Data storage\n   * @type {Object.<key, Array.<TypedArray|Array>>}\n   * @private\n   */\n\n  this._storage = {};\n  /**\n   * @type {Array.<string>}\n   */\n\n  this._nameList = [];\n  /**\n   * @type {Array.<string>}\n   */\n\n  this._idList = [];\n  /**\n   * Models of data option is stored sparse for optimizing memory cost\n   * @type {Array.<module:echarts/model/Model>}\n   * @private\n   */\n\n  this._optionModels = [];\n  /**\n   * Global visual properties after visual coding\n   * @type {Object}\n   * @private\n   */\n\n  this._visual = {};\n  /**\n   * Globel layout properties.\n   * @type {Object}\n   * @private\n   */\n\n  this._layout = {};\n  /**\n   * Item visual properties after visual coding\n   * @type {Array.<Object>}\n   * @private\n   */\n\n  this._itemVisuals = [];\n  /**\n   * Key: visual type, Value: boolean\n   * @type {Object}\n   * @readOnly\n   */\n\n  this.hasItemVisual = {};\n  /**\n   * Item layout properties after layout\n   * @type {Array.<Object>}\n   * @private\n   */\n\n  this._itemLayouts = [];\n  /**\n   * Graphic elemnents\n   * @type {Array.<module:zrender/Element>}\n   * @private\n   */\n\n  this._graphicEls = [];\n  /**\n   * Max size of each chunk.\n   * @type {number}\n   * @private\n   */\n\n  this._chunkSize = 1e5;\n  /**\n   * @type {number}\n   * @private\n   */\n\n  this._chunkCount = 0;\n  /**\n   * @type {Array.<Array|Object>}\n   * @private\n   */\n\n  this._rawData;\n  /**\n   * Raw extent will not be cloned, but only transfered.\n   * It will not be calculated util needed.\n   * key: dim,\n   * value: {end: number, extent: Array.<number>}\n   * @type {Object}\n   * @private\n   */\n\n  this._rawExtent = {};\n  /**\n   * @type {Object}\n   * @private\n   */\n\n  this._extent = {};\n  /**\n   * key: dim\n   * value: extent\n   * @type {Object}\n   * @private\n   */\n\n  this._approximateExtent = {};\n  /**\n   * Cache summary info for fast visit. See \"dimensionHelper\".\n   * @type {Object}\n   * @private\n   */\n\n  this._dimensionsSummary = summarizeDimensions(this);\n  /**\n   * @type {Object.<Array|TypedArray>}\n   * @private\n   */\n\n  this._invertedIndicesMap = invertedIndicesMap;\n  /**\n   * @type {Object}\n   * @private\n   */\n\n  this._calculationInfo = {};\n  /**\n   * User output info of this data.\n   * DO NOT use it in other places!\n   *\n   * When preparing user params for user callbacks, we have\n   * to clone these inner data structures to prevent users\n   * from modifying them to effect built-in logic. And for\n   * performance consideration we make this `userOutput` to\n   * avoid clone them too many times.\n   *\n   * @type {Object}\n   * @readOnly\n   */\n\n  this.userOutput = this._dimensionsSummary.userOutput;\n};\n\nvar listProto = List.prototype;\nlistProto.type = 'list';\n/**\n * If each data item has it's own option\n * @type {boolean}\n */\n\nlistProto.hasItemOption = true;\n/**\n * The meanings of the input parameter `dim`:\n *\n * + If dim is a number (e.g., `1`), it means the index of the dimension.\n *   For example, `getDimension(0)` will return 'x' or 'lng' or 'radius'.\n * + If dim is a number-like string (e.g., `\"1\"`):\n *     + If there is the same concrete dim name defined in `this.dimensions`, it means that concrete name.\n *     + If not, it will be converted to a number, which means the index of the dimension.\n *        (why? because of the backward compatbility. We have been tolerating number-like string in\n *        dimension setting, although now it seems that it is not a good idea.)\n *     For example, `visualMap[i].dimension: \"1\"` is the same meaning as `visualMap[i].dimension: 1`,\n *     if no dimension name is defined as `\"1\"`.\n * + If dim is a not-number-like string, it means the concrete dim name.\n *   For example, it can be be default name `\"x\"`, `\"y\"`, `\"z\"`, `\"lng\"`, `\"lat\"`, `\"angle\"`, `\"radius\"`,\n *   or customized in `dimensions` property of option like `\"age\"`.\n *\n * Get dimension name\n * @param {string|number} dim See above.\n * @return {string} Concrete dim name.\n */\n\nlistProto.getDimension = function (dim) {\n  if (typeof dim === 'number' // If being a number-like string but not being defined a dimension name.\n  || !isNaN(dim) && !this._dimensionInfos.hasOwnProperty(dim)) {\n    dim = this.dimensions[dim];\n  }\n\n  return dim;\n};\n/**\n * Get type and calculation info of particular dimension\n * @param {string|number} dim\n *        Dimension can be concrete names like x, y, z, lng, lat, angle, radius\n *        Or a ordinal number. For example getDimensionInfo(0) will return 'x' or 'lng' or 'radius'\n */\n\n\nlistProto.getDimensionInfo = function (dim) {\n  // Do not clone, because there may be categories in dimInfo.\n  return this._dimensionInfos[this.getDimension(dim)];\n};\n/**\n * @return {Array.<string>} concrete dimension name list on coord.\n */\n\n\nlistProto.getDimensionsOnCoord = function () {\n  return this._dimensionsSummary.dataDimsOnCoord.slice();\n};\n/**\n * @param {string} coordDim\n * @param {number} [idx] A coordDim may map to more than one data dim.\n *        If idx is `true`, return a array of all mapped dims.\n *        If idx is not specified, return the first dim not extra.\n * @return {string|Array.<string>} concrete data dim.\n *        If idx is number, and not found, return null/undefined.\n *        If idx is `true`, and not found, return empty array (always return array).\n */\n\n\nlistProto.mapDimension = function (coordDim, idx) {\n  var dimensionsSummary = this._dimensionsSummary;\n\n  if (idx == null) {\n    return dimensionsSummary.encodeFirstDimNotExtra[coordDim];\n  }\n\n  var dims = dimensionsSummary.encode[coordDim];\n  return idx === true // always return array if idx is `true`\n  ? (dims || []).slice() : dims && dims[idx];\n};\n/**\n * Initialize from data\n * @param {Array.<Object|number|Array>} data source or data or data provider.\n * @param {Array.<string>} [nameLIst] The name of a datum is used on data diff and\n *        defualt label/tooltip.\n *        A name can be specified in encode.itemName,\n *        or dataItem.name (only for series option data),\n *        or provided in nameList from outside.\n * @param {Function} [dimValueGetter] (dataItem, dimName, dataIndex, dimIndex) => number\n */\n\n\nlistProto.initData = function (data, nameList, dimValueGetter) {\n  var notProvider = Source.isInstance(data) || zrUtil.isArrayLike(data);\n\n  if (notProvider) {\n    data = new DefaultDataProvider(data, this.dimensions.length);\n  }\n\n  this._rawData = data; // Clear\n\n  this._storage = {};\n  this._indices = null;\n  this._nameList = nameList || [];\n  this._idList = [];\n  this._nameRepeatCount = {};\n\n  if (!dimValueGetter) {\n    this.hasItemOption = false;\n  }\n  /**\n   * @readOnly\n   */\n\n\n  this.defaultDimValueGetter = defaultDimValueGetters[this._rawData.getSource().sourceFormat]; // Default dim value getter\n\n  this._dimValueGetter = dimValueGetter = dimValueGetter || this.defaultDimValueGetter;\n  this._dimValueGetterArrayRows = defaultDimValueGetters.arrayRows; // Reset raw extent.\n\n  this._rawExtent = {};\n\n  this._initDataFromProvider(0, data.count()); // If data has no item option.\n\n\n  if (data.pure) {\n    this.hasItemOption = false;\n  }\n};\n\nlistProto.getProvider = function () {\n  return this._rawData;\n};\n/**\n * Caution: Can be only called on raw data (before `this._indices` created).\n */\n\n\nlistProto.appendData = function (data) {\n  var rawData = this._rawData;\n  var start = this.count();\n  rawData.appendData(data);\n  var end = rawData.count();\n\n  if (!rawData.persistent) {\n    end += start;\n  }\n\n  this._initDataFromProvider(start, end);\n};\n/**\n * Caution: Can be only called on raw data (before `this._indices` created).\n * This method does not modify `rawData` (`dataProvider`), but only\n * add values to storage.\n *\n * The final count will be increased by `Math.max(values.length, names.length)`.\n *\n * @param {Array.<Array.<*>>} values That is the SourceType: 'arrayRows', like\n *        [\n *            [12, 33, 44],\n *            [NaN, 43, 1],\n *            ['-', 'asdf', 0]\n *        ]\n *        Each item is exaclty cooresponding to a dimension.\n * @param {Array.<string>} [names]\n */\n\n\nlistProto.appendValues = function (values, names) {\n  var chunkSize = this._chunkSize;\n  var storage = this._storage;\n  var dimensions = this.dimensions;\n  var dimLen = dimensions.length;\n  var rawExtent = this._rawExtent;\n  var start = this.count();\n  var end = start + Math.max(values.length, names ? names.length : 0);\n  var originalChunkCount = this._chunkCount;\n\n  for (var i = 0; i < dimLen; i++) {\n    var dim = dimensions[i];\n\n    if (!rawExtent[dim]) {\n      rawExtent[dim] = getInitialExtent();\n    }\n\n    if (!storage[dim]) {\n      storage[dim] = [];\n    }\n\n    prepareChunks(storage, this._dimensionInfos[dim], chunkSize, originalChunkCount, end);\n    this._chunkCount = storage[dim].length;\n  }\n\n  var emptyDataItem = new Array(dimLen);\n\n  for (var idx = start; idx < end; idx++) {\n    var sourceIdx = idx - start;\n    var chunkIndex = Math.floor(idx / chunkSize);\n    var chunkOffset = idx % chunkSize; // Store the data by dimensions\n\n    for (var k = 0; k < dimLen; k++) {\n      var dim = dimensions[k];\n\n      var val = this._dimValueGetterArrayRows(values[sourceIdx] || emptyDataItem, dim, sourceIdx, k);\n\n      storage[dim][chunkIndex][chunkOffset] = val;\n      var dimRawExtent = rawExtent[dim];\n      val < dimRawExtent[0] && (dimRawExtent[0] = val);\n      val > dimRawExtent[1] && (dimRawExtent[1] = val);\n    }\n\n    if (names) {\n      this._nameList[idx] = names[sourceIdx];\n    }\n  }\n\n  this._rawCount = this._count = end; // Reset data extent\n\n  this._extent = {};\n  prepareInvertedIndex(this);\n};\n\nlistProto._initDataFromProvider = function (start, end) {\n  // Optimize.\n  if (start >= end) {\n    return;\n  }\n\n  var chunkSize = this._chunkSize;\n  var rawData = this._rawData;\n  var storage = this._storage;\n  var dimensions = this.dimensions;\n  var dimLen = dimensions.length;\n  var dimensionInfoMap = this._dimensionInfos;\n  var nameList = this._nameList;\n  var idList = this._idList;\n  var rawExtent = this._rawExtent;\n  var nameRepeatCount = this._nameRepeatCount = {};\n  var nameDimIdx;\n  var originalChunkCount = this._chunkCount;\n\n  for (var i = 0; i < dimLen; i++) {\n    var dim = dimensions[i];\n\n    if (!rawExtent[dim]) {\n      rawExtent[dim] = getInitialExtent();\n    }\n\n    var dimInfo = dimensionInfoMap[dim];\n\n    if (dimInfo.otherDims.itemName === 0) {\n      nameDimIdx = this._nameDimIdx = i;\n    }\n\n    if (dimInfo.otherDims.itemId === 0) {\n      this._idDimIdx = i;\n    }\n\n    if (!storage[dim]) {\n      storage[dim] = [];\n    }\n\n    prepareChunks(storage, dimInfo, chunkSize, originalChunkCount, end);\n    this._chunkCount = storage[dim].length;\n  }\n\n  var dataItem = new Array(dimLen);\n\n  for (var idx = start; idx < end; idx++) {\n    // NOTICE: Try not to write things into dataItem\n    dataItem = rawData.getItem(idx, dataItem); // Each data item is value\n    // [1, 2]\n    // 2\n    // Bar chart, line chart which uses category axis\n    // only gives the 'y' value. 'x' value is the indices of category\n    // Use a tempValue to normalize the value to be a (x, y) value\n\n    var chunkIndex = Math.floor(idx / chunkSize);\n    var chunkOffset = idx % chunkSize; // Store the data by dimensions\n\n    for (var k = 0; k < dimLen; k++) {\n      var dim = dimensions[k];\n      var dimStorage = storage[dim][chunkIndex]; // PENDING NULL is empty or zero\n\n      var val = this._dimValueGetter(dataItem, dim, idx, k);\n\n      dimStorage[chunkOffset] = val;\n      var dimRawExtent = rawExtent[dim];\n      val < dimRawExtent[0] && (dimRawExtent[0] = val);\n      val > dimRawExtent[1] && (dimRawExtent[1] = val);\n    } // ??? FIXME not check by pure but sourceFormat?\n    // TODO refactor these logic.\n\n\n    if (!rawData.pure) {\n      var name = nameList[idx];\n\n      if (dataItem && name == null) {\n        // If dataItem is {name: ...}, it has highest priority.\n        // That is appropriate for many common cases.\n        if (dataItem.name != null) {\n          // There is no other place to persistent dataItem.name,\n          // so save it to nameList.\n          nameList[idx] = name = dataItem.name;\n        } else if (nameDimIdx != null) {\n          var nameDim = dimensions[nameDimIdx];\n          var nameDimChunk = storage[nameDim][chunkIndex];\n\n          if (nameDimChunk) {\n            name = nameDimChunk[chunkOffset];\n            var ordinalMeta = dimensionInfoMap[nameDim].ordinalMeta;\n\n            if (ordinalMeta && ordinalMeta.categories.length) {\n              name = ordinalMeta.categories[name];\n            }\n          }\n        }\n      } // Try using the id in option\n      // id or name is used on dynamical data, mapping old and new items.\n\n\n      var id = dataItem == null ? null : dataItem.id;\n\n      if (id == null && name != null) {\n        // Use name as id and add counter to avoid same name\n        nameRepeatCount[name] = nameRepeatCount[name] || 0;\n        id = name;\n\n        if (nameRepeatCount[name] > 0) {\n          id += '__ec__' + nameRepeatCount[name];\n        }\n\n        nameRepeatCount[name]++;\n      }\n\n      id != null && (idList[idx] = id);\n    }\n  }\n\n  if (!rawData.persistent && rawData.clean) {\n    // Clean unused data if data source is typed array.\n    rawData.clean();\n  }\n\n  this._rawCount = this._count = end; // Reset data extent\n\n  this._extent = {};\n  prepareInvertedIndex(this);\n};\n\nfunction prepareChunks(storage, dimInfo, chunkSize, chunkCount, end) {\n  var DataCtor = dataCtors[dimInfo.type];\n  var lastChunkIndex = chunkCount - 1;\n  var dim = dimInfo.name;\n  var resizeChunkArray = storage[dim][lastChunkIndex];\n\n  if (resizeChunkArray && resizeChunkArray.length < chunkSize) {\n    var newStore = new DataCtor(Math.min(end - lastChunkIndex * chunkSize, chunkSize)); // The cost of the copy is probably inconsiderable\n    // within the initial chunkSize.\n\n    for (var j = 0; j < resizeChunkArray.length; j++) {\n      newStore[j] = resizeChunkArray[j];\n    }\n\n    storage[dim][lastChunkIndex] = newStore;\n  } // Create new chunks.\n\n\n  for (var k = chunkCount * chunkSize; k < end; k += chunkSize) {\n    storage[dim].push(new DataCtor(Math.min(end - k, chunkSize)));\n  }\n}\n\nfunction prepareInvertedIndex(list) {\n  var invertedIndicesMap = list._invertedIndicesMap;\n  zrUtil.each(invertedIndicesMap, function (invertedIndices, dim) {\n    var dimInfo = list._dimensionInfos[dim]; // Currently, only dimensions that has ordinalMeta can create inverted indices.\n\n    var ordinalMeta = dimInfo.ordinalMeta;\n\n    if (ordinalMeta) {\n      invertedIndices = invertedIndicesMap[dim] = new CtorInt32Array(ordinalMeta.categories.length); // The default value of TypedArray is 0. To avoid miss\n      // mapping to 0, we should set it as INDEX_NOT_FOUND.\n\n      for (var i = 0; i < invertedIndices.length; i++) {\n        invertedIndices[i] = INDEX_NOT_FOUND;\n      }\n\n      for (var i = 0; i < list._count; i++) {\n        // Only support the case that all values are distinct.\n        invertedIndices[list.get(dim, i)] = i;\n      }\n    }\n  });\n}\n\nfunction getRawValueFromStore(list, dimIndex, rawIndex) {\n  var val;\n\n  if (dimIndex != null) {\n    var chunkSize = list._chunkSize;\n    var chunkIndex = Math.floor(rawIndex / chunkSize);\n    var chunkOffset = rawIndex % chunkSize;\n    var dim = list.dimensions[dimIndex];\n    var chunk = list._storage[dim][chunkIndex];\n\n    if (chunk) {\n      val = chunk[chunkOffset];\n      var ordinalMeta = list._dimensionInfos[dim].ordinalMeta;\n\n      if (ordinalMeta && ordinalMeta.categories.length) {\n        val = ordinalMeta.categories[val];\n      }\n    }\n  }\n\n  return val;\n}\n/**\n * @return {number}\n */\n\n\nlistProto.count = function () {\n  return this._count;\n};\n\nlistProto.getIndices = function () {\n  var newIndices;\n  var indices = this._indices;\n\n  if (indices) {\n    var Ctor = indices.constructor;\n    var thisCount = this._count; // `new Array(a, b, c)` is different from `new Uint32Array(a, b, c)`.\n\n    if (Ctor === Array) {\n      newIndices = new Ctor(thisCount);\n\n      for (var i = 0; i < thisCount; i++) {\n        newIndices[i] = indices[i];\n      }\n    } else {\n      newIndices = new Ctor(indices.buffer, 0, thisCount);\n    }\n  } else {\n    var Ctor = getIndicesCtor(this);\n    var newIndices = new Ctor(this.count());\n\n    for (var i = 0; i < newIndices.length; i++) {\n      newIndices[i] = i;\n    }\n  }\n\n  return newIndices;\n};\n/**\n * Get value. Return NaN if idx is out of range.\n * @param {string} dim Dim must be concrete name.\n * @param {number} idx\n * @param {boolean} stack\n * @return {number}\n */\n\n\nlistProto.get = function (dim, idx\n/*, stack */\n) {\n  if (!(idx >= 0 && idx < this._count)) {\n    return NaN;\n  }\n\n  var storage = this._storage;\n\n  if (!storage[dim]) {\n    // TODO Warn ?\n    return NaN;\n  }\n\n  idx = this.getRawIndex(idx);\n  var chunkIndex = Math.floor(idx / this._chunkSize);\n  var chunkOffset = idx % this._chunkSize;\n  var chunkStore = storage[dim][chunkIndex];\n  var value = chunkStore[chunkOffset]; // FIXME ordinal data type is not stackable\n  // if (stack) {\n  //     var dimensionInfo = this._dimensionInfos[dim];\n  //     if (dimensionInfo && dimensionInfo.stackable) {\n  //         var stackedOn = this.stackedOn;\n  //         while (stackedOn) {\n  //             // Get no stacked data of stacked on\n  //             var stackedValue = stackedOn.get(dim, idx);\n  //             // Considering positive stack, negative stack and empty data\n  //             if ((value >= 0 && stackedValue > 0)  // Positive stack\n  //                 || (value <= 0 && stackedValue < 0) // Negative stack\n  //             ) {\n  //                 value += stackedValue;\n  //             }\n  //             stackedOn = stackedOn.stackedOn;\n  //         }\n  //     }\n  // }\n\n  return value;\n};\n/**\n * @param {string} dim concrete dim\n * @param {number} rawIndex\n * @return {number|string}\n */\n\n\nlistProto.getByRawIndex = function (dim, rawIdx) {\n  if (!(rawIdx >= 0 && rawIdx < this._rawCount)) {\n    return NaN;\n  }\n\n  var dimStore = this._storage[dim];\n\n  if (!dimStore) {\n    // TODO Warn ?\n    return NaN;\n  }\n\n  var chunkIndex = Math.floor(rawIdx / this._chunkSize);\n  var chunkOffset = rawIdx % this._chunkSize;\n  var chunkStore = dimStore[chunkIndex];\n  return chunkStore[chunkOffset];\n};\n/**\n * FIXME Use `get` on chrome maybe slow(in filterSelf and selectRange).\n * Hack a much simpler _getFast\n * @private\n */\n\n\nlistProto._getFast = function (dim, rawIdx) {\n  var chunkIndex = Math.floor(rawIdx / this._chunkSize);\n  var chunkOffset = rawIdx % this._chunkSize;\n  var chunkStore = this._storage[dim][chunkIndex];\n  return chunkStore[chunkOffset];\n};\n/**\n * Get value for multi dimensions.\n * @param {Array.<string>} [dimensions] If ignored, using all dimensions.\n * @param {number} idx\n * @return {number}\n */\n\n\nlistProto.getValues = function (dimensions, idx\n/*, stack */\n) {\n  var values = [];\n\n  if (!zrUtil.isArray(dimensions)) {\n    // stack = idx;\n    idx = dimensions;\n    dimensions = this.dimensions;\n  }\n\n  for (var i = 0, len = dimensions.length; i < len; i++) {\n    values.push(this.get(dimensions[i], idx\n    /*, stack */\n    ));\n  }\n\n  return values;\n};\n/**\n * If value is NaN. Inlcuding '-'\n * Only check the coord dimensions.\n * @param {string} dim\n * @param {number} idx\n * @return {number}\n */\n\n\nlistProto.hasValue = function (idx) {\n  var dataDimsOnCoord = this._dimensionsSummary.dataDimsOnCoord;\n\n  for (var i = 0, len = dataDimsOnCoord.length; i < len; i++) {\n    // Ordinal type originally can be string or number.\n    // But when an ordinal type is used on coord, it can\n    // not be string but only number. So we can also use isNaN.\n    if (isNaN(this.get(dataDimsOnCoord[i], idx))) {\n      return false;\n    }\n  }\n\n  return true;\n};\n/**\n * Get extent of data in one dimension\n * @param {string} dim\n * @param {boolean} stack\n */\n\n\nlistProto.getDataExtent = function (dim\n/*, stack */\n) {\n  // Make sure use concrete dim as cache name.\n  dim = this.getDimension(dim);\n  var dimData = this._storage[dim];\n  var initialExtent = getInitialExtent(); // stack = !!((stack || false) && this.getCalculationInfo(dim));\n\n  if (!dimData) {\n    return initialExtent;\n  } // Make more strict checkings to ensure hitting cache.\n\n\n  var currEnd = this.count(); // var cacheName = [dim, !!stack].join('_');\n  // var cacheName = dim;\n  // Consider the most cases when using data zoom, `getDataExtent`\n  // happened before filtering. We cache raw extent, which is not\n  // necessary to be cleared and recalculated when restore data.\n\n  var useRaw = !this._indices; // && !stack;\n\n  var dimExtent;\n\n  if (useRaw) {\n    return this._rawExtent[dim].slice();\n  }\n\n  dimExtent = this._extent[dim];\n\n  if (dimExtent) {\n    return dimExtent.slice();\n  }\n\n  dimExtent = initialExtent;\n  var min = dimExtent[0];\n  var max = dimExtent[1];\n\n  for (var i = 0; i < currEnd; i++) {\n    // var value = stack ? this.get(dim, i, true) : this._getFast(dim, this.getRawIndex(i));\n    var value = this._getFast(dim, this.getRawIndex(i));\n\n    value < min && (min = value);\n    value > max && (max = value);\n  }\n\n  dimExtent = [min, max];\n  this._extent[dim] = dimExtent;\n  return dimExtent;\n};\n/**\n * Optimize for the scenario that data is filtered by a given extent.\n * Consider that if data amount is more than hundreds of thousand,\n * extent calculation will cost more than 10ms and the cache will\n * be erased because of the filtering.\n */\n\n\nlistProto.getApproximateExtent = function (dim\n/*, stack */\n) {\n  dim = this.getDimension(dim);\n  return this._approximateExtent[dim] || this.getDataExtent(dim\n  /*, stack */\n  );\n};\n\nlistProto.setApproximateExtent = function (extent, dim\n/*, stack */\n) {\n  dim = this.getDimension(dim);\n  this._approximateExtent[dim] = extent.slice();\n};\n/**\n * @param {string} key\n * @return {*}\n */\n\n\nlistProto.getCalculationInfo = function (key) {\n  return this._calculationInfo[key];\n};\n/**\n * @param {string|Object} key or k-v object\n * @param {*} [value]\n */\n\n\nlistProto.setCalculationInfo = function (key, value) {\n  isObject(key) ? zrUtil.extend(this._calculationInfo, key) : this._calculationInfo[key] = value;\n};\n/**\n * Get sum of data in one dimension\n * @param {string} dim\n */\n\n\nlistProto.getSum = function (dim\n/*, stack */\n) {\n  var dimData = this._storage[dim];\n  var sum = 0;\n\n  if (dimData) {\n    for (var i = 0, len = this.count(); i < len; i++) {\n      var value = this.get(dim, i\n      /*, stack */\n      );\n\n      if (!isNaN(value)) {\n        sum += value;\n      }\n    }\n  }\n\n  return sum;\n};\n/**\n * Get median of data in one dimension\n * @param {string} dim\n */\n\n\nlistProto.getMedian = function (dim\n/*, stack */\n) {\n  var dimDataArray = []; // map all data of one dimension\n\n  this.each(dim, function (val, idx) {\n    if (!isNaN(val)) {\n      dimDataArray.push(val);\n    }\n  }); // TODO\n  // Use quick select?\n  // immutability & sort\n\n  var sortedDimDataArray = [].concat(dimDataArray).sort(function (a, b) {\n    return a - b;\n  });\n  var len = this.count(); // calculate median\n\n  return len === 0 ? 0 : len % 2 === 1 ? sortedDimDataArray[(len - 1) / 2] : (sortedDimDataArray[len / 2] + sortedDimDataArray[len / 2 - 1]) / 2;\n}; // /**\n//  * Retreive the index with given value\n//  * @param {string} dim Concrete dimension.\n//  * @param {number} value\n//  * @return {number}\n//  */\n// Currently incorrect: should return dataIndex but not rawIndex.\n// Do not fix it until this method is to be used somewhere.\n// FIXME Precision of float value\n// listProto.indexOf = function (dim, value) {\n//     var storage = this._storage;\n//     var dimData = storage[dim];\n//     var chunkSize = this._chunkSize;\n//     if (dimData) {\n//         for (var i = 0, len = this.count(); i < len; i++) {\n//             var chunkIndex = Math.floor(i / chunkSize);\n//             var chunkOffset = i % chunkSize;\n//             if (dimData[chunkIndex][chunkOffset] === value) {\n//                 return i;\n//             }\n//         }\n//     }\n//     return -1;\n// };\n\n/**\n * Only support the dimension which inverted index created.\n * Do not support other cases until required.\n * @param {string} concrete dim\n * @param {number|string} value\n * @return {number} rawIndex\n */\n\n\nlistProto.rawIndexOf = function (dim, value) {\n  var invertedIndices = dim && this._invertedIndicesMap[dim];\n  var rawIndex = invertedIndices[value];\n\n  if (rawIndex == null || isNaN(rawIndex)) {\n    return INDEX_NOT_FOUND;\n  }\n\n  return rawIndex;\n};\n/**\n * Retreive the index with given name\n * @param {number} idx\n * @param {number} name\n * @return {number}\n */\n\n\nlistProto.indexOfName = function (name) {\n  for (var i = 0, len = this.count(); i < len; i++) {\n    if (this.getName(i) === name) {\n      return i;\n    }\n  }\n\n  return -1;\n};\n/**\n * Retreive the index with given raw data index\n * @param {number} idx\n * @param {number} name\n * @return {number}\n */\n\n\nlistProto.indexOfRawIndex = function (rawIndex) {\n  if (rawIndex >= this._rawCount || rawIndex < 0) {\n    return -1;\n  }\n\n  if (!this._indices) {\n    return rawIndex;\n  } // Indices are ascending\n\n\n  var indices = this._indices; // If rawIndex === dataIndex\n\n  var rawDataIndex = indices[rawIndex];\n\n  if (rawDataIndex != null && rawDataIndex < this._count && rawDataIndex === rawIndex) {\n    return rawIndex;\n  }\n\n  var left = 0;\n  var right = this._count - 1;\n\n  while (left <= right) {\n    var mid = (left + right) / 2 | 0;\n\n    if (indices[mid] < rawIndex) {\n      left = mid + 1;\n    } else if (indices[mid] > rawIndex) {\n      right = mid - 1;\n    } else {\n      return mid;\n    }\n  }\n\n  return -1;\n};\n/**\n * Retreive the index of nearest value\n * @param {string} dim\n * @param {number} value\n * @param {number} [maxDistance=Infinity]\n * @return {Array.<number>} If and only if multiple indices has\n *        the same value, they are put to the result.\n */\n\n\nlistProto.indicesOfNearest = function (dim, value, maxDistance) {\n  var storage = this._storage;\n  var dimData = storage[dim];\n  var nearestIndices = [];\n\n  if (!dimData) {\n    return nearestIndices;\n  }\n\n  if (maxDistance == null) {\n    maxDistance = Infinity;\n  }\n\n  var minDist = Infinity;\n  var minDiff = -1;\n  var nearestIndicesLen = 0; // Check the test case of `test/ut/spec/data/List.js`.\n\n  for (var i = 0, len = this.count(); i < len; i++) {\n    var diff = value - this.get(dim, i);\n    var dist = Math.abs(diff);\n\n    if (dist <= maxDistance) {\n      // When the `value` is at the middle of `this.get(dim, i)` and `this.get(dim, i+1)`,\n      // we'd better not push both of them to `nearestIndices`, otherwise it is easy to\n      // get more than one item in `nearestIndices` (more specifically, in `tooltip`).\n      // So we chose the one that `diff >= 0` in this csae.\n      // But if `this.get(dim, i)` and `this.get(dim, j)` get the same value, both of them\n      // should be push to `nearestIndices`.\n      if (dist < minDist || dist === minDist && diff >= 0 && minDiff < 0) {\n        minDist = dist;\n        minDiff = diff;\n        nearestIndicesLen = 0;\n      }\n\n      if (diff === minDiff) {\n        nearestIndices[nearestIndicesLen++] = i;\n      }\n    }\n  }\n\n  nearestIndices.length = nearestIndicesLen;\n  return nearestIndices;\n};\n/**\n * Get raw data index\n * @param {number} idx\n * @return {number}\n */\n\n\nlistProto.getRawIndex = getRawIndexWithoutIndices;\n\nfunction getRawIndexWithoutIndices(idx) {\n  return idx;\n}\n\nfunction getRawIndexWithIndices(idx) {\n  if (idx < this._count && idx >= 0) {\n    return this._indices[idx];\n  }\n\n  return -1;\n}\n/**\n * Get raw data item\n * @param {number} idx\n * @return {number}\n */\n\n\nlistProto.getRawDataItem = function (idx) {\n  if (!this._rawData.persistent) {\n    var val = [];\n\n    for (var i = 0; i < this.dimensions.length; i++) {\n      var dim = this.dimensions[i];\n      val.push(this.get(dim, idx));\n    }\n\n    return val;\n  } else {\n    return this._rawData.getItem(this.getRawIndex(idx));\n  }\n};\n/**\n * @param {number} idx\n * @param {boolean} [notDefaultIdx=false]\n * @return {string}\n */\n\n\nlistProto.getName = function (idx) {\n  var rawIndex = this.getRawIndex(idx);\n  return this._nameList[rawIndex] || getRawValueFromStore(this, this._nameDimIdx, rawIndex) || '';\n};\n/**\n * @param {number} idx\n * @param {boolean} [notDefaultIdx=false]\n * @return {string}\n */\n\n\nlistProto.getId = function (idx) {\n  return getId(this, this.getRawIndex(idx));\n};\n\nfunction getId(list, rawIndex) {\n  var id = list._idList[rawIndex];\n\n  if (id == null) {\n    id = getRawValueFromStore(list, list._idDimIdx, rawIndex);\n  }\n\n  if (id == null) {\n    // FIXME Check the usage in graph, should not use prefix.\n    id = ID_PREFIX + rawIndex;\n  }\n\n  return id;\n}\n\nfunction normalizeDimensions(dimensions) {\n  if (!zrUtil.isArray(dimensions)) {\n    dimensions = [dimensions];\n  }\n\n  return dimensions;\n}\n\nfunction validateDimensions(list, dims) {\n  for (var i = 0; i < dims.length; i++) {\n    // stroage may be empty when no data, so use\n    // dimensionInfos to check.\n    if (!list._dimensionInfos[dims[i]]) {\n      console.error('Unkown dimension ' + dims[i]);\n    }\n  }\n}\n/**\n * Data iteration\n * @param {string|Array.<string>}\n * @param {Function} cb\n * @param {*} [context=this]\n *\n * @example\n *  list.each('x', function (x, idx) {});\n *  list.each(['x', 'y'], function (x, y, idx) {});\n *  list.each(function (idx) {})\n */\n\n\nlistProto.each = function (dims, cb, context, contextCompat) {\n  'use strict';\n\n  if (!this._count) {\n    return;\n  }\n\n  if (typeof dims === 'function') {\n    contextCompat = context;\n    context = cb;\n    cb = dims;\n    dims = [];\n  } // contextCompat just for compat echarts3\n\n\n  context = context || contextCompat || this;\n  dims = zrUtil.map(normalizeDimensions(dims), this.getDimension, this);\n  var dimSize = dims.length;\n\n  for (var i = 0; i < this.count(); i++) {\n    // Simple optimization\n    switch (dimSize) {\n      case 0:\n        cb.call(context, i);\n        break;\n\n      case 1:\n        cb.call(context, this.get(dims[0], i), i);\n        break;\n\n      case 2:\n        cb.call(context, this.get(dims[0], i), this.get(dims[1], i), i);\n        break;\n\n      default:\n        var k = 0;\n        var value = [];\n\n        for (; k < dimSize; k++) {\n          value[k] = this.get(dims[k], i);\n        } // Index\n\n\n        value[k] = i;\n        cb.apply(context, value);\n    }\n  }\n};\n/**\n * Data filter\n * @param {string|Array.<string>}\n * @param {Function} cb\n * @param {*} [context=this]\n */\n\n\nlistProto.filterSelf = function (dimensions, cb, context, contextCompat) {\n  'use strict';\n\n  if (!this._count) {\n    return;\n  }\n\n  if (typeof dimensions === 'function') {\n    contextCompat = context;\n    context = cb;\n    cb = dimensions;\n    dimensions = [];\n  } // contextCompat just for compat echarts3\n\n\n  context = context || contextCompat || this;\n  dimensions = zrUtil.map(normalizeDimensions(dimensions), this.getDimension, this);\n  var count = this.count();\n  var Ctor = getIndicesCtor(this);\n  var newIndices = new Ctor(count);\n  var value = [];\n  var dimSize = dimensions.length;\n  var offset = 0;\n  var dim0 = dimensions[0];\n\n  for (var i = 0; i < count; i++) {\n    var keep;\n    var rawIdx = this.getRawIndex(i); // Simple optimization\n\n    if (dimSize === 0) {\n      keep = cb.call(context, i);\n    } else if (dimSize === 1) {\n      var val = this._getFast(dim0, rawIdx);\n\n      keep = cb.call(context, val, i);\n    } else {\n      for (var k = 0; k < dimSize; k++) {\n        value[k] = this._getFast(dim0, rawIdx);\n      }\n\n      value[k] = i;\n      keep = cb.apply(context, value);\n    }\n\n    if (keep) {\n      newIndices[offset++] = rawIdx;\n    }\n  } // Set indices after filtered.\n\n\n  if (offset < count) {\n    this._indices = newIndices;\n  }\n\n  this._count = offset; // Reset data extent\n\n  this._extent = {};\n  this.getRawIndex = this._indices ? getRawIndexWithIndices : getRawIndexWithoutIndices;\n  return this;\n};\n/**\n * Select data in range. (For optimization of filter)\n * (Manually inline code, support 5 million data filtering in data zoom.)\n */\n\n\nlistProto.selectRange = function (range) {\n  'use strict';\n\n  if (!this._count) {\n    return;\n  }\n\n  var dimensions = [];\n\n  for (var dim in range) {\n    if (range.hasOwnProperty(dim)) {\n      dimensions.push(dim);\n    }\n  }\n\n  var dimSize = dimensions.length;\n\n  if (!dimSize) {\n    return;\n  }\n\n  var originalCount = this.count();\n  var Ctor = getIndicesCtor(this);\n  var newIndices = new Ctor(originalCount);\n  var offset = 0;\n  var dim0 = dimensions[0];\n  var min = range[dim0][0];\n  var max = range[dim0][1];\n  var quickFinished = false;\n\n  if (!this._indices) {\n    // Extreme optimization for common case. About 2x faster in chrome.\n    var idx = 0;\n\n    if (dimSize === 1) {\n      var dimStorage = this._storage[dimensions[0]];\n\n      for (var k = 0; k < this._chunkCount; k++) {\n        var chunkStorage = dimStorage[k];\n        var len = Math.min(this._count - k * this._chunkSize, this._chunkSize);\n\n        for (var i = 0; i < len; i++) {\n          var val = chunkStorage[i]; // NaN will not be filtered. Consider the case, in line chart, empty\n          // value indicates the line should be broken. But for the case like\n          // scatter plot, a data item with empty value will not be rendered,\n          // but the axis extent may be effected if some other dim of the data\n          // item has value. Fortunately it is not a significant negative effect.\n\n          if (val >= min && val <= max || isNaN(val)) {\n            newIndices[offset++] = idx;\n          }\n\n          idx++;\n        }\n      }\n\n      quickFinished = true;\n    } else if (dimSize === 2) {\n      var dimStorage = this._storage[dim0];\n      var dimStorage2 = this._storage[dimensions[1]];\n      var min2 = range[dimensions[1]][0];\n      var max2 = range[dimensions[1]][1];\n\n      for (var k = 0; k < this._chunkCount; k++) {\n        var chunkStorage = dimStorage[k];\n        var chunkStorage2 = dimStorage2[k];\n        var len = Math.min(this._count - k * this._chunkSize, this._chunkSize);\n\n        for (var i = 0; i < len; i++) {\n          var val = chunkStorage[i];\n          var val2 = chunkStorage2[i]; // Do not filter NaN, see comment above.\n\n          if ((val >= min && val <= max || isNaN(val)) && (val2 >= min2 && val2 <= max2 || isNaN(val2))) {\n            newIndices[offset++] = idx;\n          }\n\n          idx++;\n        }\n      }\n\n      quickFinished = true;\n    }\n  }\n\n  if (!quickFinished) {\n    if (dimSize === 1) {\n      for (var i = 0; i < originalCount; i++) {\n        var rawIndex = this.getRawIndex(i);\n\n        var val = this._getFast(dim0, rawIndex); // Do not filter NaN, see comment above.\n\n\n        if (val >= min && val <= max || isNaN(val)) {\n          newIndices[offset++] = rawIndex;\n        }\n      }\n    } else {\n      for (var i = 0; i < originalCount; i++) {\n        var keep = true;\n        var rawIndex = this.getRawIndex(i);\n\n        for (var k = 0; k < dimSize; k++) {\n          var dimk = dimensions[k];\n\n          var val = this._getFast(dim, rawIndex); // Do not filter NaN, see comment above.\n\n\n          if (val < range[dimk][0] || val > range[dimk][1]) {\n            keep = false;\n          }\n        }\n\n        if (keep) {\n          newIndices[offset++] = this.getRawIndex(i);\n        }\n      }\n    }\n  } // Set indices after filtered.\n\n\n  if (offset < originalCount) {\n    this._indices = newIndices;\n  }\n\n  this._count = offset; // Reset data extent\n\n  this._extent = {};\n  this.getRawIndex = this._indices ? getRawIndexWithIndices : getRawIndexWithoutIndices;\n  return this;\n};\n/**\n * Data mapping to a plain array\n * @param {string|Array.<string>} [dimensions]\n * @param {Function} cb\n * @param {*} [context=this]\n * @return {Array}\n */\n\n\nlistProto.mapArray = function (dimensions, cb, context, contextCompat) {\n  'use strict';\n\n  if (typeof dimensions === 'function') {\n    contextCompat = context;\n    context = cb;\n    cb = dimensions;\n    dimensions = [];\n  } // contextCompat just for compat echarts3\n\n\n  context = context || contextCompat || this;\n  var result = [];\n  this.each(dimensions, function () {\n    result.push(cb && cb.apply(this, arguments));\n  }, context);\n  return result;\n}; // Data in excludeDimensions is copied, otherwise transfered.\n\n\nfunction cloneListForMapAndSample(original, excludeDimensions) {\n  var allDimensions = original.dimensions;\n  var list = new List(zrUtil.map(allDimensions, original.getDimensionInfo, original), original.hostModel); // FIXME If needs stackedOn, value may already been stacked\n\n  transferProperties(list, original);\n  var storage = list._storage = {};\n  var originalStorage = original._storage; // Init storage\n\n  for (var i = 0; i < allDimensions.length; i++) {\n    var dim = allDimensions[i];\n\n    if (originalStorage[dim]) {\n      // Notice that we do not reset invertedIndicesMap here, becuase\n      // there is no scenario of mapping or sampling ordinal dimension.\n      if (zrUtil.indexOf(excludeDimensions, dim) >= 0) {\n        storage[dim] = cloneDimStore(originalStorage[dim]);\n        list._rawExtent[dim] = getInitialExtent();\n        list._extent[dim] = null;\n      } else {\n        // Direct reference for other dimensions\n        storage[dim] = originalStorage[dim];\n      }\n    }\n  }\n\n  return list;\n}\n\nfunction cloneDimStore(originalDimStore) {\n  var newDimStore = new Array(originalDimStore.length);\n\n  for (var j = 0; j < originalDimStore.length; j++) {\n    newDimStore[j] = cloneChunk(originalDimStore[j]);\n  }\n\n  return newDimStore;\n}\n\nfunction getInitialExtent() {\n  return [Infinity, -Infinity];\n}\n/**\n * Data mapping to a new List with given dimensions\n * @param {string|Array.<string>} dimensions\n * @param {Function} cb\n * @param {*} [context=this]\n * @return {Array}\n */\n\n\nlistProto.map = function (dimensions, cb, context, contextCompat) {\n  'use strict'; // contextCompat just for compat echarts3\n\n  context = context || contextCompat || this;\n  dimensions = zrUtil.map(normalizeDimensions(dimensions), this.getDimension, this);\n  var list = cloneListForMapAndSample(this, dimensions); // Following properties are all immutable.\n  // So we can reference to the same value\n\n  list._indices = this._indices;\n  list.getRawIndex = list._indices ? getRawIndexWithIndices : getRawIndexWithoutIndices;\n  var storage = list._storage;\n  var tmpRetValue = [];\n  var chunkSize = this._chunkSize;\n  var dimSize = dimensions.length;\n  var dataCount = this.count();\n  var values = [];\n  var rawExtent = list._rawExtent;\n\n  for (var dataIndex = 0; dataIndex < dataCount; dataIndex++) {\n    for (var dimIndex = 0; dimIndex < dimSize; dimIndex++) {\n      values[dimIndex] = this.get(dimensions[dimIndex], dataIndex\n      /*, stack */\n      );\n    }\n\n    values[dimSize] = dataIndex;\n    var retValue = cb && cb.apply(context, values);\n\n    if (retValue != null) {\n      // a number or string (in oridinal dimension)?\n      if (typeof retValue !== 'object') {\n        tmpRetValue[0] = retValue;\n        retValue = tmpRetValue;\n      }\n\n      var rawIndex = this.getRawIndex(dataIndex);\n      var chunkIndex = Math.floor(rawIndex / chunkSize);\n      var chunkOffset = rawIndex % chunkSize;\n\n      for (var i = 0; i < retValue.length; i++) {\n        var dim = dimensions[i];\n        var val = retValue[i];\n        var rawExtentOnDim = rawExtent[dim];\n        var dimStore = storage[dim];\n\n        if (dimStore) {\n          dimStore[chunkIndex][chunkOffset] = val;\n        }\n\n        if (val < rawExtentOnDim[0]) {\n          rawExtentOnDim[0] = val;\n        }\n\n        if (val > rawExtentOnDim[1]) {\n          rawExtentOnDim[1] = val;\n        }\n      }\n    }\n  }\n\n  return list;\n};\n/**\n * Large data down sampling on given dimension\n * @param {string} dimension\n * @param {number} rate\n * @param {Function} sampleValue\n * @param {Function} sampleIndex Sample index for name and id\n */\n\n\nlistProto.downSample = function (dimension, rate, sampleValue, sampleIndex) {\n  var list = cloneListForMapAndSample(this, [dimension]);\n  var targetStorage = list._storage;\n  var frameValues = [];\n  var frameSize = Math.floor(1 / rate);\n  var dimStore = targetStorage[dimension];\n  var len = this.count();\n  var chunkSize = this._chunkSize;\n  var rawExtentOnDim = list._rawExtent[dimension];\n  var newIndices = new (getIndicesCtor(this))(len);\n  var offset = 0;\n\n  for (var i = 0; i < len; i += frameSize) {\n    // Last frame\n    if (frameSize > len - i) {\n      frameSize = len - i;\n      frameValues.length = frameSize;\n    }\n\n    for (var k = 0; k < frameSize; k++) {\n      var dataIdx = this.getRawIndex(i + k);\n      var originalChunkIndex = Math.floor(dataIdx / chunkSize);\n      var originalChunkOffset = dataIdx % chunkSize;\n      frameValues[k] = dimStore[originalChunkIndex][originalChunkOffset];\n    }\n\n    var value = sampleValue(frameValues);\n    var sampleFrameIdx = this.getRawIndex(Math.min(i + sampleIndex(frameValues, value) || 0, len - 1));\n    var sampleChunkIndex = Math.floor(sampleFrameIdx / chunkSize);\n    var sampleChunkOffset = sampleFrameIdx % chunkSize; // Only write value on the filtered data\n\n    dimStore[sampleChunkIndex][sampleChunkOffset] = value;\n\n    if (value < rawExtentOnDim[0]) {\n      rawExtentOnDim[0] = value;\n    }\n\n    if (value > rawExtentOnDim[1]) {\n      rawExtentOnDim[1] = value;\n    }\n\n    newIndices[offset++] = sampleFrameIdx;\n  }\n\n  list._count = offset;\n  list._indices = newIndices;\n  list.getRawIndex = getRawIndexWithIndices;\n  return list;\n};\n/**\n * Get model of one data item.\n *\n * @param {number} idx\n */\n// FIXME Model proxy ?\n\n\nlistProto.getItemModel = function (idx) {\n  var hostModel = this.hostModel;\n  return new Model(this.getRawDataItem(idx), hostModel, hostModel && hostModel.ecModel);\n};\n/**\n * Create a data differ\n * @param {module:echarts/data/List} otherList\n * @return {module:echarts/data/DataDiffer}\n */\n\n\nlistProto.diff = function (otherList) {\n  var thisList = this;\n  return new DataDiffer(otherList ? otherList.getIndices() : [], this.getIndices(), function (idx) {\n    return getId(otherList, idx);\n  }, function (idx) {\n    return getId(thisList, idx);\n  });\n};\n/**\n * Get visual property.\n * @param {string} key\n */\n\n\nlistProto.getVisual = function (key) {\n  var visual = this._visual;\n  return visual && visual[key];\n};\n/**\n * Set visual property\n * @param {string|Object} key\n * @param {*} [value]\n *\n * @example\n *  setVisual('color', color);\n *  setVisual({\n *      'color': color\n *  });\n */\n\n\nlistProto.setVisual = function (key, val) {\n  if (isObject(key)) {\n    for (var name in key) {\n      if (key.hasOwnProperty(name)) {\n        this.setVisual(name, key[name]);\n      }\n    }\n\n    return;\n  }\n\n  this._visual = this._visual || {};\n  this._visual[key] = val;\n};\n/**\n * Set layout property.\n * @param {string|Object} key\n * @param {*} [val]\n */\n\n\nlistProto.setLayout = function (key, val) {\n  if (isObject(key)) {\n    for (var name in key) {\n      if (key.hasOwnProperty(name)) {\n        this.setLayout(name, key[name]);\n      }\n    }\n\n    return;\n  }\n\n  this._layout[key] = val;\n};\n/**\n * Get layout property.\n * @param  {string} key.\n * @return {*}\n */\n\n\nlistProto.getLayout = function (key) {\n  return this._layout[key];\n};\n/**\n * Get layout of single data item\n * @param {number} idx\n */\n\n\nlistProto.getItemLayout = function (idx) {\n  return this._itemLayouts[idx];\n};\n/**\n * Set layout of single data item\n * @param {number} idx\n * @param {Object} layout\n * @param {boolean=} [merge=false]\n */\n\n\nlistProto.setItemLayout = function (idx, layout, merge) {\n  this._itemLayouts[idx] = merge ? zrUtil.extend(this._itemLayouts[idx] || {}, layout) : layout;\n};\n/**\n * Clear all layout of single data item\n */\n\n\nlistProto.clearItemLayouts = function () {\n  this._itemLayouts.length = 0;\n};\n/**\n * Get visual property of single data item\n * @param {number} idx\n * @param {string} key\n * @param {boolean} [ignoreParent=false]\n */\n\n\nlistProto.getItemVisual = function (idx, key, ignoreParent) {\n  var itemVisual = this._itemVisuals[idx];\n  var val = itemVisual && itemVisual[key];\n\n  if (val == null && !ignoreParent) {\n    // Use global visual property\n    return this.getVisual(key);\n  }\n\n  return val;\n};\n/**\n * Set visual property of single data item\n *\n * @param {number} idx\n * @param {string|Object} key\n * @param {*} [value]\n *\n * @example\n *  setItemVisual(0, 'color', color);\n *  setItemVisual(0, {\n *      'color': color\n *  });\n */\n\n\nlistProto.setItemVisual = function (idx, key, value) {\n  var itemVisual = this._itemVisuals[idx] || {};\n  var hasItemVisual = this.hasItemVisual;\n  this._itemVisuals[idx] = itemVisual;\n\n  if (isObject(key)) {\n    for (var name in key) {\n      if (key.hasOwnProperty(name)) {\n        itemVisual[name] = key[name];\n        hasItemVisual[name] = true;\n      }\n    }\n\n    return;\n  }\n\n  itemVisual[key] = value;\n  hasItemVisual[key] = true;\n};\n/**\n * Clear itemVisuals and list visual.\n */\n\n\nlistProto.clearAllVisual = function () {\n  this._visual = {};\n  this._itemVisuals = [];\n  this.hasItemVisual = {};\n};\n\nvar setItemDataAndSeriesIndex = function (child) {\n  child.seriesIndex = this.seriesIndex;\n  child.dataIndex = this.dataIndex;\n  child.dataType = this.dataType;\n};\n/**\n * Set graphic element relative to data. It can be set as null\n * @param {number} idx\n * @param {module:zrender/Element} [el]\n */\n\n\nlistProto.setItemGraphicEl = function (idx, el) {\n  var hostModel = this.hostModel;\n\n  if (el) {\n    // Add data index and series index for indexing the data by element\n    // Useful in tooltip\n    el.dataIndex = idx;\n    el.dataType = this.dataType;\n    el.seriesIndex = hostModel && hostModel.seriesIndex;\n\n    if (el.type === 'group') {\n      el.traverse(setItemDataAndSeriesIndex, el);\n    }\n  }\n\n  this._graphicEls[idx] = el;\n};\n/**\n * @param {number} idx\n * @return {module:zrender/Element}\n */\n\n\nlistProto.getItemGraphicEl = function (idx) {\n  return this._graphicEls[idx];\n};\n/**\n * @param {Function} cb\n * @param {*} context\n */\n\n\nlistProto.eachItemGraphicEl = function (cb, context) {\n  zrUtil.each(this._graphicEls, function (el, idx) {\n    if (el) {\n      cb && cb.call(context, el, idx);\n    }\n  });\n};\n/**\n * Shallow clone a new list except visual and layout properties, and graph elements.\n * New list only change the indices.\n */\n\n\nlistProto.cloneShallow = function (list) {\n  if (!list) {\n    var dimensionInfoList = zrUtil.map(this.dimensions, this.getDimensionInfo, this);\n    list = new List(dimensionInfoList, this.hostModel);\n  } // FIXME\n\n\n  list._storage = this._storage;\n  transferProperties(list, this); // Clone will not change the data extent and indices\n\n  if (this._indices) {\n    var Ctor = this._indices.constructor;\n    list._indices = new Ctor(this._indices);\n  } else {\n    list._indices = null;\n  }\n\n  list.getRawIndex = list._indices ? getRawIndexWithIndices : getRawIndexWithoutIndices;\n  return list;\n};\n/**\n * Wrap some method to add more feature\n * @param {string} methodName\n * @param {Function} injectFunction\n */\n\n\nlistProto.wrapMethod = function (methodName, injectFunction) {\n  var originalMethod = this[methodName];\n\n  if (typeof originalMethod !== 'function') {\n    return;\n  }\n\n  this.__wrappedMethods = this.__wrappedMethods || [];\n\n  this.__wrappedMethods.push(methodName);\n\n  this[methodName] = function () {\n    var res = originalMethod.apply(this, arguments);\n    return injectFunction.apply(this, [res].concat(zrUtil.slice(arguments)));\n  };\n}; // Methods that create a new list based on this list should be listed here.\n// Notice that those method should `RETURN` the new list.\n\n\nlistProto.TRANSFERABLE_METHODS = ['cloneShallow', 'downSample', 'map']; // Methods that change indices of this list should be listed here.\n\nlistProto.CHANGABLE_METHODS = ['filterSelf', 'selectRange'];\nvar _default = List;\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\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*/\nfunction defaultKeyGetter(item) {\n  return item;\n}\n/**\n * @param {Array} oldArr\n * @param {Array} newArr\n * @param {Function} oldKeyGetter\n * @param {Function} newKeyGetter\n * @param {Object} [context] Can be visited by this.context in callback.\n */\n\n\nfunction DataDiffer(oldArr, newArr, oldKeyGetter, newKeyGetter, context) {\n  this._old = oldArr;\n  this._new = newArr;\n  this._oldKeyGetter = oldKeyGetter || defaultKeyGetter;\n  this._newKeyGetter = newKeyGetter || defaultKeyGetter;\n  this.context = context;\n}\n\nDataDiffer.prototype = {\n  constructor: DataDiffer,\n\n  /**\n   * Callback function when add a data\n   */\n  add: function (func) {\n    this._add = func;\n    return this;\n  },\n\n  /**\n   * Callback function when update a data\n   */\n  update: function (func) {\n    this._update = func;\n    return this;\n  },\n\n  /**\n   * Callback function when remove a data\n   */\n  remove: function (func) {\n    this._remove = func;\n    return this;\n  },\n  execute: function () {\n    var oldArr = this._old;\n    var newArr = this._new;\n    var oldDataIndexMap = {};\n    var newDataIndexMap = {};\n    var oldDataKeyArr = [];\n    var newDataKeyArr = [];\n    var i;\n    initIndexMap(oldArr, oldDataIndexMap, oldDataKeyArr, '_oldKeyGetter', this);\n    initIndexMap(newArr, newDataIndexMap, newDataKeyArr, '_newKeyGetter', this);\n\n    for (i = 0; i < oldArr.length; i++) {\n      var key = oldDataKeyArr[i];\n      var idx = newDataIndexMap[key]; // idx can never be empty array here. see 'set null' logic below.\n\n      if (idx != null) {\n        // Consider there is duplicate key (for example, use dataItem.name as key).\n        // We should make sure every item in newArr and oldArr can be visited.\n        var len = idx.length;\n\n        if (len) {\n          len === 1 && (newDataIndexMap[key] = null);\n          idx = idx.shift();\n        } else {\n          newDataIndexMap[key] = null;\n        }\n\n        this._update && this._update(idx, i);\n      } else {\n        this._remove && this._remove(i);\n      }\n    }\n\n    for (var i = 0; i < newDataKeyArr.length; i++) {\n      var key = newDataKeyArr[i];\n\n      if (newDataIndexMap.hasOwnProperty(key)) {\n        var idx = newDataIndexMap[key];\n\n        if (idx == null) {\n          continue;\n        } // idx can never be empty array here. see 'set null' logic above.\n\n\n        if (!idx.length) {\n          this._add && this._add(idx);\n        } else {\n          for (var j = 0, len = idx.length; j < len; j++) {\n            this._add && this._add(idx[j]);\n          }\n        }\n      }\n    }\n  }\n};\n\nfunction initIndexMap(arr, map, keyArr, keyGetterName, dataDiffer) {\n  for (var i = 0; i < arr.length; i++) {\n    // Add prefix to avoid conflict with Object.prototype.\n    var key = '_ec_' + dataDiffer[keyGetterName](arr[i], i);\n    var existence = map[key];\n\n    if (existence == null) {\n      keyArr.push(key);\n      map[key] = i;\n    } else {\n      if (!existence.length) {\n        map[key] = existence = [existence];\n      }\n\n      existence.push(i);\n    }\n  }\n}\n\nvar _default = DataDiffer;\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 _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 _util = require(\"zrender/lib/core/util\");\n\nvar createHashMap = _util.createHashMap;\nvar isObject = _util.isObject;\nvar map = _util.map;\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 * @constructor\n * @param {Object} [opt]\n * @param {Object} [opt.categories=[]]\n * @param {Object} [opt.needCollect=false]\n * @param {Object} [opt.deduplication=false]\n */\nfunction OrdinalMeta(opt) {\n  /**\n   * @readOnly\n   * @type {Array.<string>}\n   */\n  this.categories = opt.categories || [];\n  /**\n   * @private\n   * @type {boolean}\n   */\n\n  this._needCollect = opt.needCollect;\n  /**\n   * @private\n   * @type {boolean}\n   */\n\n  this._deduplication = opt.deduplication;\n  /**\n   * @private\n   * @type {boolean}\n   */\n\n  this._map;\n}\n/**\n * @param {module:echarts/model/Model} axisModel\n * @return {module:echarts/data/OrdinalMeta}\n */\n\n\nOrdinalMeta.createByAxisModel = function (axisModel) {\n  var option = axisModel.option;\n  var data = option.data;\n  var categories = data && map(data, getName);\n  return new OrdinalMeta({\n    categories: categories,\n    needCollect: !categories,\n    // deduplication is default in axis.\n    deduplication: option.dedplication !== false\n  });\n};\n\nvar proto = OrdinalMeta.prototype;\n/**\n * @param {string} category\n * @return {number} ordinal\n */\n\nproto.getOrdinal = function (category) {\n  return getOrCreateMap(this).get(category);\n};\n/**\n * @param {*} category\n * @return {number} The ordinal. If not found, return NaN.\n */\n\n\nproto.parseAndCollect = function (category) {\n  var index;\n  var needCollect = this._needCollect; // The value of category dim can be the index of the given category set.\n  // This feature is only supported when !needCollect, because we should\n  // consider a common case: a value is 2017, which is a number but is\n  // expected to be tread as a category. This case usually happen in dataset,\n  // where it happent to be no need of the index feature.\n\n  if (typeof category !== 'string' && !needCollect) {\n    return category;\n  } // Optimize for the scenario:\n  // category is ['2012-01-01', '2012-01-02', ...], where the input\n  // data has been ensured not duplicate and is large data.\n  // Notice, if a dataset dimension provide categroies, usually echarts\n  // should remove duplication except user tell echarts dont do that\n  // (set axis.deduplication = false), because echarts do not know whether\n  // the values in the category dimension has duplication (consider the\n  // parallel-aqi example)\n\n\n  if (needCollect && !this._deduplication) {\n    index = this.categories.length;\n    this.categories[index] = category;\n    return index;\n  }\n\n  var map = getOrCreateMap(this);\n  index = map.get(category);\n\n  if (index == null) {\n    if (needCollect) {\n      index = this.categories.length;\n      this.categories[index] = category;\n      map.set(category, index);\n    } else {\n      index = NaN;\n    }\n  }\n\n  return index;\n}; // Consider big data, do not create map until needed.\n\n\nfunction getOrCreateMap(ordinalMeta) {\n  return ordinalMeta._map || (ordinalMeta._map = createHashMap(ordinalMeta.categories));\n}\n\nfunction getName(obj) {\n  if (isObject(obj) && obj.value != null) {\n    return obj.value;\n  } else {\n    return obj + '';\n  }\n}\n\nvar _default = OrdinalMeta;\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\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;","\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 _util = require(\"zrender/lib/core/util\");\n\nvar createHashMap = _util.createHashMap;\nvar isTypedArray = _util.isTypedArray;\n\nvar _clazz = require(\"../util/clazz\");\n\nvar enableClassCheck = _clazz.enableClassCheck;\n\nvar _sourceType = require(\"./helper/sourceType\");\n\nvar SOURCE_FORMAT_ORIGINAL = _sourceType.SOURCE_FORMAT_ORIGINAL;\nvar SERIES_LAYOUT_BY_COLUMN = _sourceType.SERIES_LAYOUT_BY_COLUMN;\nvar SOURCE_FORMAT_UNKNOWN = _sourceType.SOURCE_FORMAT_UNKNOWN;\nvar SOURCE_FORMAT_TYPED_ARRAY = _sourceType.SOURCE_FORMAT_TYPED_ARRAY;\nvar SOURCE_FORMAT_KEYED_COLUMNS = _sourceType.SOURCE_FORMAT_KEYED_COLUMNS;\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 * [sourceFormat]\n *\n * + \"original\":\n * This format is only used in series.data, where\n * itemStyle can be specified in data item.\n *\n * + \"arrayRows\":\n * [\n *     ['product', 'score', 'amount'],\n *     ['Matcha Latte', 89.3, 95.8],\n *     ['Milk Tea', 92.1, 89.4],\n *     ['Cheese Cocoa', 94.4, 91.2],\n *     ['Walnut Brownie', 85.4, 76.9]\n * ]\n *\n * + \"objectRows\":\n * [\n *     {product: 'Matcha Latte', score: 89.3, amount: 95.8},\n *     {product: 'Milk Tea', score: 92.1, amount: 89.4},\n *     {product: 'Cheese Cocoa', score: 94.4, amount: 91.2},\n *     {product: 'Walnut Brownie', score: 85.4, amount: 76.9}\n * ]\n *\n * + \"keyedColumns\":\n * {\n *     'product': ['Matcha Latte', 'Milk Tea', 'Cheese Cocoa', 'Walnut Brownie'],\n *     'count': [823, 235, 1042, 988],\n *     'score': [95.8, 81.4, 91.2, 76.9]\n * }\n *\n * + \"typedArray\"\n *\n * + \"unknown\"\n */\n\n/**\n * @constructor\n * @param {Object} fields\n * @param {string} fields.sourceFormat\n * @param {Array|Object} fields.fromDataset\n * @param {Array|Object} [fields.data]\n * @param {string} [seriesLayoutBy='column']\n * @param {Array.<Object|string>} [dimensionsDefine]\n * @param {Objet|HashMap} [encodeDefine]\n * @param {number} [startIndex=0]\n * @param {number} [dimensionsDetectCount]\n */\nfunction Source(fields) {\n  /**\n   * @type {boolean}\n   */\n  this.fromDataset = fields.fromDataset;\n  /**\n   * Not null/undefined.\n   * @type {Array|Object}\n   */\n\n  this.data = fields.data || (fields.sourceFormat === SOURCE_FORMAT_KEYED_COLUMNS ? {} : []);\n  /**\n   * See also \"detectSourceFormat\".\n   * Not null/undefined.\n   * @type {string}\n   */\n\n  this.sourceFormat = fields.sourceFormat || SOURCE_FORMAT_UNKNOWN;\n  /**\n   * 'row' or 'column'\n   * Not null/undefined.\n   * @type {string} seriesLayoutBy\n   */\n\n  this.seriesLayoutBy = fields.seriesLayoutBy || SERIES_LAYOUT_BY_COLUMN;\n  /**\n   * dimensions definition in option.\n   * can be null/undefined.\n   * @type {Array.<Object|string>}\n   */\n\n  this.dimensionsDefine = fields.dimensionsDefine;\n  /**\n   * encode definition in option.\n   * can be null/undefined.\n   * @type {Objet|HashMap}\n   */\n\n  this.encodeDefine = fields.encodeDefine && createHashMap(fields.encodeDefine);\n  /**\n   * Not null/undefined, uint.\n   * @type {number}\n   */\n\n  this.startIndex = fields.startIndex || 0;\n  /**\n   * Can be null/undefined (when unknown), uint.\n   * @type {number}\n   */\n\n  this.dimensionsDetectCount = fields.dimensionsDetectCount;\n}\n/**\n * Wrap original series data for some compatibility cases.\n */\n\n\nSource.seriesDataToSource = function (data) {\n  return new Source({\n    data: data,\n    sourceFormat: isTypedArray(data) ? SOURCE_FORMAT_TYPED_ARRAY : SOURCE_FORMAT_ORIGINAL,\n    fromDataset: false\n  });\n};\n\nenableClassCheck(Source);\nvar _default = Source;\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 _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;"],"sourceRoot":""}