@fecp/mobile 1.0.79 → 1.1.1

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

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const model = require("../util/model.js");
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+var QUERY_REG = /^(min|max)?(.+)$/;
+var OptionManager = (
+  /** @class */
+  function() {
+    function OptionManager2(api) {
+      this._timelineOptions = [];
+      this._mediaList = [];
+      this._currentMediaIndices = [];
+      this._api = api;
+    }
+    OptionManager2.prototype.setOption = function(rawOption, optionPreprocessorFuncs, opt) {
+      if (rawOption) {
+        util.each(model.normalizeToArray(rawOption.series), function(series) {
+          series && series.data && util.isTypedArray(series.data) && util.setAsPrimitive(series.data);
+        });
+        util.each(model.normalizeToArray(rawOption.dataset), function(dataset) {
+          dataset && dataset.source && util.isTypedArray(dataset.source) && util.setAsPrimitive(dataset.source);
+        });
+      }
+      rawOption = util.clone(rawOption);
+      var optionBackup = this._optionBackup;
+      var newParsedOption = parseRawOption(rawOption, optionPreprocessorFuncs, !optionBackup);
+      this._newBaseOption = newParsedOption.baseOption;
+      if (optionBackup) {
+        if (newParsedOption.timelineOptions.length) {
+          optionBackup.timelineOptions = newParsedOption.timelineOptions;
+        }
+        if (newParsedOption.mediaList.length) {
+          optionBackup.mediaList = newParsedOption.mediaList;
+        }
+        if (newParsedOption.mediaDefault) {
+          optionBackup.mediaDefault = newParsedOption.mediaDefault;
+        }
+      } else {
+        this._optionBackup = newParsedOption;
+      }
+    };
+    OptionManager2.prototype.mountOption = function(isRecreate) {
+      var optionBackup = this._optionBackup;
+      this._timelineOptions = optionBackup.timelineOptions;
+      this._mediaList = optionBackup.mediaList;
+      this._mediaDefault = optionBackup.mediaDefault;
+      this._currentMediaIndices = [];
+      return util.clone(isRecreate ? optionBackup.baseOption : this._newBaseOption);
+    };
+    OptionManager2.prototype.getTimelineOption = function(ecModel) {
+      var option;
+      var timelineOptions = this._timelineOptions;
+      if (timelineOptions.length) {
+        var timelineModel = ecModel.getComponent("timeline");
+        if (timelineModel) {
+          option = util.clone(
+            // FIXME:TS as TimelineModel or quivlant interface
+            timelineOptions[timelineModel.getCurrentIndex()]
+          );
+        }
+      }
+      return option;
+    };
+    OptionManager2.prototype.getMediaOption = function(ecModel) {
+      var ecWidth = this._api.getWidth();
+      var ecHeight = this._api.getHeight();
+      var mediaList = this._mediaList;
+      var mediaDefault = this._mediaDefault;
+      var indices = [];
+      var result = [];
+      if (!mediaList.length && !mediaDefault) {
+        return result;
+      }
+      for (var i = 0, len = mediaList.length; i < len; i++) {
+        if (applyMediaQuery(mediaList[i].query, ecWidth, ecHeight)) {
+          indices.push(i);
+        }
+      }
+      if (!indices.length && mediaDefault) {
+        indices = [-1];
+      }
+      if (indices.length && !indicesEquals(indices, this._currentMediaIndices)) {
+        result = util.map(indices, function(index) {
+          return util.clone(index === -1 ? mediaDefault.option : mediaList[index].option);
+        });
+      }
+      this._currentMediaIndices = indices;
+      return result;
+    };
+    return OptionManager2;
+  }()
+);
+function parseRawOption(rawOption, optionPreprocessorFuncs, isNew) {
+  var mediaList = [];
+  var mediaDefault;
+  var baseOption;
+  var declaredBaseOption = rawOption.baseOption;
+  var timelineOnRoot = rawOption.timeline;
+  var timelineOptionsOnRoot = rawOption.options;
+  var mediaOnRoot = rawOption.media;
+  var hasMedia = !!rawOption.media;
+  var hasTimeline = !!(timelineOptionsOnRoot || timelineOnRoot || declaredBaseOption && declaredBaseOption.timeline);
+  if (declaredBaseOption) {
+    baseOption = declaredBaseOption;
+    if (!baseOption.timeline) {
+      baseOption.timeline = timelineOnRoot;
+    }
+  } else {
+    if (hasTimeline || hasMedia) {
+      rawOption.options = rawOption.media = null;
+    }
+    baseOption = rawOption;
+  }
+  if (hasMedia) {
+    if (util.isArray(mediaOnRoot)) {
+      util.each(mediaOnRoot, function(singleMedia) {
+        if (singleMedia && singleMedia.option) {
+          if (singleMedia.query) {
+            mediaList.push(singleMedia);
+          } else if (!mediaDefault) {
+            mediaDefault = singleMedia;
+          }
+        }
+      });
+    }
+  }
+  doPreprocess(baseOption);
+  util.each(timelineOptionsOnRoot, function(option) {
+    return doPreprocess(option);
+  });
+  util.each(mediaList, function(media) {
+    return doPreprocess(media.option);
+  });
+  function doPreprocess(option) {
+    util.each(optionPreprocessorFuncs, function(preProcess) {
+      preProcess(option, isNew);
+    });
+  }
+  return {
+    baseOption,
+    timelineOptions: timelineOptionsOnRoot || [],
+    mediaDefault,
+    mediaList
+  };
+}
+function applyMediaQuery(query, ecWidth, ecHeight) {
+  var realMap = {
+    width: ecWidth,
+    height: ecHeight,
+    aspectratio: ecWidth / ecHeight
+    // lower case for convenience.
+  };
+  var applicable = true;
+  util.each(query, function(value, attr) {
+    var matched = attr.match(QUERY_REG);
+    if (!matched || !matched[1] || !matched[2]) {
+      return;
+    }
+    var operator = matched[1];
+    var realAttr = matched[2].toLowerCase();
+    if (!compare(realMap[realAttr], value, operator)) {
+      applicable = false;
+    }
+  });
+  return applicable;
+}
+function compare(real, expect, operator) {
+  if (operator === "min") {
+    return real >= expect;
+  } else if (operator === "max") {
+    return real <= expect;
+  } else {
+    return real === expect;
+  }
+}
+function indicesEquals(indices1, indices2) {
+  return indices1.join(",") === indices2.join(",");
+}
+exports.default = OptionManager;

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

@@ -0,0 +1,375 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const tslib_es6 = require("../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.js");
+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 model = require("../util/model.js");
+const Component = require("./Component.js");
+const palette = require("./mixin/palette.js");
+const dataFormat = require("./mixin/dataFormat.js");
+const layout = require("../util/layout.js");
+const task = require("../core/task.js");
+const clazz = require("../util/clazz.js");
+const sourceManager = require("../data/helper/sourceManager.js");
+const seriesFormatTooltip = require("../component/tooltip/seriesFormatTooltip.js");
+var inner = model.makeInner();
+function getSelectionKey(data, dataIndex) {
+  return data.getName(dataIndex) || data.getId(dataIndex);
+}
+var SERIES_UNIVERSAL_TRANSITION_PROP = "__universalTransitionEnabled";
+var SeriesModel = (
+  /** @class */
+  function(_super) {
+    tslib_es6.__extends(SeriesModel2, _super);
+    function SeriesModel2() {
+      var _this = _super !== null && _super.apply(this, arguments) || this;
+      _this._selectedDataIndicesMap = {};
+      return _this;
+    }
+    SeriesModel2.prototype.init = function(option, parentModel, ecModel) {
+      this.seriesIndex = this.componentIndex;
+      this.dataTask = task.createTask({
+        count: dataTaskCount,
+        reset: dataTaskReset
+      });
+      this.dataTask.context = {
+        model: this
+      };
+      this.mergeDefaultAndTheme(option, ecModel);
+      var sourceManager$1 = inner(this).sourceManager = new sourceManager.SourceManager(this);
+      sourceManager$1.prepareSource();
+      var data = this.getInitialData(option, ecModel);
+      wrapData(data, this);
+      this.dataTask.context.data = data;
+      inner(this).dataBeforeProcessed = data;
+      autoSeriesName(this);
+      this._initSelectedMapFromData(data);
+    };
+    SeriesModel2.prototype.mergeDefaultAndTheme = function(option, ecModel) {
+      var layoutMode = layout.fetchLayoutMode(this);
+      var inputPositionParams = layoutMode ? layout.getLayoutParams(option) : {};
+      var themeSubType = this.subType;
+      if (Component.default.hasClass(themeSubType)) {
+        themeSubType += "Series";
+      }
+      util.merge(option, ecModel.getTheme().get(this.subType));
+      util.merge(option, this.getDefaultOption());
+      model.defaultEmphasis(option, "label", ["show"]);
+      this.fillDataTextStyle(option.data);
+      if (layoutMode) {
+        layout.mergeLayoutParam(option, inputPositionParams, layoutMode);
+      }
+    };
+    SeriesModel2.prototype.mergeOption = function(newSeriesOption, ecModel) {
+      newSeriesOption = util.merge(this.option, newSeriesOption, true);
+      this.fillDataTextStyle(newSeriesOption.data);
+      var layoutMode = layout.fetchLayoutMode(this);
+      if (layoutMode) {
+        layout.mergeLayoutParam(this.option, newSeriesOption, layoutMode);
+      }
+      var sourceManager2 = inner(this).sourceManager;
+      sourceManager2.dirty();
+      sourceManager2.prepareSource();
+      var data = this.getInitialData(newSeriesOption, ecModel);
+      wrapData(data, this);
+      this.dataTask.dirty();
+      this.dataTask.context.data = data;
+      inner(this).dataBeforeProcessed = data;
+      autoSeriesName(this);
+      this._initSelectedMapFromData(data);
+    };
+    SeriesModel2.prototype.fillDataTextStyle = function(data) {
+      if (data && !util.isTypedArray(data)) {
+        var props = ["show"];
+        for (var i = 0; i < data.length; i++) {
+          if (data[i] && data[i].label) {
+            model.defaultEmphasis(data[i], "label", props);
+          }
+        }
+      }
+    };
+    SeriesModel2.prototype.getInitialData = function(option, ecModel) {
+      return;
+    };
+    SeriesModel2.prototype.appendData = function(params) {
+      var data = this.getRawData();
+      data.appendData(params.data);
+    };
+    SeriesModel2.prototype.getData = function(dataType) {
+      var task2 = getCurrentTask(this);
+      if (task2) {
+        var data = task2.context.data;
+        return dataType == null || !data.getLinkedData ? data : data.getLinkedData(dataType);
+      } else {
+        return inner(this).data;
+      }
+    };
+    SeriesModel2.prototype.getAllData = function() {
+      var mainData = this.getData();
+      return mainData && mainData.getLinkedDataAll ? mainData.getLinkedDataAll() : [{
+        data: mainData
+      }];
+    };
+    SeriesModel2.prototype.setData = function(data) {
+      var task2 = getCurrentTask(this);
+      if (task2) {
+        var context = task2.context;
+        context.outputData = data;
+        if (task2 !== this.dataTask) {
+          context.data = data;
+        }
+      }
+      inner(this).data = data;
+    };
+    SeriesModel2.prototype.getEncode = function() {
+      var encode = this.get("encode", true);
+      if (encode) {
+        return util.createHashMap(encode);
+      }
+    };
+    SeriesModel2.prototype.getSourceManager = function() {
+      return inner(this).sourceManager;
+    };
+    SeriesModel2.prototype.getSource = function() {
+      return this.getSourceManager().getSource();
+    };
+    SeriesModel2.prototype.getRawData = function() {
+      return inner(this).dataBeforeProcessed;
+    };
+    SeriesModel2.prototype.getColorBy = function() {
+      var colorBy = this.get("colorBy");
+      return colorBy || "series";
+    };
+    SeriesModel2.prototype.isColorBySeries = function() {
+      return this.getColorBy() === "series";
+    };
+    SeriesModel2.prototype.getBaseAxis = function() {
+      var coordSys = this.coordinateSystem;
+      return coordSys && coordSys.getBaseAxis && coordSys.getBaseAxis();
+    };
+    SeriesModel2.prototype.formatTooltip = function(dataIndex, multipleSeries, dataType) {
+      return seriesFormatTooltip.defaultSeriesFormatTooltip({
+        series: this,
+        dataIndex,
+        multipleSeries
+      });
+    };
+    SeriesModel2.prototype.isAnimationEnabled = function() {
+      var ecModel = this.ecModel;
+      if (env.default.node && !(ecModel && ecModel.ssr)) {
+        return false;
+      }
+      var animationEnabled = this.getShallow("animation");
+      if (animationEnabled) {
+        if (this.getData().count() > this.getShallow("animationThreshold")) {
+          animationEnabled = false;
+        }
+      }
+      return !!animationEnabled;
+    };
+    SeriesModel2.prototype.restoreData = function() {
+      this.dataTask.dirty();
+    };
+    SeriesModel2.prototype.getColorFromPalette = function(name, scope, requestColorNum) {
+      var ecModel = this.ecModel;
+      var color = palette.PaletteMixin.prototype.getColorFromPalette.call(this, name, scope, requestColorNum);
+      if (!color) {
+        color = ecModel.getColorFromPalette(name, scope, requestColorNum);
+      }
+      return color;
+    };
+    SeriesModel2.prototype.coordDimToDataDim = function(coordDim) {
+      return this.getRawData().mapDimensionsAll(coordDim);
+    };
+    SeriesModel2.prototype.getProgressive = function() {
+      return this.get("progressive");
+    };
+    SeriesModel2.prototype.getProgressiveThreshold = function() {
+      return this.get("progressiveThreshold");
+    };
+    SeriesModel2.prototype.select = function(innerDataIndices, dataType) {
+      this._innerSelect(this.getData(dataType), innerDataIndices);
+    };
+    SeriesModel2.prototype.unselect = function(innerDataIndices, dataType) {
+      var selectedMap = this.option.selectedMap;
+      if (!selectedMap) {
+        return;
+      }
+      var selectedMode = this.option.selectedMode;
+      var data = this.getData(dataType);
+      if (selectedMode === "series" || selectedMap === "all") {
+        this.option.selectedMap = {};
+        this._selectedDataIndicesMap = {};
+        return;
+      }
+      for (var i = 0; i < innerDataIndices.length; i++) {
+        var dataIndex = innerDataIndices[i];
+        var nameOrId = getSelectionKey(data, dataIndex);
+        selectedMap[nameOrId] = false;
+        this._selectedDataIndicesMap[nameOrId] = -1;
+      }
+    };
+    SeriesModel2.prototype.toggleSelect = function(innerDataIndices, dataType) {
+      var tmpArr = [];
+      for (var i = 0; i < innerDataIndices.length; i++) {
+        tmpArr[0] = innerDataIndices[i];
+        this.isSelected(innerDataIndices[i], dataType) ? this.unselect(tmpArr, dataType) : this.select(tmpArr, dataType);
+      }
+    };
+    SeriesModel2.prototype.getSelectedDataIndices = function() {
+      if (this.option.selectedMap === "all") {
+        return [].slice.call(this.getData().getIndices());
+      }
+      var selectedDataIndicesMap = this._selectedDataIndicesMap;
+      var nameOrIds = util.keys(selectedDataIndicesMap);
+      var dataIndices = [];
+      for (var i = 0; i < nameOrIds.length; i++) {
+        var dataIndex = selectedDataIndicesMap[nameOrIds[i]];
+        if (dataIndex >= 0) {
+          dataIndices.push(dataIndex);
+        }
+      }
+      return dataIndices;
+    };
+    SeriesModel2.prototype.isSelected = function(dataIndex, dataType) {
+      var selectedMap = this.option.selectedMap;
+      if (!selectedMap) {
+        return false;
+      }
+      var data = this.getData(dataType);
+      return (selectedMap === "all" || selectedMap[getSelectionKey(data, dataIndex)]) && !data.getItemModel(dataIndex).get(["select", "disabled"]);
+    };
+    SeriesModel2.prototype.isUniversalTransitionEnabled = function() {
+      if (this[SERIES_UNIVERSAL_TRANSITION_PROP]) {
+        return true;
+      }
+      var universalTransitionOpt = this.option.universalTransition;
+      if (!universalTransitionOpt) {
+        return false;
+      }
+      if (universalTransitionOpt === true) {
+        return true;
+      }
+      return universalTransitionOpt && universalTransitionOpt.enabled;
+    };
+    SeriesModel2.prototype._innerSelect = function(data, innerDataIndices) {
+      var _a, _b;
+      var option = this.option;
+      var selectedMode = option.selectedMode;
+      var len = innerDataIndices.length;
+      if (!selectedMode || !len) {
+        return;
+      }
+      if (selectedMode === "series") {
+        option.selectedMap = "all";
+      } else if (selectedMode === "multiple") {
+        if (!util.isObject(option.selectedMap)) {
+          option.selectedMap = {};
+        }
+        var selectedMap = option.selectedMap;
+        for (var i = 0; i < len; i++) {
+          var dataIndex = innerDataIndices[i];
+          var nameOrId = getSelectionKey(data, dataIndex);
+          selectedMap[nameOrId] = true;
+          this._selectedDataIndicesMap[nameOrId] = data.getRawIndex(dataIndex);
+        }
+      } else if (selectedMode === "single" || selectedMode === true) {
+        var lastDataIndex = innerDataIndices[len - 1];
+        var nameOrId = getSelectionKey(data, lastDataIndex);
+        option.selectedMap = (_a = {}, _a[nameOrId] = true, _a);
+        this._selectedDataIndicesMap = (_b = {}, _b[nameOrId] = data.getRawIndex(lastDataIndex), _b);
+      }
+    };
+    SeriesModel2.prototype._initSelectedMapFromData = function(data) {
+      if (this.option.selectedMap) {
+        return;
+      }
+      var dataIndices = [];
+      if (data.hasItemOption) {
+        data.each(function(idx) {
+          var rawItem = data.getRawDataItem(idx);
+          if (rawItem && rawItem.selected) {
+            dataIndices.push(idx);
+          }
+        });
+      }
+      if (dataIndices.length > 0) {
+        this._innerSelect(data, dataIndices);
+      }
+    };
+    SeriesModel2.registerClass = function(clz) {
+      return Component.default.registerClass(clz);
+    };
+    SeriesModel2.protoInitialize = function() {
+      var proto = SeriesModel2.prototype;
+      proto.type = "series.__base__";
+      proto.seriesIndex = 0;
+      proto.ignoreStyleOnData = false;
+      proto.hasSymbolVisual = false;
+      proto.defaultSymbol = "circle";
+      proto.visualStyleAccessPath = "itemStyle";
+      proto.visualDrawType = "fill";
+    }();
+    return SeriesModel2;
+  }(Component.default)
+);
+util.mixin(SeriesModel, dataFormat.DataFormatMixin);
+util.mixin(SeriesModel, palette.PaletteMixin);
+clazz.mountExtend(SeriesModel, Component.default);
+function autoSeriesName(seriesModel) {
+  var name = seriesModel.name;
+  if (!model.isNameSpecified(seriesModel)) {
+    seriesModel.name = getSeriesAutoName(seriesModel) || name;
+  }
+}
+function getSeriesAutoName(seriesModel) {
+  var data = seriesModel.getRawData();
+  var dataDims = data.mapDimensionsAll("seriesName");
+  var nameArr = [];
+  util.each(dataDims, function(dataDim) {
+    var dimInfo = data.getDimensionInfo(dataDim);
+    dimInfo.displayName && nameArr.push(dimInfo.displayName);
+  });
+  return nameArr.join(" ");
+}
+function dataTaskCount(context) {
+  return context.model.getRawData().count();
+}
+function dataTaskReset(context) {
+  var seriesModel = context.model;
+  seriesModel.setData(seriesModel.getRawData().cloneShallow());
+  return dataTaskProgress;
+}
+function dataTaskProgress(param, context) {
+  if (context.outputData && param.end > context.outputData.count()) {
+    context.model.getRawData().cloneShallow(context.outputData);
+  }
+}
+function wrapData(data, seriesModel) {
+  util.each(util.concatArray(data.CHANGABLE_METHODS, data.DOWNSAMPLE_METHODS), function(methodName) {
+    data.wrapMethod(methodName, util.curry(onDataChange, seriesModel));
+  });
+}
+function onDataChange(seriesModel, newList) {
+  var task2 = getCurrentTask(seriesModel);
+  if (task2) {
+    task2.setOutputEnd((newList || this).count());
+  }
+  return newList;
+}
+function getCurrentTask(seriesModel) {
+  var scheduler = (seriesModel.ecModel || {}).scheduler;
+  var pipeline = scheduler && scheduler.getPipeline(seriesModel.uid);
+  if (pipeline) {
+    var task2 = pipeline.currentTask;
+    if (task2) {
+      var agentStubMap = task2.agentStubMap;
+      if (agentStubMap) {
+        task2 = agentStubMap.get(seriesModel.uid);
+      }
+    }
+    return task2;
+  }
+}
+exports.SERIES_UNIVERSAL_TRANSITION_PROP = SERIES_UNIVERSAL_TRANSITION_PROP;
+exports.default = SeriesModel;

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var platform = "";
+if (typeof navigator !== "undefined") {
+  platform = navigator.platform || "";
+}
+var decalColor = "rgba(0, 0, 0, 0.2)";
+const globalDefault = {
+  darkMode: "auto",
+  // backgroundColor: 'rgba(0,0,0,0)',
+  colorBy: "series",
+  color: ["#5470c6", "#91cc75", "#fac858", "#ee6666", "#73c0de", "#3ba272", "#fc8452", "#9a60b4", "#ea7ccc"],
+  gradientColor: ["#f6efa6", "#d88273", "#bf444c"],
+  aria: {
+    decal: {
+      decals: [{
+        color: decalColor,
+        dashArrayX: [1, 0],
+        dashArrayY: [2, 5],
+        symbolSize: 1,
+        rotation: Math.PI / 6
+      }, {
+        color: decalColor,
+        symbol: "circle",
+        dashArrayX: [[8, 8], [0, 8, 8, 0]],
+        dashArrayY: [6, 0],
+        symbolSize: 0.8
+      }, {
+        color: decalColor,
+        dashArrayX: [1, 0],
+        dashArrayY: [4, 3],
+        rotation: -Math.PI / 4
+      }, {
+        color: decalColor,
+        dashArrayX: [[6, 6], [0, 6, 6, 0]],
+        dashArrayY: [6, 0]
+      }, {
+        color: decalColor,
+        dashArrayX: [[1, 0], [1, 6]],
+        dashArrayY: [1, 0, 6, 0],
+        rotation: Math.PI / 4
+      }, {
+        color: decalColor,
+        symbol: "triangle",
+        dashArrayX: [[9, 9], [0, 9, 9, 0]],
+        dashArrayY: [7, 2],
+        symbolSize: 0.75
+      }]
+    }
+  },
+  // If xAxis and yAxis declared, grid is created by default.
+  // grid: {},
+  textStyle: {
+    // color: '#000',
+    // decoration: 'none',
+    // PENDING
+    fontFamily: platform.match(/^Win/) ? "Microsoft YaHei" : "sans-serif",
+    // fontFamily: 'Arial, Verdana, sans-serif',
+    fontSize: 12,
+    fontStyle: "normal",
+    fontWeight: "normal"
+  },
+  // http://blogs.adobe.com/webplatform/2014/02/24/using-blend-modes-in-html-canvas/
+  // https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation
+  // Default is source-over
+  blendMode: null,
+  stateAnimation: {
+    duration: 300,
+    easing: "cubicOut"
+  },
+  animation: "auto",
+  animationDuration: 1e3,
+  animationDurationUpdate: 500,
+  animationEasing: "cubicInOut",
+  animationEasingUpdate: "cubicInOut",
+  animationThreshold: 2e3,
+  // Configuration for progressive/incremental rendering
+  progressiveThreshold: 3e3,
+  progressive: 400,
+  // Threshold of if use single hover layer to optimize.
+  // It is recommended that `hoverLayerThreshold` is equivalent to or less than
+  // `progressiveThreshold`, otherwise hover will cause restart of progressive,
+  // which is unexpected.
+  // see example <echarts/test/heatmap-large.html>.
+  hoverLayerThreshold: 3e3,
+  // See: module:echarts/scale/Time
+  useUTC: false
+};
+exports.default = globalDefault;

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.js");
+var internalOptionCreatorMap = util.createHashMap();
+function concatInternalOptions(ecModel, mainType, newCmptOptionList) {
+  var internalOptionCreator = internalOptionCreatorMap.get(mainType);
+  if (!internalOptionCreator) {
+    return newCmptOptionList;
+  }
+  var internalOptions = internalOptionCreator(ecModel);
+  if (!internalOptions) {
+    return newCmptOptionList;
+  }
+  return newCmptOptionList.concat(internalOptions);
+}
+exports.concatInternalOptions = concatInternalOptions;

package/lib/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/model/mixin/areaStyle.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const makeStyleMapper = require("./makeStyleMapper.js");
+var AREA_STYLE_KEY_MAP = [
+  ["fill", "color"],
+  ["shadowBlur"],
+  ["shadowOffsetX"],
+  ["shadowOffsetY"],
+  ["opacity"],
+  ["shadowColor"]
+  // Option decal is in `DecalObject` but style.decal is in `PatternObject`.
+  // So do not transfer decal directly.
+];
+var getAreaStyle = makeStyleMapper.default(AREA_STYLE_KEY_MAP);
+var AreaStyleMixin = (
+  /** @class */
+  function() {
+    function AreaStyleMixin2() {
+    }
+    AreaStyleMixin2.prototype.getAreaStyle = function(excludes, includes) {
+      return getAreaStyle(this, excludes, includes);
+    };
+    return AreaStyleMixin2;
+  }()
+);
+exports.AREA_STYLE_KEY_MAP = AREA_STYLE_KEY_MAP;
+exports.AreaStyleMixin = AreaStyleMixin;