@fecp/designer 5.6.28 → 5.6.30

package/lib/node_modules/cytoscape-cose-bilkent/cytoscape-cose-bilkent.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const cytoscapeCoseBilkent$1 = require("../../_virtual/cytoscape-cose-bilkent2.js");
-const coseBase = require("./node_modules/cose-base/cose-base.js");
+const coseBase = require("../cose-base/cose-base.js");
 var cytoscapeCoseBilkent = cytoscapeCoseBilkent$1.__module.exports;
 var hasRequiredCytoscapeCoseBilkent;
 function requireCytoscapeCoseBilkent() {

package/lib/node_modules/d3-sankey/src/sankeyLinkHorizontal.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const index = require("../node_modules/d3-shape/src/link/index.js");
+const index = require("../../d3-shape/src/link/index.js");
 function horizontalSource(d) {
   return [d.source.x1, d.y0];
 }

package/lib/node_modules/echarts/core.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const parseGeoJson = require("./lib/coord/geo/parseGeoJson.js");
+const env = require("../zrender/lib/core/env.js");
+const Model = require("./lib/model/Model.js");
+const Axis = require("./lib/coord/Axis.js");
+const SeriesData = require("./lib/data/SeriesData.js");
+const Component = require("./lib/model/Component.js");
+const Component$1 = require("./lib/view/Component.js");
+const Series = require("./lib/model/Series.js");
+const Chart = require("./lib/view/Chart.js");
+const locale = require("./lib/core/locale.js");
+const echarts = require("./lib/core/echarts.js");
+const throttle = require("./lib/util/throttle.js");
+const extension = require("./lib/extension.js");
+const platform = require("../zrender/lib/core/platform.js");
+const graphic$1 = require("../zrender/lib/canvas/graphic.js");
+const zrender = require("../zrender/lib/zrender.js");
+const matrix = require("../zrender/lib/core/matrix.js");
+const vector = require("../zrender/lib/core/vector.js");
+const util = require("../zrender/lib/core/util.js");
+const color = require("../zrender/lib/tool/color.js");
+const helper = require("./lib/export/api/helper.js");
+const number = require("./lib/export/api/number.js");
+const time = require("./lib/export/api/time.js");
+const graphic = require("./lib/export/api/graphic.js");
+const format = require("./lib/export/api/format.js");
+const util$1 = require("./lib/export/api/util.js");
+const api = require("./lib/export/api.js");
+exports.parseGeoJSON = parseGeoJson.default;
+exports.parseGeoJson = parseGeoJson.default;
+exports.env = env.default;
+exports.Model = Model.default;
+exports.Axis = Axis.default;
+exports.List = SeriesData.default;
+exports.ComponentModel = Component.default;
+exports.ComponentView = Component$1.default;
+exports.SeriesModel = Series.default;
+exports.ChartView = Chart.default;
+exports.registerLocale = locale.registerLocale;
+exports.PRIORITY = echarts.PRIORITY;
+exports.connect = echarts.connect;
+exports.dataTool = echarts.dataTool;
+exports.dependencies = echarts.dependencies;
+exports.disConnect = echarts.disConnect;
+exports.disconnect = echarts.disconnect;
+exports.dispose = echarts.dispose;
+exports.getCoordinateSystemDimensions = echarts.getCoordinateSystemDimensions;
+exports.getInstanceByDom = echarts.getInstanceByDom;
+exports.getInstanceById = echarts.getInstanceById;
+exports.getMap = echarts.getMap;
+exports.init = echarts.init;
+exports.registerAction = echarts.registerAction;
+exports.registerCoordinateSystem = echarts.registerCoordinateSystem;
+exports.registerLayout = echarts.registerLayout;
+exports.registerLoading = echarts.registerLoading;
+exports.registerMap = echarts.registerMap;
+exports.registerPostInit = echarts.registerPostInit;
+exports.registerPostUpdate = echarts.registerPostUpdate;
+exports.registerPreprocessor = echarts.registerPreprocessor;
+exports.registerProcessor = echarts.registerProcessor;
+exports.registerTheme = echarts.registerTheme;
+exports.registerTransform = echarts.registerTransform;
+exports.registerUpdateLifecycle = echarts.registerUpdateLifecycle;
+exports.registerVisual = echarts.registerVisual;
+exports.setCanvasCreator = echarts.setCanvasCreator;
+exports.version = echarts.version;
+exports.throttle = throttle.throttle;
+exports.use = extension.use;
+exports.setPlatformAPI = platform.setPlatformAPI;
+exports.innerDrawElementOnCanvas = graphic$1.brushSingle;
+exports.zrender = zrender;
+exports.matrix = matrix;
+exports.vector = vector;
+exports.zrUtil = util;
+exports.color = color;
+exports.helper = helper;
+exports.number = number;
+exports.time = time;
+exports.graphic = graphic;
+exports.format = format;
+exports.util = util$1;
+exports.extendChartView = api.extendChartView;
+exports.extendComponentModel = api.extendComponentModel;
+exports.extendComponentView = api.extendComponentView;
+exports.extendSeriesModel = api.extendSeriesModel;

package/lib/node_modules/echarts/lib/animation/basicTransition.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../zrender/lib/core/util.js");
+const model = require("../util/model.js");
+var transitionStore = model.makeInner();
+function getAnimationConfig(animationType, animatableModel, dataIndex, extraOpts, extraDelayParams) {
+  var animationPayload;
+  if (animatableModel && animatableModel.ecModel) {
+    var updatePayload = animatableModel.ecModel.getUpdatePayload();
+    animationPayload = updatePayload && updatePayload.animation;
+  }
+  var animationEnabled = animatableModel && animatableModel.isAnimationEnabled();
+  var isUpdate = animationType === "update";
+  if (animationEnabled) {
+    var duration = void 0;
+    var easing = void 0;
+    var delay = void 0;
+    if (extraOpts) {
+      duration = util.retrieve2(extraOpts.duration, 200);
+      easing = util.retrieve2(extraOpts.easing, "cubicOut");
+      delay = 0;
+    } else {
+      duration = animatableModel.getShallow(isUpdate ? "animationDurationUpdate" : "animationDuration");
+      easing = animatableModel.getShallow(isUpdate ? "animationEasingUpdate" : "animationEasing");
+      delay = animatableModel.getShallow(isUpdate ? "animationDelayUpdate" : "animationDelay");
+    }
+    if (animationPayload) {
+      animationPayload.duration != null && (duration = animationPayload.duration);
+      animationPayload.easing != null && (easing = animationPayload.easing);
+      animationPayload.delay != null && (delay = animationPayload.delay);
+    }
+    if (util.isFunction(delay)) {
+      delay = delay(dataIndex, extraDelayParams);
+    }
+    if (util.isFunction(duration)) {
+      duration = duration(dataIndex);
+    }
+    var config = {
+      duration: duration || 0,
+      delay,
+      easing
+    };
+    return config;
+  } else {
+    return null;
+  }
+}
+function animateOrSetProps(animationType, el, props, animatableModel, dataIndex, cb, during) {
+  var isFrom = false;
+  var removeOpt;
+  if (util.isFunction(dataIndex)) {
+    during = cb;
+    cb = dataIndex;
+    dataIndex = null;
+  } else if (util.isObject(dataIndex)) {
+    cb = dataIndex.cb;
+    during = dataIndex.during;
+    isFrom = dataIndex.isFrom;
+    removeOpt = dataIndex.removeOpt;
+    dataIndex = dataIndex.dataIndex;
+  }
+  var isRemove = animationType === "leave";
+  if (!isRemove) {
+    el.stopAnimation("leave");
+  }
+  var animationConfig = getAnimationConfig(animationType, animatableModel, dataIndex, isRemove ? removeOpt || {} : null, animatableModel && animatableModel.getAnimationDelayParams ? animatableModel.getAnimationDelayParams(el, dataIndex) : null);
+  if (animationConfig && animationConfig.duration > 0) {
+    var duration = animationConfig.duration;
+    var animationDelay = animationConfig.delay;
+    var animationEasing = animationConfig.easing;
+    var animateConfig = {
+      duration,
+      delay: animationDelay || 0,
+      easing: animationEasing,
+      done: cb,
+      force: !!cb || !!during,
+      // Set to final state in update/init animation.
+      // So the post processing based on the path shape can be done correctly.
+      setToFinal: !isRemove,
+      scope: animationType,
+      during
+    };
+    isFrom ? el.animateFrom(props, animateConfig) : el.animateTo(props, animateConfig);
+  } else {
+    el.stopAnimation();
+    !isFrom && el.attr(props);
+    during && during(1);
+    cb && cb();
+  }
+}
+function updateProps(el, props, animatableModel, dataIndex, cb, during) {
+  animateOrSetProps("update", el, props, animatableModel, dataIndex, cb, during);
+}
+function initProps(el, props, animatableModel, dataIndex, cb, during) {
+  animateOrSetProps("enter", el, props, animatableModel, dataIndex, cb, during);
+}
+function isElementRemoved(el) {
+  if (!el.__zr) {
+    return true;
+  }
+  for (var i = 0; i < el.animators.length; i++) {
+    var animator = el.animators[i];
+    if (animator.scope === "leave") {
+      return true;
+    }
+  }
+  return false;
+}
+function removeElement(el, props, animatableModel, dataIndex, cb, during) {
+  if (isElementRemoved(el)) {
+    return;
+  }
+  animateOrSetProps("leave", el, props, animatableModel, dataIndex, cb, during);
+}
+function fadeOutDisplayable(el, animatableModel, dataIndex, done) {
+  el.removeTextContent();
+  el.removeTextGuideLine();
+  removeElement(el, {
+    style: {
+      opacity: 0
+    }
+  }, animatableModel, dataIndex, done);
+}
+function removeElementWithFadeOut(el, animatableModel, dataIndex) {
+  function doRemove() {
+    el.parent && el.parent.remove(el);
+  }
+  if (!el.isGroup) {
+    fadeOutDisplayable(el, animatableModel, dataIndex, doRemove);
+  } else {
+    el.traverse(function(disp) {
+      if (!disp.isGroup) {
+        fadeOutDisplayable(disp, animatableModel, dataIndex, doRemove);
+      }
+    });
+  }
+}
+function saveOldStyle(el) {
+  transitionStore(el).oldStyle = el.style;
+}
+exports.getAnimationConfig = getAnimationConfig;
+exports.initProps = initProps;
+exports.isElementRemoved = isElementRemoved;
+exports.removeElement = removeElement;
+exports.removeElementWithFadeOut = removeElementWithFadeOut;
+exports.saveOldStyle = saveOldStyle;
+exports.transitionStore = transitionStore;
+exports.updateProps = updateProps;

package/lib/node_modules/echarts/lib/animation/customGraphicKeyframeAnimation.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../../../zrender/lib/core/util.js");
+const customGraphicTransition = require("./customGraphicTransition.js");
+const basicTransition = require("./basicTransition.js");
+const model = require("../util/model.js");
+var getStateToRestore = model.makeInner();
+var KEYFRAME_EXCLUDE_KEYS = ["percent", "easing", "shape", "style", "extra"];
+function stopPreviousKeyframeAnimationAndRestore(el) {
+  el.stopAnimation("keyframe");
+  el.attr(getStateToRestore(el));
+}
+function applyKeyframeAnimation(el, animationOpts, animatableModel) {
+  if (!animatableModel.isAnimationEnabled() || !animationOpts) {
+    return;
+  }
+  if (util.isArray(animationOpts)) {
+    util.each(animationOpts, function(singleAnimationOpts) {
+      applyKeyframeAnimation(el, singleAnimationOpts, animatableModel);
+    });
+    return;
+  }
+  var keyframes = animationOpts.keyframes;
+  var duration = animationOpts.duration;
+  if (animatableModel && duration == null) {
+    var config = basicTransition.getAnimationConfig("enter", animatableModel, 0);
+    duration = config && config.duration;
+  }
+  if (!keyframes || !duration) {
+    return;
+  }
+  var stateToRestore = getStateToRestore(el);
+  util.each(customGraphicTransition.ELEMENT_ANIMATABLE_PROPS, function(targetPropName) {
+    if (targetPropName && !el[targetPropName]) {
+      return;
+    }
+    var animator;
+    keyframes.sort(function(a, b) {
+      return a.percent - b.percent;
+    });
+    util.each(keyframes, function(kf) {
+      var animators = el.animators;
+      var kfValues = targetPropName ? kf[targetPropName] : kf;
+      if (!kfValues) {
+        return;
+      }
+      var propKeys = util.keys(kfValues);
+      if (!targetPropName) {
+        propKeys = util.filter(propKeys, function(key) {
+          return util.indexOf(KEYFRAME_EXCLUDE_KEYS, key) < 0;
+        });
+      }
+      if (!propKeys.length) {
+        return;
+      }
+      if (!animator) {
+        animator = el.animate(targetPropName, animationOpts.loop, true);
+        animator.scope = "keyframe";
+      }
+      for (var i = 0; i < animators.length; i++) {
+        if (animators[i] !== animator && animators[i].targetName === animator.targetName) {
+          animators[i].stopTracks(propKeys);
+        }
+      }
+      targetPropName && (stateToRestore[targetPropName] = stateToRestore[targetPropName] || {});
+      var savedTarget = targetPropName ? stateToRestore[targetPropName] : stateToRestore;
+      util.each(propKeys, function(key) {
+        savedTarget[key] = ((targetPropName ? el[targetPropName] : el) || {})[key];
+      });
+      animator.whenWithKeys(duration * kf.percent, kfValues, propKeys, kf.easing);
+    });
+    if (!animator) {
+      return;
+    }
+    animator.delay(animationOpts.delay || 0).duration(duration).start(animationOpts.easing);
+  });
+}
+exports.applyKeyframeAnimation = applyKeyframeAnimation;
+exports.stopPreviousKeyframeAnimationAndRestore = stopPreviousKeyframeAnimationAndRestore;

package/lib/node_modules/echarts/lib/animation/customGraphicTransition.js

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const model = require("../util/model.js");
+const util = require("../../../zrender/lib/core/util.js");
+const Animator = require("../../../zrender/lib/animation/Animator.js");
+const Displayable = require("../../../zrender/lib/graphic/Displayable.js");
+const basicTransition = require("./basicTransition.js");
+require("../util/graphic.js");
+const Transformable = require("../../../zrender/lib/core/Transformable.js");
+const Path = require("../../../zrender/lib/graphic/Path.js");
+var LEGACY_TRANSFORM_PROPS_MAP = {
+  position: ["x", "y"],
+  scale: ["scaleX", "scaleY"],
+  origin: ["originX", "originY"]
+};
+var LEGACY_TRANSFORM_PROPS = util.keys(LEGACY_TRANSFORM_PROPS_MAP);
+util.reduce(Transformable.TRANSFORMABLE_PROPS, function(obj, key) {
+  obj[key] = 1;
+  return obj;
+}, {});
+Transformable.TRANSFORMABLE_PROPS.join(", ");
+var ELEMENT_ANIMATABLE_PROPS = ["", "style", "shape", "extra"];
+var transitionInnerStore = model.makeInner();
+function getElementAnimationConfig(animationType, el, elOption, parentModel, dataIndex) {
+  var animationProp = animationType + "Animation";
+  var config = basicTransition.getAnimationConfig(animationType, parentModel, dataIndex) || {};
+  var userDuring = transitionInnerStore(el).userDuring;
+  if (config.duration > 0) {
+    config.during = userDuring ? util.bind(duringCall, {
+      el,
+      userDuring
+    }) : null;
+    config.setToFinal = true;
+    config.scope = animationType;
+  }
+  util.extend(config, elOption[animationProp]);
+  return config;
+}
+function applyUpdateTransition(el, elOption, animatableModel, opts) {
+  opts = opts || {};
+  var dataIndex = opts.dataIndex, isInit = opts.isInit, clearStyle = opts.clearStyle;
+  var hasAnimation = animatableModel.isAnimationEnabled();
+  var store = transitionInnerStore(el);
+  var styleOpt = elOption.style;
+  store.userDuring = elOption.during;
+  var transFromProps = {};
+  var propsToSet = {};
+  prepareTransformAllPropsFinal(el, elOption, propsToSet);
+  prepareShapeOrExtraAllPropsFinal("shape", elOption, propsToSet);
+  prepareShapeOrExtraAllPropsFinal("extra", elOption, propsToSet);
+  if (!isInit && hasAnimation) {
+    prepareTransformTransitionFrom(el, elOption, transFromProps);
+    prepareShapeOrExtraTransitionFrom("shape", el, elOption, transFromProps);
+    prepareShapeOrExtraTransitionFrom("extra", el, elOption, transFromProps);
+    prepareStyleTransitionFrom(el, elOption, styleOpt, transFromProps);
+  }
+  propsToSet.style = styleOpt;
+  applyPropsDirectly(el, propsToSet, clearStyle);
+  applyMiscProps(el, elOption);
+  if (hasAnimation) {
+    if (isInit) {
+      var enterFromProps_1 = {};
+      util.each(ELEMENT_ANIMATABLE_PROPS, function(propName) {
+        var prop = propName ? elOption[propName] : elOption;
+        if (prop && prop.enterFrom) {
+          if (propName) {
+            enterFromProps_1[propName] = enterFromProps_1[propName] || {};
+          }
+          util.extend(propName ? enterFromProps_1[propName] : enterFromProps_1, prop.enterFrom);
+        }
+      });
+      var config = getElementAnimationConfig("enter", el, elOption, animatableModel, dataIndex);
+      if (config.duration > 0) {
+        el.animateFrom(enterFromProps_1, config);
+      }
+    } else {
+      applyPropsTransition(el, elOption, dataIndex || 0, animatableModel, transFromProps);
+    }
+  }
+  updateLeaveTo(el, elOption);
+  styleOpt ? el.dirty() : el.markRedraw();
+}
+function updateLeaveTo(el, elOption) {
+  var leaveToProps = transitionInnerStore(el).leaveToProps;
+  for (var i = 0; i < ELEMENT_ANIMATABLE_PROPS.length; i++) {
+    var propName = ELEMENT_ANIMATABLE_PROPS[i];
+    var prop = propName ? elOption[propName] : elOption;
+    if (prop && prop.leaveTo) {
+      if (!leaveToProps) {
+        leaveToProps = transitionInnerStore(el).leaveToProps = {};
+      }
+      if (propName) {
+        leaveToProps[propName] = leaveToProps[propName] || {};
+      }
+      util.extend(propName ? leaveToProps[propName] : leaveToProps, prop.leaveTo);
+    }
+  }
+}
+function applyLeaveTransition(el, elOption, animatableModel, onRemove) {
+  if (el) {
+    var parent_1 = el.parent;
+    var leaveToProps = transitionInnerStore(el).leaveToProps;
+    if (leaveToProps) {
+      var config = getElementAnimationConfig("update", el, elOption, animatableModel, 0);
+      config.done = function() {
+        parent_1.remove(el);
+      };
+      el.animateTo(leaveToProps, config);
+    } else {
+      parent_1.remove(el);
+    }
+  }
+}
+function isTransitionAll(transition) {
+  return transition === "all";
+}
+function applyPropsDirectly(el, allPropsFinal, clearStyle) {
+  var styleOpt = allPropsFinal.style;
+  if (!el.isGroup && styleOpt) {
+    if (clearStyle) {
+      el.useStyle({});
+      var animators = el.animators;
+      for (var i = 0; i < animators.length; i++) {
+        var animator = animators[i];
+        if (animator.targetName === "style") {
+          animator.changeTarget(el.style);
+        }
+      }
+    }
+    el.setStyle(styleOpt);
+  }
+  if (allPropsFinal) {
+    allPropsFinal.style = null;
+    allPropsFinal && el.attr(allPropsFinal);
+    allPropsFinal.style = styleOpt;
+  }
+}
+function applyPropsTransition(el, elOption, dataIndex, model2, transFromProps) {
+  if (transFromProps) {
+    var config = getElementAnimationConfig("update", el, elOption, model2, dataIndex);
+    if (config.duration > 0) {
+      el.animateFrom(transFromProps, config);
+    }
+  }
+}
+function applyMiscProps(el, elOption) {
+  util.hasOwn(elOption, "silent") && (el.silent = elOption.silent);
+  util.hasOwn(elOption, "ignore") && (el.ignore = elOption.ignore);
+  if (el instanceof Displayable.default) {
+    util.hasOwn(elOption, "invisible") && (el.invisible = elOption.invisible);
+  }
+  if (el instanceof Path.default) {
+    util.hasOwn(elOption, "autoBatch") && (el.autoBatch = elOption.autoBatch);
+  }
+}
+var tmpDuringScope = {};
+var transitionDuringAPI = {
+  // Usually other props do not need to be changed in animation during.
+  setTransform: function(key, val) {
+    tmpDuringScope.el[key] = val;
+    return this;
+  },
+  getTransform: function(key) {
+    return tmpDuringScope.el[key];
+  },
+  setShape: function(key, val) {
+    var el = tmpDuringScope.el;
+    var shape = el.shape || (el.shape = {});
+    shape[key] = val;
+    el.dirtyShape && el.dirtyShape();
+    return this;
+  },
+  getShape: function(key) {
+    var shape = tmpDuringScope.el.shape;
+    if (shape) {
+      return shape[key];
+    }
+  },
+  setStyle: function(key, val) {
+    var el = tmpDuringScope.el;
+    var style = el.style;
+    if (style) {
+      style[key] = val;
+      el.dirtyStyle && el.dirtyStyle();
+    }
+    return this;
+  },
+  getStyle: function(key) {
+    var style = tmpDuringScope.el.style;
+    if (style) {
+      return style[key];
+    }
+  },
+  setExtra: function(key, val) {
+    var extra = tmpDuringScope.el.extra || (tmpDuringScope.el.extra = {});
+    extra[key] = val;
+    return this;
+  },
+  getExtra: function(key) {
+    var extra = tmpDuringScope.el.extra;
+    if (extra) {
+      return extra[key];
+    }
+  }
+};
+function duringCall() {
+  var scope = this;
+  var el = scope.el;
+  if (!el) {
+    return;
+  }
+  var latestUserDuring = transitionInnerStore(el).userDuring;
+  var scopeUserDuring = scope.userDuring;
+  if (latestUserDuring !== scopeUserDuring) {
+    scope.el = scope.userDuring = null;
+    return;
+  }
+  tmpDuringScope.el = el;
+  scopeUserDuring(transitionDuringAPI);
+}
+function prepareShapeOrExtraTransitionFrom(mainAttr, fromEl, elOption, transFromProps) {
+  var attrOpt = elOption[mainAttr];
+  if (!attrOpt) {
+    return;
+  }
+  var elPropsInAttr = fromEl[mainAttr];
+  var transFromPropsInAttr;
+  if (elPropsInAttr) {
+    var transition = elOption.transition;
+    var attrTransition = attrOpt.transition;
+    if (attrTransition) {
+      !transFromPropsInAttr && (transFromPropsInAttr = transFromProps[mainAttr] = {});
+      if (isTransitionAll(attrTransition)) {
+        util.extend(transFromPropsInAttr, elPropsInAttr);
+      } else {
+        var transitionKeys = model.normalizeToArray(attrTransition);
+        for (var i = 0; i < transitionKeys.length; i++) {
+          var key = transitionKeys[i];
+          var elVal = elPropsInAttr[key];
+          transFromPropsInAttr[key] = elVal;
+        }
+      }
+    } else if (isTransitionAll(transition) || util.indexOf(transition, mainAttr) >= 0) {
+      !transFromPropsInAttr && (transFromPropsInAttr = transFromProps[mainAttr] = {});
+      var elPropsInAttrKeys = util.keys(elPropsInAttr);
+      for (var i = 0; i < elPropsInAttrKeys.length; i++) {
+        var key = elPropsInAttrKeys[i];
+        var elVal = elPropsInAttr[key];
+        if (isNonStyleTransitionEnabled(attrOpt[key], elVal)) {
+          transFromPropsInAttr[key] = elVal;
+        }
+      }
+    }
+  }
+}
+function prepareShapeOrExtraAllPropsFinal(mainAttr, elOption, allProps) {
+  var attrOpt = elOption[mainAttr];
+  if (!attrOpt) {
+    return;
+  }
+  var allPropsInAttr = allProps[mainAttr] = {};
+  var keysInAttr = util.keys(attrOpt);
+  for (var i = 0; i < keysInAttr.length; i++) {
+    var key = keysInAttr[i];
+    allPropsInAttr[key] = Animator.cloneValue(attrOpt[key]);
+  }
+}
+function prepareTransformTransitionFrom(el, elOption, transFromProps) {
+  var transition = elOption.transition;
+  var transitionKeys = isTransitionAll(transition) ? Transformable.TRANSFORMABLE_PROPS : model.normalizeToArray(transition || []);
+  for (var i = 0; i < transitionKeys.length; i++) {
+    var key = transitionKeys[i];
+    if (key === "style" || key === "shape" || key === "extra") {
+      continue;
+    }
+    var elVal = el[key];
+    transFromProps[key] = elVal;
+  }
+}
+function prepareTransformAllPropsFinal(el, elOption, allProps) {
+  for (var i = 0; i < LEGACY_TRANSFORM_PROPS.length; i++) {
+    var legacyName = LEGACY_TRANSFORM_PROPS[i];
+    var xyName = LEGACY_TRANSFORM_PROPS_MAP[legacyName];
+    var legacyArr = elOption[legacyName];
+    if (legacyArr) {
+      allProps[xyName[0]] = legacyArr[0];
+      allProps[xyName[1]] = legacyArr[1];
+    }
+  }
+  for (var i = 0; i < Transformable.TRANSFORMABLE_PROPS.length; i++) {
+    var key = Transformable.TRANSFORMABLE_PROPS[i];
+    if (elOption[key] != null) {
+      allProps[key] = elOption[key];
+    }
+  }
+}
+function prepareStyleTransitionFrom(fromEl, elOption, styleOpt, transFromProps) {
+  if (!styleOpt) {
+    return;
+  }
+  var fromElStyle = fromEl.style;
+  var transFromStyleProps;
+  if (fromElStyle) {
+    var styleTransition = styleOpt.transition;
+    var elTransition = elOption.transition;
+    if (styleTransition && !isTransitionAll(styleTransition)) {
+      var transitionKeys = model.normalizeToArray(styleTransition);
+      !transFromStyleProps && (transFromStyleProps = transFromProps.style = {});
+      for (var i = 0; i < transitionKeys.length; i++) {
+        var key = transitionKeys[i];
+        var elVal = fromElStyle[key];
+        transFromStyleProps[key] = elVal;
+      }
+    } else if (fromEl.getAnimationStyleProps && (isTransitionAll(elTransition) || isTransitionAll(styleTransition) || util.indexOf(elTransition, "style") >= 0)) {
+      var animationProps = fromEl.getAnimationStyleProps();
+      var animationStyleProps = animationProps ? animationProps.style : null;
+      if (animationStyleProps) {
+        !transFromStyleProps && (transFromStyleProps = transFromProps.style = {});
+        var styleKeys = util.keys(styleOpt);
+        for (var i = 0; i < styleKeys.length; i++) {
+          var key = styleKeys[i];
+          if (animationStyleProps[key]) {
+            var elVal = fromElStyle[key];
+            transFromStyleProps[key] = elVal;
+          }
+        }
+      }
+    }
+  }
+}
+function isNonStyleTransitionEnabled(optVal, elVal) {
+  return !util.isArrayLike(optVal) ? optVal != null && isFinite(optVal) : optVal !== elVal;
+}
+exports.ELEMENT_ANIMATABLE_PROPS = ELEMENT_ANIMATABLE_PROPS;
+exports.applyLeaveTransition = applyLeaveTransition;
+exports.applyUpdateTransition = applyUpdateTransition;
+exports.isTransitionAll = isTransitionAll;
+exports.updateLeaveTo = updateLeaveTo;