@fecp/mobile 1.0.78 → 1.1.0

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/util/model.js

@@ -0,0 +1,391 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+const env = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/env.js");
+const number = require("./number.js");
+function interpolateNumber(p0, p1, percent) {
+  return (p1 - p0) * percent + p0;
+}
+var DUMMY_COMPONENT_NAME_PREFIX = "series\0";
+var INTERNAL_COMPONENT_ID_PREFIX = "\0_ec_\0";
+function normalizeToArray(value) {
+  return value instanceof Array ? value : value == null ? [] : [value];
+}
+function defaultEmphasis(opt, key, subOpts) {
+  if (opt) {
+    opt[key] = opt[key] || {};
+    opt.emphasis = opt.emphasis || {};
+    opt.emphasis[key] = opt.emphasis[key] || {};
+    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"];
+function getDataItemValue(dataItem) {
+  return util.isObject(dataItem) && !util.isArray(dataItem) && !(dataItem instanceof Date) ? dataItem.value : dataItem;
+}
+function isDataItemOption(dataItem) {
+  return util.isObject(dataItem) && !(dataItem instanceof Array);
+}
+function mappingToExists(existings, newCmptOptions, mode) {
+  var isNormalMergeMode = mode === "normalMerge";
+  var isReplaceMergeMode = mode === "replaceMerge";
+  var isReplaceAllMode = mode === "replaceAll";
+  existings = existings || [];
+  newCmptOptions = (newCmptOptions || []).slice();
+  var existingIdIdxMap = util.createHashMap();
+  util.each(newCmptOptions, function(cmptOption, index) {
+    if (!util.isObject(cmptOption)) {
+      newCmptOptions[index] = null;
+      return;
+    }
+  });
+  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);
+  return result;
+}
+function prepareResult(existings, existingIdIdxMap, mode) {
+  var result = [];
+  if (mode === "replaceAll") {
+    return result;
+  }
+  for (var index = 0; index < existings.length; index++) {
+    var existing = existings[index];
+    if (existing && existing.id != null) {
+      existingIdIdxMap.set(existing.id, index);
+    }
+    result.push({
+      existing: mode === "replaceMerge" || isComponentIdInternal(existing) ? null : existing,
+      newOption: null,
+      keyInfo: null,
+      brandNew: null
+    });
+  }
+  return result;
+}
+function mappingById(result, existings, existingIdIdxMap, newCmptOptions) {
+  util.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];
+      util.assert(!resultItem.newOption, 'Duplicated option on id "' + optionId + '".');
+      resultItem.newOption = cmptOption;
+      resultItem.existing = existings[existingIdx];
+      newCmptOptions[index] = null;
+    }
+  });
+}
+function mappingByName(result, newCmptOptions) {
+  util.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 && 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) {
+  util.each(newCmptOptions, function(cmptOption) {
+    if (!cmptOption) {
+      return;
+    }
+    var resultItem;
+    var nextIdx = 0;
+    while (
+      // Be `!resultItem` only when `nextIdx >= result.length`.
+      (resultItem = result[nextIdx]) && (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,
+        existing: null,
+        keyInfo: null
+      });
+    }
+    nextIdx++;
+  });
+}
+function mappingInReplaceAllMode(result, newCmptOptions) {
+  util.each(newCmptOptions, function(cmptOption) {
+    result.push({
+      newOption: cmptOption,
+      brandNew: true,
+      existing: null,
+      keyInfo: null
+    });
+  });
+}
+function makeIdAndName(mapResult) {
+  var idMap = util.createHashMap();
+  util.each(mapResult, function(item) {
+    var existing = item.existing;
+    existing && idMap.set(existing.id, item);
+  });
+  util.each(mapResult, function(item) {
+    var opt = item.newOption;
+    util.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 = {});
+  });
+  util.each(mapResult, function(item, index) {
+    var existing = item.existing;
+    var opt = item.newOption;
+    var keyInfo = item.keyInfo;
+    if (!util.isObject(opt)) {
+      return;
+    }
+    keyInfo.name = opt.name != null ? makeComparableKey(opt.name) : existing ? existing.name : DUMMY_COMPONENT_NAME_PREFIX + index;
+    if (existing) {
+      keyInfo.id = makeComparableKey(existing.id);
+    } else if (opt.id != null) {
+      keyInfo.id = makeComparableKey(opt.id);
+    } else {
+      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);
+  return key1 != null && key2 != null && key1 === key2;
+}
+function makeComparableKey(val) {
+  return convertOptionIdName(val, "");
+}
+function convertOptionIdName(idOrName, defaultValue) {
+  if (idOrName == null) {
+    return defaultValue;
+  }
+  return util.isString(idOrName) ? idOrName : util.isNumber(idOrName) || util.isStringSafe(idOrName) ? idOrName + "" : defaultValue;
+}
+function isNameSpecified(componentModel) {
+  var name = componentModel.name;
+  return !!(name && name.indexOf(DUMMY_COMPONENT_NAME_PREFIX));
+}
+function isComponentIdInternal(cmptOption) {
+  return cmptOption && cmptOption.id != null && makeComparableKey(cmptOption.id).indexOf(INTERNAL_COMPONENT_ID_PREFIX) === 0;
+}
+function setComponentTypeToKeyInfo(mappingResult, mainType, componentModelCtor) {
+  util.each(mappingResult, function(item) {
+    var newOption = item.newOption;
+    if (util.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 : componentModelCtor.determineSubType(mainType, newCmptOption);
+  return subType;
+}
+function queryDataIndex(data, payload) {
+  if (payload.dataIndexInside != null) {
+    return payload.dataIndexInside;
+  } else if (payload.dataIndex != null) {
+    return util.isArray(payload.dataIndex) ? util.map(payload.dataIndex, function(value) {
+      return data.indexOfRawIndex(value);
+    }) : data.indexOfRawIndex(payload.dataIndex);
+  } else if (payload.name != null) {
+    return util.isArray(payload.name) ? util.map(payload.name, function(value) {
+      return data.indexOfName(value);
+    }) : data.indexOfName(payload.name);
+  }
+}
+function makeInner() {
+  var key = "__ec_inner_" + innerUniqueIndex++;
+  return function(hostObj) {
+    return hostObj[key] || (hostObj[key] = {});
+  };
+}
+var innerUniqueIndex = number.getRandomIdBase();
+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 (util.isString(finderInput)) {
+    var obj = {};
+    obj[finderInput + "Index"] = 0;
+    finder = obj;
+  } else {
+    finder = finderInput;
+  }
+  var queryOptionMap = util.createHashMap();
+  var others = {};
+  var mainTypeSpecified = false;
+  util.each(finder, function(value, key) {
+    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 && util.indexOf(opt.includeMainTypes, mainType) < 0) {
+      return;
+    }
+    mainTypeSpecified = mainTypeSpecified || !!mainType;
+    var queryOption = queryOptionMap.get(mainType) || queryOptionMap.set(mainType, {});
+    queryOption[queryType] = value;
+  });
+  return {
+    mainTypeSpecified,
+    queryOptionMap,
+    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) {
+    var firstCmpt = void 0;
+    result.models = opt.useDefault && (firstCmpt = ecModel.getComponent(mainType)) ? [firstCmpt] : [];
+    return result;
+  }
+  if (indexOption === "none" || indexOption === false) {
+    util.assert(opt.enableNone, '`"none"` or `false` is not a valid value on index option.');
+    result.models = [];
+    return result;
+  }
+  if (indexOption === "all") {
+    util.assert(opt.enableAll, '`"all"` is not a valid value on index option.');
+    indexOption = idOption = nameOption = null;
+  }
+  result.models = ecModel.queryComponents({
+    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") {
+    return env.default.domSupported ? "html" : "richText";
+  } else {
+    return renderModeOption || "html";
+  }
+}
+function interpolateRawValues(data, precision, sourceValue, targetValue, percent) {
+  var isAutoPrecision = precision == null || precision === "auto";
+  if (targetValue == null) {
+    return targetValue;
+  }
+  if (util.isNumber(targetValue)) {
+    var value = interpolateNumber(sourceValue || 0, targetValue, percent);
+    return number.round(value, isAutoPrecision ? Math.max(number.getPrecision(sourceValue || 0), number.getPrecision(targetValue)) : precision);
+  } else if (util.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);
+      if (info && info.type === "ordinal") {
+        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] = number.round(value, isAutoPrecision ? Math.max(number.getPrecision(leftVal), number.getPrecision(rightVal)) : precision);
+      }
+    }
+    return interpolated;
+  }
+}
+exports.MULTIPLE_REFERRING = MULTIPLE_REFERRING;
+exports.SINGLE_REFERRING = SINGLE_REFERRING;
+exports.TEXT_STYLE_OPTIONS = TEXT_STYLE_OPTIONS;
+exports.convertOptionIdName = convertOptionIdName;
+exports.defaultEmphasis = defaultEmphasis;
+exports.getAttribute = getAttribute;
+exports.getDataItemValue = getDataItemValue;
+exports.getTooltipRenderMode = getTooltipRenderMode;
+exports.interpolateRawValues = interpolateRawValues;
+exports.isComponentIdInternal = isComponentIdInternal;
+exports.isDataItemOption = isDataItemOption;
+exports.isNameSpecified = isNameSpecified;
+exports.makeInner = makeInner;
+exports.mappingToExists = mappingToExists;
+exports.normalizeToArray = normalizeToArray;
+exports.parseFinder = parseFinder;
+exports.preParseFinder = preParseFinder;
+exports.queryDataIndex = queryDataIndex;
+exports.queryReferringComponents = queryReferringComponents;
+exports.setAttribute = setAttribute;
+exports.setComponentTypeToKeyInfo = setComponentTypeToKeyInfo;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/util/number.js

@@ -0,0 +1,322 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+var RADIAN_EPSILON = 1e-4;
+var ROUND_SUPPORTED_PRECISION_MAX = 20;
+function _trim(str) {
+  return str.replace(/^\s+|\s+$/g, "");
+}
+function linearMap(val, domain, range, clamp) {
+  var d0 = domain[0];
+  var d1 = domain[1];
+  var r0 = range[0];
+  var r1 = range[1];
+  var subDomain = d1 - d0;
+  var subRange = r1 - r0;
+  if (subDomain === 0) {
+    return subRange === 0 ? r0 : (r0 + r1) / 2;
+  }
+  if (clamp) {
+    if (subDomain > 0) {
+      if (val <= d0) {
+        return r0;
+      } else if (val >= d1) {
+        return r1;
+      }
+    } else {
+      if (val >= d0) {
+        return r0;
+      } else if (val <= d1) {
+        return r1;
+      }
+    }
+  } else {
+    if (val === d0) {
+      return r0;
+    }
+    if (val === d1) {
+      return r1;
+    }
+  }
+  return (val - d0) / subDomain * subRange + r0;
+}
+function parsePercent(percent, all) {
+  switch (percent) {
+    case "center":
+    case "middle":
+      percent = "50%";
+      break;
+    case "left":
+    case "top":
+      percent = "0%";
+      break;
+    case "right":
+    case "bottom":
+      percent = "100%";
+      break;
+  }
+  if (util.isString(percent)) {
+    if (_trim(percent).match(/%$/)) {
+      return parseFloat(percent) / 100 * all;
+    }
+    return parseFloat(percent);
+  }
+  return percent == null ? NaN : +percent;
+}
+function round(x, precision, returnStr) {
+  if (precision == null) {
+    precision = 10;
+  }
+  precision = Math.min(Math.max(0, precision), ROUND_SUPPORTED_PRECISION_MAX);
+  x = (+x).toFixed(precision);
+  return returnStr ? x : +x;
+}
+function asc(arr) {
+  arr.sort(function(a, b) {
+    return a - b;
+  });
+  return arr;
+}
+function getPrecision(val) {
+  val = +val;
+  if (isNaN(val)) {
+    return 0;
+  }
+  if (val > 1e-14) {
+    var e = 1;
+    for (var i = 0; i < 15; i++, e *= 10) {
+      if (Math.round(val * e) / e === val) {
+        return i;
+      }
+    }
+  }
+  return getPrecisionSafe(val);
+}
+function getPrecisionSafe(val) {
+  var str = val.toString().toLowerCase();
+  var eIndex = str.indexOf("e");
+  var exp = eIndex > 0 ? +str.slice(eIndex + 1) : 0;
+  var significandPartLen = eIndex > 0 ? eIndex : str.length;
+  var dotIndex = str.indexOf(".");
+  var decimalPartLen = dotIndex < 0 ? 0 : significandPartLen - 1 - dotIndex;
+  return Math.max(0, decimalPartLen - exp);
+}
+function getPixelPrecision(dataExtent, pixelExtent) {
+  var log = Math.log;
+  var LN10 = Math.LN10;
+  var dataQuantity = Math.floor(log(dataExtent[1] - dataExtent[0]) / LN10);
+  var sizeQuantity = Math.round(log(Math.abs(pixelExtent[1] - pixelExtent[0])) / LN10);
+  var precision = Math.min(Math.max(-dataQuantity + sizeQuantity, 0), 20);
+  return !isFinite(precision) ? 20 : precision;
+}
+function getPercentWithPrecision(valueList, idx, precision) {
+  if (!valueList[idx]) {
+    return 0;
+  }
+  var seats = getPercentSeats(valueList, precision);
+  return seats[idx] || 0;
+}
+function getPercentSeats(valueList, precision) {
+  var sum = util.reduce(valueList, function(acc, val) {
+    return acc + (isNaN(val) ? 0 : val);
+  }, 0);
+  if (sum === 0) {
+    return [];
+  }
+  var digits = Math.pow(10, precision);
+  var votesPerQuota = util.map(valueList, function(val) {
+    return (isNaN(val) ? 0 : val) / sum * digits * 100;
+  });
+  var targetSeats = digits * 100;
+  var seats = util.map(votesPerQuota, function(votes) {
+    return Math.floor(votes);
+  });
+  var currentSum = util.reduce(seats, function(acc, val) {
+    return acc + val;
+  }, 0);
+  var remainder = util.map(votesPerQuota, function(votes, idx) {
+    return votes - seats[idx];
+  });
+  while (currentSum < targetSeats) {
+    var max = Number.NEGATIVE_INFINITY;
+    var maxId = null;
+    for (var i = 0, len = remainder.length; i < len; ++i) {
+      if (remainder[i] > max) {
+        max = remainder[i];
+        maxId = i;
+      }
+    }
+    ++seats[maxId];
+    remainder[maxId] = 0;
+    ++currentSum;
+  }
+  return util.map(seats, function(seat) {
+    return seat / digits;
+  });
+}
+function addSafe(val0, val1) {
+  var maxPrecision = Math.max(getPrecision(val0), getPrecision(val1));
+  var sum = val0 + val1;
+  return maxPrecision > ROUND_SUPPORTED_PRECISION_MAX ? sum : round(sum, maxPrecision);
+}
+var MAX_SAFE_INTEGER = 9007199254740991;
+function remRadian(radian) {
+  var pi2 = Math.PI * 2;
+  return (radian % pi2 + pi2) % pi2;
+}
+function isRadianAroundZero(val) {
+  return val > -1e-4 && val < RADIAN_EPSILON;
+}
+var TIME_REG = /^(?:(\d{4})(?:[-\/](\d{1,2})(?:[-\/](\d{1,2})(?:[T ](\d{1,2})(?::(\d{1,2})(?::(\d{1,2})(?:[.,](\d+))?)?)?(Z|[\+\-]\d\d:?\d\d)?)?)?)?)?$/;
+function parseDate(value) {
+  if (value instanceof Date) {
+    return value;
+  } else if (util.isString(value)) {
+    var match = TIME_REG.exec(value);
+    if (!match) {
+      return /* @__PURE__ */ new Date(NaN);
+    }
+    if (!match[8]) {
+      return new Date(+match[1], +(match[2] || 1) - 1, +match[3] || 1, +match[4] || 0, +(match[5] || 0), +match[6] || 0, match[7] ? +match[7].substring(0, 3) : 0);
+    } else {
+      var hour = +match[4] || 0;
+      if (match[8].toUpperCase() !== "Z") {
+        hour -= +match[8].slice(0, 3);
+      }
+      return new Date(Date.UTC(+match[1], +(match[2] || 1) - 1, +match[3] || 1, hour, +(match[5] || 0), +match[6] || 0, match[7] ? +match[7].substring(0, 3) : 0));
+    }
+  } else if (value == null) {
+    return /* @__PURE__ */ new Date(NaN);
+  }
+  return new Date(Math.round(value));
+}
+function quantity(val) {
+  return Math.pow(10, quantityExponent(val));
+}
+function quantityExponent(val) {
+  if (val === 0) {
+    return 0;
+  }
+  var exp = Math.floor(Math.log(val) / Math.LN10);
+  if (val / Math.pow(10, exp) >= 10) {
+    exp++;
+  }
+  return exp;
+}
+function nice(val, round2) {
+  var exponent = quantityExponent(val);
+  var exp10 = Math.pow(10, exponent);
+  var f = val / exp10;
+  var nf;
+  if (round2) {
+    if (f < 1.5) {
+      nf = 1;
+    } else if (f < 2.5) {
+      nf = 2;
+    } else if (f < 4) {
+      nf = 3;
+    } else if (f < 7) {
+      nf = 5;
+    } else {
+      nf = 10;
+    }
+  } else {
+    if (f < 1) {
+      nf = 1;
+    } else if (f < 2) {
+      nf = 2;
+    } else if (f < 3) {
+      nf = 3;
+    } else if (f < 5) {
+      nf = 5;
+    } else {
+      nf = 10;
+    }
+  }
+  val = nf * exp10;
+  return exponent >= -20 ? +val.toFixed(exponent < 0 ? -exponent : 0) : val;
+}
+function quantile(ascArr, p) {
+  var H = (ascArr.length - 1) * p + 1;
+  var h = Math.floor(H);
+  var v = +ascArr[h - 1];
+  var e = H - h;
+  return e ? v + e * (ascArr[h] - v) : v;
+}
+function reformIntervals(list) {
+  list.sort(function(a, b) {
+    return littleThan(a, b, 0) ? -1 : 1;
+  });
+  var curr = -Infinity;
+  var currClose = 1;
+  for (var i = 0; i < list.length; ) {
+    var interval = list[i].interval;
+    var close_1 = list[i].close;
+    for (var lg = 0; lg < 2; lg++) {
+      if (interval[lg] <= curr) {
+        interval[lg] = curr;
+        close_1[lg] = !lg ? 1 - currClose : 1;
+      }
+      curr = interval[lg];
+      currClose = close_1[lg];
+    }
+    if (interval[0] === interval[1] && close_1[0] * close_1[1] !== 1) {
+      list.splice(i, 1);
+    } else {
+      i++;
+    }
+  }
+  return list;
+  function littleThan(a, b, lg2) {
+    return a.interval[lg2] < b.interval[lg2] || a.interval[lg2] === b.interval[lg2] && (a.close[lg2] - b.close[lg2] === (!lg2 ? 1 : -1) || !lg2 && littleThan(a, b, 1));
+  }
+}
+function numericToNumber(val) {
+  var valFloat = parseFloat(val);
+  return valFloat == val && (valFloat !== 0 || !util.isString(val) || val.indexOf("x") <= 0) ? valFloat : NaN;
+}
+function isNumeric(val) {
+  return !isNaN(numericToNumber(val));
+}
+function getRandomIdBase() {
+  return Math.round(Math.random() * 9);
+}
+function getGreatestCommonDividor(a, b) {
+  if (b === 0) {
+    return a;
+  }
+  return getGreatestCommonDividor(b, a % b);
+}
+function getLeastCommonMultiple(a, b) {
+  if (a == null) {
+    return b;
+  }
+  if (b == null) {
+    return a;
+  }
+  return a * b / getGreatestCommonDividor(a, b);
+}
+exports.MAX_SAFE_INTEGER = MAX_SAFE_INTEGER;
+exports.addSafe = addSafe;
+exports.asc = asc;
+exports.getGreatestCommonDividor = getGreatestCommonDividor;
+exports.getLeastCommonMultiple = getLeastCommonMultiple;
+exports.getPercentSeats = getPercentSeats;
+exports.getPercentWithPrecision = getPercentWithPrecision;
+exports.getPixelPrecision = getPixelPrecision;
+exports.getPrecision = getPrecision;
+exports.getPrecisionSafe = getPrecisionSafe;
+exports.getRandomIdBase = getRandomIdBase;
+exports.isNumeric = isNumeric;
+exports.isRadianAroundZero = isRadianAroundZero;
+exports.linearMap = linearMap;
+exports.nice = nice;
+exports.numericToNumber = numericToNumber;
+exports.parseDate = parseDate;
+exports.parsePercent = parsePercent;
+exports.quantile = quantile;
+exports.quantity = quantity;
+exports.quantityExponent = quantityExponent;
+exports.reformIntervals = reformIntervals;
+exports.remRadian = remRadian;
+exports.round = round;