@fecp/mobile 1.0.79 → 1.1.0

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/model/Component.mjs

@@ -0,0 +1,118 @@
+import { __extends } from "../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import { merge, each, map, indexOf } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import Model from "./Model.mjs";
+import { getUID, enableSubTypeDefaulter, enableTopologicalTravel } from "../util/component.mjs";
+import { isExtendedClass, mountExtend, enableClassManagement, parseClassType } from "../util/clazz.mjs";
+import { makeInner, queryReferringComponents } from "../util/model.mjs";
+import { fetchLayoutMode, getLayoutParams, mergeLayoutParam } from "../util/layout.mjs";
+var inner = makeInner();
+var ComponentModel = (
+  /** @class */
+  function(_super) {
+    __extends(ComponentModel2, _super);
+    function ComponentModel2(option, parentModel, ecModel) {
+      var _this = _super.call(this, option, parentModel, ecModel) || this;
+      _this.uid = getUID("ec_cpt_model");
+      return _this;
+    }
+    ComponentModel2.prototype.init = function(option, parentModel, ecModel) {
+      this.mergeDefaultAndTheme(option, ecModel);
+    };
+    ComponentModel2.prototype.mergeDefaultAndTheme = function(option, ecModel) {
+      var layoutMode = fetchLayoutMode(this);
+      var inputPositionParams = layoutMode ? getLayoutParams(option) : {};
+      var themeModel = ecModel.getTheme();
+      merge(option, themeModel.get(this.mainType));
+      merge(option, this.getDefaultOption());
+      if (layoutMode) {
+        mergeLayoutParam(option, inputPositionParams, layoutMode);
+      }
+    };
+    ComponentModel2.prototype.mergeOption = function(option, ecModel) {
+      merge(this.option, option, true);
+      var layoutMode = fetchLayoutMode(this);
+      if (layoutMode) {
+        mergeLayoutParam(this.option, option, layoutMode);
+      }
+    };
+    ComponentModel2.prototype.optionUpdated = function(newCptOption, isInit) {
+    };
+    ComponentModel2.prototype.getDefaultOption = function() {
+      var ctor = this.constructor;
+      if (!isExtendedClass(ctor)) {
+        return ctor.defaultOption;
+      }
+      var fields = inner(this);
+      if (!fields.defaultOption) {
+        var optList = [];
+        var clz = ctor;
+        while (clz) {
+          var opt = clz.prototype.defaultOption;
+          opt && optList.push(opt);
+          clz = clz.superClass;
+        }
+        var defaultOption = {};
+        for (var i = optList.length - 1; i >= 0; i--) {
+          defaultOption = merge(defaultOption, optList[i], true);
+        }
+        fields.defaultOption = defaultOption;
+      }
+      return fields.defaultOption;
+    };
+    ComponentModel2.prototype.getReferringComponents = function(mainType, opt) {
+      var indexKey = mainType + "Index";
+      var idKey = mainType + "Id";
+      return queryReferringComponents(this.ecModel, mainType, {
+        index: this.get(indexKey, true),
+        id: this.get(idKey, true)
+      }, opt);
+    };
+    ComponentModel2.prototype.getBoxLayoutParams = function() {
+      var boxLayoutModel = this;
+      return {
+        left: boxLayoutModel.get("left"),
+        top: boxLayoutModel.get("top"),
+        right: boxLayoutModel.get("right"),
+        bottom: boxLayoutModel.get("bottom"),
+        width: boxLayoutModel.get("width"),
+        height: boxLayoutModel.get("height")
+      };
+    };
+    ComponentModel2.prototype.getZLevelKey = function() {
+      return "";
+    };
+    ComponentModel2.prototype.setZLevel = function(zlevel) {
+      this.option.zlevel = zlevel;
+    };
+    ComponentModel2.protoInitialize = function() {
+      var proto = ComponentModel2.prototype;
+      proto.type = "component";
+      proto.id = "";
+      proto.name = "";
+      proto.mainType = "";
+      proto.subType = "";
+      proto.componentIndex = 0;
+    }();
+    return ComponentModel2;
+  }(Model)
+);
+mountExtend(ComponentModel, Model);
+enableClassManagement(ComponentModel);
+enableSubTypeDefaulter(ComponentModel);
+enableTopologicalTravel(ComponentModel, getDependencies);
+function getDependencies(componentType) {
+  var deps = [];
+  each(ComponentModel.getClassesByMainType(componentType), function(clz) {
+    deps = deps.concat(clz.dependencies || clz.prototype.dependencies || []);
+  });
+  deps = map(deps, function(type) {
+    return parseClassType(type).main;
+  });
+  if (componentType !== "dataset" && indexOf(deps, "dataset") <= 0) {
+    deps.unshift("dataset");
+  }
+  return deps;
+}
+export {
+  ComponentModel as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/model/Global.mjs

@@ -0,0 +1,471 @@
+import { __extends } from "../../../../../tslib@2.3.0/node_modules/tslib/tslib.es6.mjs";
+import { each, createHashMap, clone, merge, extend, filter, isFunction, isString, isObject, isArray, mixin } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+import { normalizeToArray, mappingToExists, setComponentTypeToKeyInfo, isComponentIdInternal, convertOptionIdName } from "../util/model.mjs";
+import Model from "./Model.mjs";
+import ComponentModel from "./Component.mjs";
+import globalDefault from "./globalDefault.mjs";
+import { resetSourceDefaulter } from "../data/helper/sourceHelper.mjs";
+import { concatInternalOptions } from "./internalComponentCreator.mjs";
+import { PaletteMixin } from "./mixin/palette.mjs";
+var reCreateSeriesIndices;
+var assertSeriesInitialized;
+var initBase;
+var OPTION_INNER_KEY = "\0_ec_inner";
+var OPTION_INNER_VALUE = 1;
+var GlobalModel = (
+  /** @class */
+  function(_super) {
+    __extends(GlobalModel2, _super);
+    function GlobalModel2() {
+      return _super !== null && _super.apply(this, arguments) || this;
+    }
+    GlobalModel2.prototype.init = function(option, parentModel, ecModel, theme, locale, optionManager) {
+      theme = theme || {};
+      this.option = null;
+      this._theme = new Model(theme);
+      this._locale = new Model(locale);
+      this._optionManager = optionManager;
+    };
+    GlobalModel2.prototype.setOption = function(option, opts, optionPreprocessorFuncs) {
+      var innerOpt = normalizeSetOptionInput(opts);
+      this._optionManager.setOption(option, optionPreprocessorFuncs, innerOpt);
+      this._resetOption(null, innerOpt);
+    };
+    GlobalModel2.prototype.resetOption = function(type, opt) {
+      return this._resetOption(type, normalizeSetOptionInput(opt));
+    };
+    GlobalModel2.prototype._resetOption = function(type, opt) {
+      var optionChanged = false;
+      var optionManager = this._optionManager;
+      if (!type || type === "recreate") {
+        var baseOption = optionManager.mountOption(type === "recreate");
+        if (!this.option || type === "recreate") {
+          initBase(this, baseOption);
+        } else {
+          this.restoreData();
+          this._mergeOption(baseOption, opt);
+        }
+        optionChanged = true;
+      }
+      if (type === "timeline" || type === "media") {
+        this.restoreData();
+      }
+      if (!type || type === "recreate" || type === "timeline") {
+        var timelineOption = optionManager.getTimelineOption(this);
+        if (timelineOption) {
+          optionChanged = true;
+          this._mergeOption(timelineOption, opt);
+        }
+      }
+      if (!type || type === "recreate" || type === "media") {
+        var mediaOptions = optionManager.getMediaOption(this);
+        if (mediaOptions.length) {
+          each(mediaOptions, function(mediaOption) {
+            optionChanged = true;
+            this._mergeOption(mediaOption, opt);
+          }, this);
+        }
+      }
+      return optionChanged;
+    };
+    GlobalModel2.prototype.mergeOption = function(option) {
+      this._mergeOption(option, null);
+    };
+    GlobalModel2.prototype._mergeOption = function(newOption, opt) {
+      var option = this.option;
+      var componentsMap = this._componentsMap;
+      var componentsCount = this._componentsCount;
+      var newCmptTypes = [];
+      var newCmptTypeMap = createHashMap();
+      var replaceMergeMainTypeMap = opt && opt.replaceMergeMainTypeMap;
+      resetSourceDefaulter(this);
+      each(newOption, function(componentOption, mainType) {
+        if (componentOption == null) {
+          return;
+        }
+        if (!ComponentModel.hasClass(mainType)) {
+          option[mainType] = option[mainType] == null ? clone(componentOption) : merge(option[mainType], componentOption, true);
+        } else if (mainType) {
+          newCmptTypes.push(mainType);
+          newCmptTypeMap.set(mainType, true);
+        }
+      });
+      if (replaceMergeMainTypeMap) {
+        replaceMergeMainTypeMap.each(function(val, mainTypeInReplaceMerge) {
+          if (ComponentModel.hasClass(mainTypeInReplaceMerge) && !newCmptTypeMap.get(mainTypeInReplaceMerge)) {
+            newCmptTypes.push(mainTypeInReplaceMerge);
+            newCmptTypeMap.set(mainTypeInReplaceMerge, true);
+          }
+        });
+      }
+      ComponentModel.topologicalTravel(newCmptTypes, ComponentModel.getAllClassMainTypes(), visitComponent, this);
+      function visitComponent(mainType) {
+        var newCmptOptionList = concatInternalOptions(this, mainType, normalizeToArray(newOption[mainType]));
+        var oldCmptList = componentsMap.get(mainType);
+        var mergeMode = (
+          // `!oldCmptList` means init. See the comment in `mappingToExists`
+          !oldCmptList ? "replaceAll" : replaceMergeMainTypeMap && replaceMergeMainTypeMap.get(mainType) ? "replaceMerge" : "normalMerge"
+        );
+        var mappingResult = mappingToExists(oldCmptList, newCmptOptionList, mergeMode);
+        setComponentTypeToKeyInfo(mappingResult, mainType, ComponentModel);
+        option[mainType] = null;
+        componentsMap.set(mainType, null);
+        componentsCount.set(mainType, 0);
+        var optionsByMainType = [];
+        var cmptsByMainType = [];
+        var cmptsCountByMainType = 0;
+        var tooltipExists;
+        each(mappingResult, function(resultItem, index) {
+          var componentModel = resultItem.existing;
+          var newCmptOption = resultItem.newOption;
+          if (!newCmptOption) {
+            if (componentModel) {
+              componentModel.mergeOption({}, this);
+              componentModel.optionUpdated({}, false);
+            }
+          } else {
+            var isSeriesType = mainType === "series";
+            var ComponentModelClass = ComponentModel.getClass(
+              mainType,
+              resultItem.keyInfo.subType,
+              !isSeriesType
+              // Give a more detailed warn later if series don't exists
+            );
+            if (!ComponentModelClass) {
+              return;
+            }
+            if (mainType === "tooltip") {
+              if (tooltipExists) {
+                return;
+              }
+              tooltipExists = true;
+            }
+            if (componentModel && componentModel.constructor === ComponentModelClass) {
+              componentModel.name = resultItem.keyInfo.name;
+              componentModel.mergeOption(newCmptOption, this);
+              componentModel.optionUpdated(newCmptOption, false);
+            } else {
+              var extraOpt = extend({
+                componentIndex: index
+              }, resultItem.keyInfo);
+              componentModel = new ComponentModelClass(newCmptOption, this, this, extraOpt);
+              extend(componentModel, extraOpt);
+              if (resultItem.brandNew) {
+                componentModel.__requireNewView = true;
+              }
+              componentModel.init(newCmptOption, this, this);
+              componentModel.optionUpdated(null, true);
+            }
+          }
+          if (componentModel) {
+            optionsByMainType.push(componentModel.option);
+            cmptsByMainType.push(componentModel);
+            cmptsCountByMainType++;
+          } else {
+            optionsByMainType.push(void 0);
+            cmptsByMainType.push(void 0);
+          }
+        }, this);
+        option[mainType] = optionsByMainType;
+        componentsMap.set(mainType, cmptsByMainType);
+        componentsCount.set(mainType, cmptsCountByMainType);
+        if (mainType === "series") {
+          reCreateSeriesIndices(this);
+        }
+      }
+      if (!this._seriesIndices) {
+        reCreateSeriesIndices(this);
+      }
+    };
+    GlobalModel2.prototype.getOption = function() {
+      var option = clone(this.option);
+      each(option, function(optInMainType, mainType) {
+        if (ComponentModel.hasClass(mainType)) {
+          var opts = normalizeToArray(optInMainType);
+          var realLen = opts.length;
+          var metNonInner = false;
+          for (var i = realLen - 1; i >= 0; i--) {
+            if (opts[i] && !isComponentIdInternal(opts[i])) {
+              metNonInner = true;
+            } else {
+              opts[i] = null;
+              !metNonInner && realLen--;
+            }
+          }
+          opts.length = realLen;
+          option[mainType] = opts;
+        }
+      });
+      delete option[OPTION_INNER_KEY];
+      return option;
+    };
+    GlobalModel2.prototype.getTheme = function() {
+      return this._theme;
+    };
+    GlobalModel2.prototype.getLocaleModel = function() {
+      return this._locale;
+    };
+    GlobalModel2.prototype.setUpdatePayload = function(payload) {
+      this._payload = payload;
+    };
+    GlobalModel2.prototype.getUpdatePayload = function() {
+      return this._payload;
+    };
+    GlobalModel2.prototype.getComponent = function(mainType, idx) {
+      var list = this._componentsMap.get(mainType);
+      if (list) {
+        var cmpt = list[idx || 0];
+        if (cmpt) {
+          return cmpt;
+        } else if (idx == null) {
+          for (var i = 0; i < list.length; i++) {
+            if (list[i]) {
+              return list[i];
+            }
+          }
+        }
+      }
+    };
+    GlobalModel2.prototype.queryComponents = function(condition) {
+      var mainType = condition.mainType;
+      if (!mainType) {
+        return [];
+      }
+      var index = condition.index;
+      var id = condition.id;
+      var name = condition.name;
+      var cmpts = this._componentsMap.get(mainType);
+      if (!cmpts || !cmpts.length) {
+        return [];
+      }
+      var result;
+      if (index != null) {
+        result = [];
+        each(normalizeToArray(index), function(idx) {
+          cmpts[idx] && result.push(cmpts[idx]);
+        });
+      } else if (id != null) {
+        result = queryByIdOrName("id", id, cmpts);
+      } else if (name != null) {
+        result = queryByIdOrName("name", name, cmpts);
+      } else {
+        result = filter(cmpts, function(cmpt) {
+          return !!cmpt;
+        });
+      }
+      return filterBySubType(result, condition);
+    };
+    GlobalModel2.prototype.findComponents = function(condition) {
+      var query = condition.query;
+      var mainType = condition.mainType;
+      var queryCond = getQueryCond(query);
+      var result = queryCond ? this.queryComponents(queryCond) : filter(this._componentsMap.get(mainType), function(cmpt) {
+        return !!cmpt;
+      });
+      return doFilter(filterBySubType(result, condition));
+      function getQueryCond(q) {
+        var indexAttr = mainType + "Index";
+        var idAttr = mainType + "Id";
+        var nameAttr = mainType + "Name";
+        return q && (q[indexAttr] != null || q[idAttr] != null || q[nameAttr] != null) ? {
+          mainType,
+          // subType will be filtered finally.
+          index: q[indexAttr],
+          id: q[idAttr],
+          name: q[nameAttr]
+        } : null;
+      }
+      function doFilter(res) {
+        return condition.filter ? filter(res, condition.filter) : res;
+      }
+    };
+    GlobalModel2.prototype.eachComponent = function(mainType, cb, context) {
+      var componentsMap = this._componentsMap;
+      if (isFunction(mainType)) {
+        var ctxForAll_1 = cb;
+        var cbForAll_1 = mainType;
+        componentsMap.each(function(cmpts2, componentType) {
+          for (var i2 = 0; cmpts2 && i2 < cmpts2.length; i2++) {
+            var cmpt2 = cmpts2[i2];
+            cmpt2 && cbForAll_1.call(ctxForAll_1, componentType, cmpt2, cmpt2.componentIndex);
+          }
+        });
+      } else {
+        var cmpts = isString(mainType) ? componentsMap.get(mainType) : isObject(mainType) ? this.findComponents(mainType) : null;
+        for (var i = 0; cmpts && i < cmpts.length; i++) {
+          var cmpt = cmpts[i];
+          cmpt && cb.call(context, cmpt, cmpt.componentIndex);
+        }
+      }
+    };
+    GlobalModel2.prototype.getSeriesByName = function(name) {
+      var nameStr = convertOptionIdName(name, null);
+      return filter(this._componentsMap.get("series"), function(oneSeries) {
+        return !!oneSeries && nameStr != null && oneSeries.name === nameStr;
+      });
+    };
+    GlobalModel2.prototype.getSeriesByIndex = function(seriesIndex) {
+      return this._componentsMap.get("series")[seriesIndex];
+    };
+    GlobalModel2.prototype.getSeriesByType = function(subType) {
+      return filter(this._componentsMap.get("series"), function(oneSeries) {
+        return !!oneSeries && oneSeries.subType === subType;
+      });
+    };
+    GlobalModel2.prototype.getSeries = function() {
+      return filter(this._componentsMap.get("series"), function(oneSeries) {
+        return !!oneSeries;
+      });
+    };
+    GlobalModel2.prototype.getSeriesCount = function() {
+      return this._componentsCount.get("series");
+    };
+    GlobalModel2.prototype.eachSeries = function(cb, context) {
+      assertSeriesInitialized(this);
+      each(this._seriesIndices, function(rawSeriesIndex) {
+        var series = this._componentsMap.get("series")[rawSeriesIndex];
+        cb.call(context, series, rawSeriesIndex);
+      }, this);
+    };
+    GlobalModel2.prototype.eachRawSeries = function(cb, context) {
+      each(this._componentsMap.get("series"), function(series) {
+        series && cb.call(context, series, series.componentIndex);
+      });
+    };
+    GlobalModel2.prototype.eachSeriesByType = function(subType, cb, context) {
+      assertSeriesInitialized(this);
+      each(this._seriesIndices, function(rawSeriesIndex) {
+        var series = this._componentsMap.get("series")[rawSeriesIndex];
+        if (series.subType === subType) {
+          cb.call(context, series, rawSeriesIndex);
+        }
+      }, this);
+    };
+    GlobalModel2.prototype.eachRawSeriesByType = function(subType, cb, context) {
+      return each(this.getSeriesByType(subType), cb, context);
+    };
+    GlobalModel2.prototype.isSeriesFiltered = function(seriesModel) {
+      assertSeriesInitialized(this);
+      return this._seriesIndicesMap.get(seriesModel.componentIndex) == null;
+    };
+    GlobalModel2.prototype.getCurrentSeriesIndices = function() {
+      return (this._seriesIndices || []).slice();
+    };
+    GlobalModel2.prototype.filterSeries = function(cb, context) {
+      assertSeriesInitialized(this);
+      var newSeriesIndices = [];
+      each(this._seriesIndices, function(seriesRawIdx) {
+        var series = this._componentsMap.get("series")[seriesRawIdx];
+        cb.call(context, series, seriesRawIdx) && newSeriesIndices.push(seriesRawIdx);
+      }, this);
+      this._seriesIndices = newSeriesIndices;
+      this._seriesIndicesMap = createHashMap(newSeriesIndices);
+    };
+    GlobalModel2.prototype.restoreData = function(payload) {
+      reCreateSeriesIndices(this);
+      var componentsMap = this._componentsMap;
+      var componentTypes = [];
+      componentsMap.each(function(components, componentType) {
+        if (ComponentModel.hasClass(componentType)) {
+          componentTypes.push(componentType);
+        }
+      });
+      ComponentModel.topologicalTravel(componentTypes, ComponentModel.getAllClassMainTypes(), function(componentType) {
+        each(componentsMap.get(componentType), function(component) {
+          if (component && (componentType !== "series" || !isNotTargetSeries(component, payload))) {
+            component.restoreData();
+          }
+        });
+      });
+    };
+    GlobalModel2.internalField = function() {
+      reCreateSeriesIndices = function(ecModel) {
+        var seriesIndices = ecModel._seriesIndices = [];
+        each(ecModel._componentsMap.get("series"), function(series) {
+          series && seriesIndices.push(series.componentIndex);
+        });
+        ecModel._seriesIndicesMap = createHashMap(seriesIndices);
+      };
+      assertSeriesInitialized = function(ecModel) {
+      };
+      initBase = function(ecModel, baseOption) {
+        ecModel.option = {};
+        ecModel.option[OPTION_INNER_KEY] = OPTION_INNER_VALUE;
+        ecModel._componentsMap = createHashMap({
+          series: []
+        });
+        ecModel._componentsCount = createHashMap();
+        var airaOption = baseOption.aria;
+        if (isObject(airaOption) && airaOption.enabled == null) {
+          airaOption.enabled = true;
+        }
+        mergeTheme(baseOption, ecModel._theme.option);
+        merge(baseOption, globalDefault, false);
+        ecModel._mergeOption(baseOption, null);
+      };
+    }();
+    return GlobalModel2;
+  }(Model)
+);
+function isNotTargetSeries(seriesModel, payload) {
+  if (payload) {
+    var index = payload.seriesIndex;
+    var id = payload.seriesId;
+    var name_1 = payload.seriesName;
+    return index != null && seriesModel.componentIndex !== index || id != null && seriesModel.id !== id || name_1 != null && seriesModel.name !== name_1;
+  }
+}
+function mergeTheme(option, theme) {
+  var notMergeColorLayer = option.color && !option.colorLayer;
+  each(theme, function(themeItem, name) {
+    if (name === "colorLayer" && notMergeColorLayer) {
+      return;
+    }
+    if (!ComponentModel.hasClass(name)) {
+      if (typeof themeItem === "object") {
+        option[name] = !option[name] ? clone(themeItem) : merge(option[name], themeItem, false);
+      } else {
+        if (option[name] == null) {
+          option[name] = themeItem;
+        }
+      }
+    }
+  });
+}
+function queryByIdOrName(attr, idOrName, cmpts) {
+  if (isArray(idOrName)) {
+    var keyMap_1 = createHashMap();
+    each(idOrName, function(idOrNameItem) {
+      if (idOrNameItem != null) {
+        var idName = convertOptionIdName(idOrNameItem, null);
+        idName != null && keyMap_1.set(idOrNameItem, true);
+      }
+    });
+    return filter(cmpts, function(cmpt) {
+      return cmpt && keyMap_1.get(cmpt[attr]);
+    });
+  } else {
+    var idName_1 = convertOptionIdName(idOrName, null);
+    return filter(cmpts, function(cmpt) {
+      return cmpt && idName_1 != null && cmpt[attr] === idName_1;
+    });
+  }
+}
+function filterBySubType(components, condition) {
+  return condition.hasOwnProperty("subType") ? filter(components, function(cmpt) {
+    return cmpt && cmpt.subType === condition.subType;
+  }) : components;
+}
+function normalizeSetOptionInput(opts) {
+  var replaceMergeMainTypeMap = createHashMap();
+  opts && each(normalizeToArray(opts.replaceMerge), function(mainType) {
+    replaceMergeMainTypeMap.set(mainType, true);
+  });
+  return {
+    replaceMergeMainTypeMap
+  };
+}
+mixin(GlobalModel, PaletteMixin);
+export {
+  GlobalModel as default
+};

package/es/node_modules/.pnpm/echarts@5.6.0/node_modules/echarts/lib/model/Model.mjs

@@ -0,0 +1,102 @@
+import env from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/env.mjs";
+import { enableClassExtend, enableClassCheck } from "../util/clazz.mjs";
+import { AreaStyleMixin } from "./mixin/areaStyle.mjs";
+import TextStyleMixin from "./mixin/textStyle.mjs";
+import { LineStyleMixin } from "./mixin/lineStyle.mjs";
+import { ItemStyleMixin } from "./mixin/itemStyle.mjs";
+import { merge, clone, mixin } from "../../../../../zrender@5.6.1/node_modules/zrender/lib/core/util.mjs";
+var Model = (
+  /** @class */
+  function() {
+    function Model2(option, parentModel, ecModel) {
+      this.parentModel = parentModel;
+      this.ecModel = ecModel;
+      this.option = option;
+    }
+    Model2.prototype.init = function(option, parentModel, ecModel) {
+    };
+    Model2.prototype.mergeOption = function(option, ecModel) {
+      merge(this.option, option, true);
+    };
+    Model2.prototype.get = function(path, ignoreParent) {
+      if (path == null) {
+        return this.option;
+      }
+      return this._doGet(this.parsePath(path), !ignoreParent && this.parentModel);
+    };
+    Model2.prototype.getShallow = function(key, ignoreParent) {
+      var option = this.option;
+      var val = option == null ? option : option[key];
+      if (val == null && !ignoreParent) {
+        var parentModel = this.parentModel;
+        if (parentModel) {
+          val = parentModel.getShallow(key);
+        }
+      }
+      return val;
+    };
+    Model2.prototype.getModel = function(path, parentModel) {
+      var hasPath = path != null;
+      var pathFinal = hasPath ? this.parsePath(path) : null;
+      var obj = hasPath ? this._doGet(pathFinal) : this.option;
+      parentModel = parentModel || this.parentModel && this.parentModel.getModel(this.resolveParentPath(pathFinal));
+      return new Model2(obj, parentModel, this.ecModel);
+    };
+    Model2.prototype.isEmpty = function() {
+      return this.option == null;
+    };
+    Model2.prototype.restoreData = function() {
+    };
+    Model2.prototype.clone = function() {
+      var Ctor = this.constructor;
+      return new Ctor(clone(this.option));
+    };
+    Model2.prototype.parsePath = function(path) {
+      if (typeof path === "string") {
+        return path.split(".");
+      }
+      return path;
+    };
+    Model2.prototype.resolveParentPath = function(path) {
+      return path;
+    };
+    Model2.prototype.isAnimationEnabled = function() {
+      if (!env.node && this.option) {
+        if (this.option.animation != null) {
+          return !!this.option.animation;
+        } else if (this.parentModel) {
+          return this.parentModel.isAnimationEnabled();
+        }
+      }
+    };
+    Model2.prototype._doGet = function(pathArr, parentModel) {
+      var obj = this.option;
+      if (!pathArr) {
+        return obj;
+      }
+      for (var i = 0; i < pathArr.length; i++) {
+        if (!pathArr[i]) {
+          continue;
+        }
+        obj = obj && typeof obj === "object" ? obj[pathArr[i]] : null;
+        if (obj == null) {
+          break;
+        }
+      }
+      if (obj == null && parentModel) {
+        obj = parentModel._doGet(this.resolveParentPath(pathArr), parentModel.parentModel);
+      }
+      return obj;
+    };
+    return Model2;
+  }()
+);
+enableClassExtend(Model);
+enableClassCheck(Model);
+mixin(Model, LineStyleMixin);
+mixin(Model, ItemStyleMixin);
+mixin(Model, AreaStyleMixin);
+mixin(Model, TextStyleMixin);
+export {
+  Model as default
+};