@fmdevui/fm-dev 1.0.113 → 1.0.114

package/es/node_modules/.pnpm/echarts@6.0.0/node_modules/echarts/lib/util/model.mjs

@@ -0,0 +1,717 @@
+import { isObject, isArray, createHashMap, each, assert, isString, isNumber, isStringSafe, map, indexOf } from '../../../../../zrender@6.0.0/node_modules/zrender/lib/core/util.mjs';
+import env from '../../../../../zrender@6.0.0/node_modules/zrender/lib/core/env.mjs';
+import { isNumeric, getRandomIdBase, round, getPrecision } from './number.mjs';
+import { warn, error } from './log.mjs';
+
+function interpolateNumber(p0, p1, percent) {
+  return (p1 - p0) * percent + p0;
+}
+/**
+ * Make the name displayable. But we should
+ * make sure it is not duplicated with user
+ * specified name, so use '\0';
+ */
+var DUMMY_COMPONENT_NAME_PREFIX = 'series\0';
+var INTERNAL_COMPONENT_ID_PREFIX = '\0_ec_\0';
+/**
+ * If value is not array, then translate it to array.
+ * @param  {*} value
+ * @return {Array} [value] or value
+ */
+function normalizeToArray(value) {
+  return value instanceof Array ? value : value == null ? [] : [value];
+}
+/**
+ * Sync default option between normal and emphasis like `position` and `show`
+ * In case some one will write code like
+ *     label: {
+ *          show: false,
+ *          position: 'outside',
+ *          fontSize: 18
+ *     },
+ *     emphasis: {
+ *          label: { show: true }
+ *     }
+ */
+function defaultEmphasis(opt, key, subOpts) {
+  // Caution: performance sensitive.
+  if (opt) {
+    opt[key] = opt[key] || {};
+    opt.emphasis = opt.emphasis || {};
+    opt.emphasis[key] = opt.emphasis[key] || {};
+    // Default emphasis option from normal
+    for (var i = 0, len = subOpts.length; i < len; i++) {
+      var subOptName = subOpts[i];
+      if (!opt.emphasis[key].hasOwnProperty(subOptName) && opt[key].hasOwnProperty(subOptName)) {
+        opt.emphasis[key][subOptName] = opt[key][subOptName];
+      }
+    }
+  }
+}
+var TEXT_STYLE_OPTIONS = ['fontStyle', 'fontWeight', 'fontSize', 'fontFamily', 'rich', 'tag', 'color', 'textBorderColor', 'textBorderWidth', 'width', 'height', 'lineHeight', 'align', 'verticalAlign', 'baseline', 'shadowColor', 'shadowBlur', 'shadowOffsetX', 'shadowOffsetY', 'textShadowColor', 'textShadowBlur', 'textShadowOffsetX', 'textShadowOffsetY', 'backgroundColor', 'borderColor', 'borderWidth', 'borderRadius', 'padding'];
+// modelUtil.LABEL_OPTIONS = modelUtil.TEXT_STYLE_OPTIONS.concat([
+//     'position', 'offset', 'rotate', 'origin', 'show', 'distance', 'formatter',
+//     'fontStyle', 'fontWeight', 'fontSize', 'fontFamily',
+//     // FIXME: deprecated, check and remove it.
+//     'textStyle'
+// ]);
+/**
+ * The method does not ensure performance.
+ * data could be [12, 2323, {value: 223}, [1221, 23], {value: [2, 23]}]
+ * This helper method retrieves value from data.
+ */
+function getDataItemValue(dataItem) {
+  return isObject(dataItem) && !isArray(dataItem) && !(dataItem instanceof Date) ? dataItem.value : dataItem;
+}
+/**
+ * data could be [12, 2323, {value: 223}, [1221, 23], {value: [2, 23]}]
+ * This helper method determine if dataItem has extra option besides value
+ */
+function isDataItemOption(dataItem) {
+  return isObject(dataItem) && !(dataItem instanceof Array);
+  // // markLine data can be array
+  // && !(dataItem[0] && isObject(dataItem[0]) && !(dataItem[0] instanceof Array));
+}
+;
+/**
+ * Mapping to existings for merge.
+ *
+ * Mode "normalMege":
+ *     The mapping result (merge result) will keep the order of the existing
+ *     component, rather than the order of new option. Because we should ensure
+ *     some specified index reference (like xAxisIndex) keep work.
+ *     And in most cases, "merge option" is used to update partial option but not
+ *     be expected to change the order.
+ *
+ * Mode "replaceMege":
+ *     (1) Only the id mapped components will be merged.
+ *     (2) Other existing components (except internal components) will be removed.
+ *     (3) Other new options will be used to create new component.
+ *     (4) The index of the existing components will not be modified.
+ *     That means their might be "hole" after the removal.
+ *     The new components are created first at those available index.
+ *
+ * Mode "replaceAll":
+ *     This mode try to support that reproduce an echarts instance from another
+ *     echarts instance (via `getOption`) in some simple cases.
+ *     In this scenario, the `result` index are exactly the consistent with the `newCmptOptions`,
+ *     which ensures the component index referring (like `xAxisIndex: ?`) corrent. That is,
+ *     the "hole" in `newCmptOptions` will also be kept.
+ *     On the contrary, other modes try best to eliminate holes.
+ *     PENDING: This is an experimental mode yet.
+ *
+ * @return See the comment of <MappingResult>.
+ */
+function mappingToExists(existings, newCmptOptions, mode) {
+  var isNormalMergeMode = mode === 'normalMerge';
+  var isReplaceMergeMode = mode === 'replaceMerge';
+  var isReplaceAllMode = mode === 'replaceAll';
+  existings = existings || [];
+  newCmptOptions = (newCmptOptions || []).slice();
+  var existingIdIdxMap = createHashMap();
+  // Validate id and name on user input option.
+  each(newCmptOptions, function (cmptOption, index) {
+    if (!isObject(cmptOption)) {
+      newCmptOptions[index] = null;
+      return;
+    }
+    if (process.env.NODE_ENV !== 'production') {
+      // There is some legacy case that name is set as `false`.
+      // But should work normally rather than throw error.
+      if (cmptOption.id != null && !isValidIdOrName(cmptOption.id)) {
+        warnInvalidateIdOrName(cmptOption.id);
+      }
+      if (cmptOption.name != null && !isValidIdOrName(cmptOption.name)) {
+        warnInvalidateIdOrName(cmptOption.name);
+      }
+    }
+  });
+  var result = prepareResult(existings, existingIdIdxMap, mode);
+  if (isNormalMergeMode || isReplaceMergeMode) {
+    mappingById(result, existings, existingIdIdxMap, newCmptOptions);
+  }
+  if (isNormalMergeMode) {
+    mappingByName(result, newCmptOptions);
+  }
+  if (isNormalMergeMode || isReplaceMergeMode) {
+    mappingByIndex(result, newCmptOptions, isReplaceMergeMode);
+  } else if (isReplaceAllMode) {
+    mappingInReplaceAllMode(result, newCmptOptions);
+  }
+  makeIdAndName(result);
+  // The array `result` MUST NOT contain elided items, otherwise the
+  // forEach will omit those items and result in incorrect result.
+  return result;
+}
+function prepareResult(existings, existingIdIdxMap, mode) {
+  var result = [];
+  if (mode === 'replaceAll') {
+    return result;
+  }
+  // Do not use native `map` to in case that the array `existings`
+  // contains elided items, which will be omitted.
+  for (var index = 0; index < existings.length; index++) {
+    var existing = existings[index];
+    // Because of replaceMerge, `existing` may be null/undefined.
+    if (existing && existing.id != null) {
+      existingIdIdxMap.set(existing.id, index);
+    }
+    // For non-internal-componnets:
+    //     Mode "normalMerge": all existings kept.
+    //     Mode "replaceMerge": all existing removed unless mapped by id.
+    // For internal-components:
+    //     go with "replaceMerge" approach in both mode.
+    result.push({
+      existing: mode === 'replaceMerge' || isComponentIdInternal(existing) ? null : existing,
+      newOption: null,
+      keyInfo: null,
+      brandNew: null
+    });
+  }
+  return result;
+}
+function mappingById(result, existings, existingIdIdxMap, newCmptOptions) {
+  // Mapping by id if specified.
+  each(newCmptOptions, function (cmptOption, index) {
+    if (!cmptOption || cmptOption.id == null) {
+      return;
+    }
+    var optionId = makeComparableKey(cmptOption.id);
+    var existingIdx = existingIdIdxMap.get(optionId);
+    if (existingIdx != null) {
+      var resultItem = result[existingIdx];
+      assert(!resultItem.newOption, 'Duplicated option on id "' + optionId + '".');
+      resultItem.newOption = cmptOption;
+      // In both mode, if id matched, new option will be merged to
+      // the existings rather than creating new component model.
+      resultItem.existing = existings[existingIdx];
+      newCmptOptions[index] = null;
+    }
+  });
+}
+function mappingByName(result, newCmptOptions) {
+  // Mapping by name if specified.
+  each(newCmptOptions, function (cmptOption, index) {
+    if (!cmptOption || cmptOption.name == null) {
+      return;
+    }
+    for (var i = 0; i < result.length; i++) {
+      var existing = result[i].existing;
+      if (!result[i].newOption // Consider name: two map to one.
+      // Can not match when both ids existing but different.
+      && existing && (existing.id == null || cmptOption.id == null) && !isComponentIdInternal(cmptOption) && !isComponentIdInternal(existing) && keyExistAndEqual('name', existing, cmptOption)) {
+        result[i].newOption = cmptOption;
+        newCmptOptions[index] = null;
+        return;
+      }
+    }
+  });
+}
+function mappingByIndex(result, newCmptOptions, brandNew) {
+  each(newCmptOptions, function (cmptOption) {
+    if (!cmptOption) {
+      return;
+    }
+    // Find the first place that not mapped by id and not internal component (consider the "hole").
+    var resultItem;
+    var nextIdx = 0;
+    while (
+    // Be `!resultItem` only when `nextIdx >= result.length`.
+    (resultItem = result[nextIdx]
+    // (1) Existing models that already have id should be able to mapped to. Because
+    // after mapping performed, model will always be assigned with an id if user not given.
+    // After that all models have id.
+    // (2) If new option has id, it can only set to a hole or append to the last. It should
+    // not be merged to the existings with different id. Because id should not be overwritten.
+    // (3) Name can be overwritten, because axis use name as 'show label text'.
+    ) && (resultItem.newOption || isComponentIdInternal(resultItem.existing) ||
+    // In mode "replaceMerge", here no not-mapped-non-internal-existing.
+    resultItem.existing && cmptOption.id != null && !keyExistAndEqual('id', cmptOption, resultItem.existing))) {
+      nextIdx++;
+    }
+    if (resultItem) {
+      resultItem.newOption = cmptOption;
+      resultItem.brandNew = brandNew;
+    } else {
+      result.push({
+        newOption: cmptOption,
+        brandNew: brandNew,
+        existing: null,
+        keyInfo: null
+      });
+    }
+    nextIdx++;
+  });
+}
+function mappingInReplaceAllMode(result, newCmptOptions) {
+  each(newCmptOptions, function (cmptOption) {
+    // The feature "reproduce" requires "hole" will also reproduced
+    // in case that component index referring are broken.
+    result.push({
+      newOption: cmptOption,
+      brandNew: true,
+      existing: null,
+      keyInfo: null
+    });
+  });
+}
+/**
+ * Make id and name for mapping result (result of mappingToExists)
+ * into `keyInfo` field.
+ */
+function makeIdAndName(mapResult) {
+  // We use this id to hash component models and view instances
+  // in echarts. id can be specified by user, or auto generated.
+  // The id generation rule ensures new view instance are able
+  // to mapped to old instance when setOption are called in
+  // no-merge mode. So we generate model id by name and plus
+  // type in view id.
+  // name can be duplicated among components, which is convenient
+  // to specify multi components (like series) by one name.
+  // Ensure that each id is distinct.
+  var idMap = createHashMap();
+  each(mapResult, function (item) {
+    var existing = item.existing;
+    existing && idMap.set(existing.id, item);
+  });
+  each(mapResult, function (item) {
+    var opt = item.newOption;
+    // Force ensure id not duplicated.
+    assert(!opt || opt.id == null || !idMap.get(opt.id) || idMap.get(opt.id) === item, 'id duplicates: ' + (opt && opt.id));
+    opt && opt.id != null && idMap.set(opt.id, item);
+    !item.keyInfo && (item.keyInfo = {});
+  });
+  // Make name and id.
+  each(mapResult, function (item, index) {
+    var existing = item.existing;
+    var opt = item.newOption;
+    var keyInfo = item.keyInfo;
+    if (!isObject(opt)) {
+      return;
+    }
+    // Name can be overwritten. Consider case: axis.name = '20km'.
+    // But id generated by name will not be changed, which affect
+    // only in that case: setOption with 'not merge mode' and view
+    // instance will be recreated, which can be accepted.
+    keyInfo.name = opt.name != null ? makeComparableKey(opt.name) : existing ? existing.name
+    // Avoid that different series has the same name,
+    // because name may be used like in color pallet.
+    : DUMMY_COMPONENT_NAME_PREFIX + index;
+    if (existing) {
+      keyInfo.id = makeComparableKey(existing.id);
+    } else if (opt.id != null) {
+      keyInfo.id = makeComparableKey(opt.id);
+    } else {
+      // Consider this situatoin:
+      //  optionA: [{name: 'a'}, {name: 'a'}, {..}]
+      //  optionB [{..}, {name: 'a'}, {name: 'a'}]
+      // Series with the same name between optionA and optionB
+      // should be mapped.
+      var idNum = 0;
+      do {
+        keyInfo.id = '\0' + keyInfo.name + '\0' + idNum++;
+      } while (idMap.get(keyInfo.id));
+    }
+    idMap.set(keyInfo.id, item);
+  });
+}
+function keyExistAndEqual(attr, obj1, obj2) {
+  var key1 = convertOptionIdName(obj1[attr], null);
+  var key2 = convertOptionIdName(obj2[attr], null);
+  // See `MappingExistingItem`. `id` and `name` trade string equals to number.
+  return key1 != null && key2 != null && key1 === key2;
+}
+/**
+ * @return return null if not exist.
+ */
+function makeComparableKey(val) {
+  if (process.env.NODE_ENV !== 'production') {
+    if (val == null) {
+      throw new Error();
+    }
+  }
+  return convertOptionIdName(val, '');
+}
+function convertOptionIdName(idOrName, defaultValue) {
+  if (idOrName == null) {
+    return defaultValue;
+  }
+  return isString(idOrName) ? idOrName : isNumber(idOrName) || isStringSafe(idOrName) ? idOrName + '' : defaultValue;
+}
+function warnInvalidateIdOrName(idOrName) {
+  if (process.env.NODE_ENV !== 'production') {
+    warn('`' + idOrName + '` is invalid id or name. Must be a string or number.');
+  }
+}
+function isValidIdOrName(idOrName) {
+  return isStringSafe(idOrName) || isNumeric(idOrName);
+}
+function isNameSpecified(componentModel) {
+  var name = componentModel.name;
+  // Is specified when `indexOf` get -1 or > 0.
+  return !!(name && name.indexOf(DUMMY_COMPONENT_NAME_PREFIX));
+}
+/**
+ * @public
+ * @param {Object} cmptOption
+ * @return {boolean}
+ */
+function isComponentIdInternal(cmptOption) {
+  return cmptOption && cmptOption.id != null && makeComparableKey(cmptOption.id).indexOf(INTERNAL_COMPONENT_ID_PREFIX) === 0;
+}
+function makeInternalComponentId(idSuffix) {
+  return INTERNAL_COMPONENT_ID_PREFIX + idSuffix;
+}
+function setComponentTypeToKeyInfo(mappingResult, mainType, componentModelCtor) {
+  // Set mainType and complete subType.
+  each(mappingResult, function (item) {
+    var newOption = item.newOption;
+    if (isObject(newOption)) {
+      item.keyInfo.mainType = mainType;
+      item.keyInfo.subType = determineSubType(mainType, newOption, item.existing, componentModelCtor);
+    }
+  });
+}
+function determineSubType(mainType, newCmptOption, existComponent, componentModelCtor) {
+  var subType = newCmptOption.type ? newCmptOption.type : existComponent ? existComponent.subType
+  // Use determineSubType only when there is no existComponent.
+  : componentModelCtor.determineSubType(mainType, newCmptOption);
+  // tooltip, markline, markpoint may always has no subType
+  return subType;
+}
+/**
+ * A helper for removing duplicate items between batchA and batchB,
+ * and in themselves, and categorize by series.
+ *
+ * @param batchA Like: [{seriesId: 2, dataIndex: [32, 4, 5]}, ...]
+ * @param batchB Like: [{seriesId: 2, dataIndex: [32, 4, 5]}, ...]
+ * @return result: [resultBatchA, resultBatchB]
+ */
+function compressBatches(batchA, batchB) {
+  var mapA = {};
+  var mapB = {};
+  makeMap(batchA || [], mapA);
+  makeMap(batchB || [], mapB, mapA);
+  return [mapToArray(mapA), mapToArray(mapB)];
+  function makeMap(sourceBatch, map, otherMap) {
+    for (var i = 0, len = sourceBatch.length; i < len; i++) {
+      var seriesId = convertOptionIdName(sourceBatch[i].seriesId, null);
+      if (seriesId == null) {
+        return;
+      }
+      var dataIndices = normalizeToArray(sourceBatch[i].dataIndex);
+      var otherDataIndices = otherMap && otherMap[seriesId];
+      for (var j = 0, lenj = dataIndices.length; j < lenj; j++) {
+        var dataIndex = dataIndices[j];
+        if (otherDataIndices && otherDataIndices[dataIndex]) {
+          otherDataIndices[dataIndex] = null;
+        } else {
+          (map[seriesId] || (map[seriesId] = {}))[dataIndex] = 1;
+        }
+      }
+    }
+  }
+  function mapToArray(map, isData) {
+    var result = [];
+    for (var i in map) {
+      if (map.hasOwnProperty(i) && map[i] != null) {
+        if (isData) {
+          result.push(+i);
+        } else {
+          var dataIndices = mapToArray(map[i], true);
+          dataIndices.length && result.push({
+            seriesId: i,
+            dataIndex: dataIndices
+          });
+        }
+      }
+    }
+    return result;
+  }
+}
+/**
+ * @param payload Contains dataIndex (means rawIndex) / dataIndexInside / name
+ *                         each of which can be Array or primary type.
+ * @return dataIndex If not found, return undefined/null.
+ */
+function queryDataIndex(data, payload) {
+  if (payload.dataIndexInside != null) {
+    return payload.dataIndexInside;
+  } else if (payload.dataIndex != null) {
+    return isArray(payload.dataIndex) ? map(payload.dataIndex, function (value) {
+      return data.indexOfRawIndex(value);
+    }) : data.indexOfRawIndex(payload.dataIndex);
+  } else if (payload.name != null) {
+    return isArray(payload.name) ? map(payload.name, function (value) {
+      return data.indexOfName(value);
+    }) : data.indexOfName(payload.name);
+  }
+}
+/**
+ * Enable property storage to any host object.
+ * Notice: Serialization is not supported.
+ *
+ * For example:
+ * let inner = zrUitl.makeInner();
+ *
+ * function some1(hostObj) {
+ *      inner(hostObj).someProperty = 1212;
+ *      ...
+ * }
+ * function some2() {
+ *      let fields = inner(this);
+ *      fields.someProperty1 = 1212;
+ *      fields.someProperty2 = 'xx';
+ *      ...
+ * }
+ *
+ * @return {Function}
+ */
+function makeInner() {
+  var key = '__ec_inner_' + innerUniqueIndex++;
+  return function (hostObj) {
+    return hostObj[key] || (hostObj[key] = {});
+  };
+}
+var innerUniqueIndex = getRandomIdBase();
+/**
+ * The same behavior as `component.getReferringComponents`.
+ */
+function parseFinder(ecModel, finderInput, opt) {
+  var _a = preParseFinder(finderInput, opt),
+    mainTypeSpecified = _a.mainTypeSpecified,
+    queryOptionMap = _a.queryOptionMap,
+    others = _a.others;
+  var result = others;
+  var defaultMainType = opt ? opt.defaultMainType : null;
+  if (!mainTypeSpecified && defaultMainType) {
+    queryOptionMap.set(defaultMainType, {});
+  }
+  queryOptionMap.each(function (queryOption, mainType) {
+    var queryResult = queryReferringComponents(ecModel, mainType, queryOption, {
+      useDefault: defaultMainType === mainType,
+      enableAll: opt && opt.enableAll != null ? opt.enableAll : true,
+      enableNone: opt && opt.enableNone != null ? opt.enableNone : true
+    });
+    result[mainType + 'Models'] = queryResult.models;
+    result[mainType + 'Model'] = queryResult.models[0];
+  });
+  return result;
+}
+function preParseFinder(finderInput, opt) {
+  var finder;
+  if (isString(finderInput)) {
+    var obj = {};
+    obj[finderInput + 'Index'] = 0;
+    finder = obj;
+  } else {
+    finder = finderInput;
+  }
+  var queryOptionMap = createHashMap();
+  var others = {};
+  var mainTypeSpecified = false;
+  each(finder, function (value, key) {
+    // Exclude 'dataIndex' and other illegal keys.
+    if (key === 'dataIndex' || key === 'dataIndexInside') {
+      others[key] = value;
+      return;
+    }
+    var parsedKey = key.match(/^(\w+)(Index|Id|Name)$/) || [];
+    var mainType = parsedKey[1];
+    var queryType = (parsedKey[2] || '').toLowerCase();
+    if (!mainType || !queryType || opt && opt.includeMainTypes && indexOf(opt.includeMainTypes, mainType) < 0) {
+      return;
+    }
+    mainTypeSpecified = mainTypeSpecified || !!mainType;
+    var queryOption = queryOptionMap.get(mainType) || queryOptionMap.set(mainType, {});
+    queryOption[queryType] = value;
+  });
+  return {
+    mainTypeSpecified: mainTypeSpecified,
+    queryOptionMap: queryOptionMap,
+    others: others
+  };
+}
+var SINGLE_REFERRING = {
+  useDefault: true,
+  enableAll: false,
+  enableNone: false
+};
+var MULTIPLE_REFERRING = {
+  useDefault: false,
+  enableAll: true,
+  enableNone: true
+};
+function queryReferringComponents(ecModel, mainType, userOption, opt) {
+  opt = opt || SINGLE_REFERRING;
+  var indexOption = userOption.index;
+  var idOption = userOption.id;
+  var nameOption = userOption.name;
+  var result = {
+    models: null,
+    specified: indexOption != null || idOption != null || nameOption != null
+  };
+  if (!result.specified) {
+    // Use the first as default if `useDefault`.
+    var firstCmpt = void 0;
+    result.models = opt.useDefault && (firstCmpt = ecModel.getComponent(mainType)) ? [firstCmpt] : [];
+    return result;
+  }
+  if (indexOption === 'none' || indexOption === false) {
+    if (opt.enableNone) {
+      result.models = [];
+      return result;
+    } else {
+      // Do not throw; consider if some component previously does not use this method,
+      // and start to use it, need to be fault-tolerant for backward compatibility.
+      if (process.env.NODE_ENV !== 'production') {
+        error('`"none"` or `false` is not a valid value on index option.');
+      }
+      indexOption = -1; // Can not query by index but may still query by id/name if specified.
+    }
+  }
+  // `queryComponents` will return all components if
+  // both all of index/id/name are null/undefined.
+  if (indexOption === 'all') {
+    if (opt.enableAll) {
+      indexOption = idOption = nameOption = null;
+    } else {
+      if (process.env.NODE_ENV !== 'production') {
+        error('`"all"` is not a valid value on index option.');
+      }
+      indexOption = -1;
+    }
+  }
+  result.models = ecModel.queryComponents({
+    mainType: mainType,
+    index: indexOption,
+    id: idOption,
+    name: nameOption
+  });
+  return result;
+}
+function setAttribute(dom, key, value) {
+  dom.setAttribute ? dom.setAttribute(key, value) : dom[key] = value;
+}
+function getAttribute(dom, key) {
+  return dom.getAttribute ? dom.getAttribute(key) : dom[key];
+}
+function getTooltipRenderMode(renderModeOption) {
+  if (renderModeOption === 'auto') {
+    // Using html when `document` exists, use richText otherwise
+    return env.domSupported ? 'html' : 'richText';
+  } else {
+    return renderModeOption || 'html';
+  }
+}
+/**
+ * Group a list by key.
+ */
+function groupData(array, getKey // return key
+) {
+  var buckets = createHashMap();
+  var keys = [];
+  each(array, function (item) {
+    var key = getKey(item);
+    (buckets.get(key) || (keys.push(key), buckets.set(key, []))).push(item);
+  });
+  return {
+    keys: keys,
+    buckets: buckets
+  };
+}
+/**
+ * Interpolate raw values of a series with percent
+ *
+ * @param data         data
+ * @param labelModel   label model of the text element
+ * @param sourceValue  start value. May be null/undefined when init.
+ * @param targetValue  end value
+ * @param percent      0~1 percentage; 0 uses start value while 1 uses end value
+ * @return             interpolated values
+ *                     If `sourceValue` and `targetValue` are `number`, return `number`.
+ *                     If `sourceValue` and `targetValue` are `string`, return `string`.
+ *                     If `sourceValue` and `targetValue` are `(string | number)[]`, return `(string | number)[]`.
+ *                     Other cases do not supported.
+ */
+function interpolateRawValues(data, precision, sourceValue, targetValue, percent) {
+  var isAutoPrecision = precision == null || precision === 'auto';
+  if (targetValue == null) {
+    return targetValue;
+  }
+  if (isNumber(targetValue)) {
+    var value = interpolateNumber(sourceValue || 0, targetValue, percent);
+    return round(value, isAutoPrecision ? Math.max(getPrecision(sourceValue || 0), getPrecision(targetValue)) : precision);
+  } else if (isString(targetValue)) {
+    return percent < 1 ? sourceValue : targetValue;
+  } else {
+    var interpolated = [];
+    var leftArr = sourceValue;
+    var rightArr = targetValue;
+    var length_1 = Math.max(leftArr ? leftArr.length : 0, rightArr.length);
+    for (var i = 0; i < length_1; ++i) {
+      var info = data.getDimensionInfo(i);
+      // Don't interpolate ordinal dims
+      if (info && info.type === 'ordinal') {
+        // In init, there is no `sourceValue`, but should better not to get undefined result.
+        interpolated[i] = (percent < 1 && leftArr ? leftArr : rightArr)[i];
+      } else {
+        var leftVal = leftArr && leftArr[i] ? leftArr[i] : 0;
+        var rightVal = rightArr[i];
+        var value = interpolateNumber(leftVal, rightVal, percent);
+        interpolated[i] = round(value, isAutoPrecision ? Math.max(getPrecision(leftVal), getPrecision(rightVal)) : precision);
+      }
+    }
+    return interpolated;
+  }
+}
+/**
+ * Use an iterator to avoid exposing the internal list or duplicating it
+ * for the outside traveller, and no extra heap allocation.
+ * @usage
+ *  for (const it = resetIterator(); it.next();) {
+ *      const item = it.item;
+ *      const key = it.key;
+ *      const itIdx = it.itIdx;
+ *      // ...
+ *  }
+ * @usage
+ *  const it = resetIterator();
+ *  while (it.next()) { ... }
+ * @usage
+ *  for (resetIterator(it); it.next();) { ... }
+ */
+var ListIterator = /** @class */function () {
+  function ListIterator() {}
+  /**
+   * The loop condition is `idx < end` if `step > 0`;
+   * The loop condition is `idx >= end` if `step < 0`.
+   *
+   * @param end By default `list.length` if `step > 0`; `0` if `step < 0`.
+   * @param step By default `1`.
+   */
+  ListIterator.prototype.reset = function (list, start, end, step) {
+    this._list = list;
+    this._step = step = step || 1;
+    this._idx = start;
+    this._end = end != null ? end : step > 0 ? list.length : 0;
+    this.item = null;
+    this.key = NaN;
+    return this;
+  };
+  ListIterator.prototype.next = function () {
+    if (this._step > 0 ? this._idx < this._end : this._idx >= this._end) {
+      this.item = this._list[this._idx];
+      this.key = this._idx = this._idx + this._step;
+      return true;
+    }
+    return false;
+  };
+  return ListIterator;
+}();
+function clearTmpModel(model) {
+  // Clear to avoid memory leak.
+  model.option = model.parentModel = model.ecModel = null;
+}
+
+export { ListIterator, MULTIPLE_REFERRING, SINGLE_REFERRING, TEXT_STYLE_OPTIONS, clearTmpModel, compressBatches, convertOptionIdName, defaultEmphasis, getAttribute, getDataItemValue, getTooltipRenderMode, groupData, interpolateRawValues, isComponentIdInternal, isDataItemOption, isNameSpecified, makeInner, makeInternalComponentId, mappingToExists, normalizeToArray, parseFinder, preParseFinder, queryDataIndex, queryReferringComponents, setAttribute, setComponentTypeToKeyInfo };