sun-card-design 1.1.16 → 1.1.18

package/dist/pc/sun-card-design-pc.es2035.js

@@ -1,17 +1,701 @@
-import { getDecalFromPalette } from "./sun-card-design-pc.es1759.js";
-function enableAriaDecalForTree(seriesModel) {
-  var data = seriesModel.getData();
-  var tree = data.tree;
-  var decalPaletteScope = {};
-  tree.eachNode(function(node) {
-    var current = node;
-    while (current && current.depth > 1) {
-      current = current.parentNode;
-    }
-    var decal = getDecalFromPalette(seriesModel.ecModel, current.name || current.dataIndex + "", decalPaletteScope);
-    node.setVisual("decal", decal);
-  });
+import Clip from "./sun-card-design-pc.es2167.js";
+import { parse } from "./sun-card-design-pc.es1768.js";
+import { logError, isArrayLike, keys, map, isNumber, eqNaN, isString, isGradientObject, extend, isFunction } from "./sun-card-design-pc.es922.js";
+import easingFuncs from "./sun-card-design-pc.es2168.js";
+import { createCubicEasingFunc } from "./sun-card-design-pc.es2169.js";
+import { isLinearGradient, isRadialGradient } from "./sun-card-design-pc.es2087.js";
+var arraySlice = Array.prototype.slice;
+function interpolateNumber(p0, p1, percent) {
+  return (p1 - p0) * percent + p0;
 }
+function interpolate1DArray(out, p0, p1, percent) {
+  var len = p0.length;
+  for (var i = 0; i < len; i++) {
+    out[i] = interpolateNumber(p0[i], p1[i], percent);
+  }
+  return out;
+}
+function interpolate2DArray(out, p0, p1, percent) {
+  var len = p0.length;
+  var len2 = len && p0[0].length;
+  for (var i = 0; i < len; i++) {
+    if (!out[i]) {
+      out[i] = [];
+    }
+    for (var j = 0; j < len2; j++) {
+      out[i][j] = interpolateNumber(p0[i][j], p1[i][j], percent);
+    }
+  }
+  return out;
+}
+function add1DArray(out, p0, p1, sign) {
+  var len = p0.length;
+  for (var i = 0; i < len; i++) {
+    out[i] = p0[i] + p1[i] * sign;
+  }
+  return out;
+}
+function add2DArray(out, p0, p1, sign) {
+  var len = p0.length;
+  var len2 = len && p0[0].length;
+  for (var i = 0; i < len; i++) {
+    if (!out[i]) {
+      out[i] = [];
+    }
+    for (var j = 0; j < len2; j++) {
+      out[i][j] = p0[i][j] + p1[i][j] * sign;
+    }
+  }
+  return out;
+}
+function fillColorStops(val0, val1) {
+  var len0 = val0.length;
+  var len1 = val1.length;
+  var shorterArr = len0 > len1 ? val1 : val0;
+  var shorterLen = Math.min(len0, len1);
+  var last = shorterArr[shorterLen - 1] || { color: [0, 0, 0, 0], offset: 0 };
+  for (var i = shorterLen; i < Math.max(len0, len1); i++) {
+    shorterArr.push({
+      offset: last.offset,
+      color: last.color.slice()
+    });
+  }
+}
+function fillArray(val0, val1, arrDim) {
+  var arr0 = val0;
+  var arr1 = val1;
+  if (!arr0.push || !arr1.push) {
+    return;
+  }
+  var arr0Len = arr0.length;
+  var arr1Len = arr1.length;
+  if (arr0Len !== arr1Len) {
+    var isPreviousLarger = arr0Len > arr1Len;
+    if (isPreviousLarger) {
+      arr0.length = arr1Len;
+    } else {
+      for (var i = arr0Len; i < arr1Len; i++) {
+        arr0.push(arrDim === 1 ? arr1[i] : arraySlice.call(arr1[i]));
+      }
+    }
+  }
+  var len2 = arr0[0] && arr0[0].length;
+  for (var i = 0; i < arr0.length; i++) {
+    if (arrDim === 1) {
+      if (isNaN(arr0[i])) {
+        arr0[i] = arr1[i];
+      }
+    } else {
+      for (var j = 0; j < len2; j++) {
+        if (isNaN(arr0[i][j])) {
+          arr0[i][j] = arr1[i][j];
+        }
+      }
+    }
+  }
+}
+function cloneValue(value) {
+  if (isArrayLike(value)) {
+    var len = value.length;
+    if (isArrayLike(value[0])) {
+      var ret = [];
+      for (var i = 0; i < len; i++) {
+        ret.push(arraySlice.call(value[i]));
+      }
+      return ret;
+    }
+    return arraySlice.call(value);
+  }
+  return value;
+}
+function rgba2String(rgba) {
+  rgba[0] = Math.floor(rgba[0]) || 0;
+  rgba[1] = Math.floor(rgba[1]) || 0;
+  rgba[2] = Math.floor(rgba[2]) || 0;
+  rgba[3] = rgba[3] == null ? 1 : rgba[3];
+  return "rgba(" + rgba.join(",") + ")";
+}
+function guessArrayDim(value) {
+  return isArrayLike(value && value[0]) ? 2 : 1;
+}
+var VALUE_TYPE_NUMBER = 0;
+var VALUE_TYPE_1D_ARRAY = 1;
+var VALUE_TYPE_2D_ARRAY = 2;
+var VALUE_TYPE_COLOR = 3;
+var VALUE_TYPE_LINEAR_GRADIENT = 4;
+var VALUE_TYPE_RADIAL_GRADIENT = 5;
+var VALUE_TYPE_UNKOWN = 6;
+function isGradientValueType(valType) {
+  return valType === VALUE_TYPE_LINEAR_GRADIENT || valType === VALUE_TYPE_RADIAL_GRADIENT;
+}
+function isArrayValueType(valType) {
+  return valType === VALUE_TYPE_1D_ARRAY || valType === VALUE_TYPE_2D_ARRAY;
+}
+var tmpRgba = [0, 0, 0, 0];
+var Track = (function() {
+  function Track2(propName) {
+    this.keyframes = [];
+    this.discrete = false;
+    this._invalid = false;
+    this._needsSort = false;
+    this._lastFr = 0;
+    this._lastFrP = 0;
+    this.propName = propName;
+  }
+  Track2.prototype.isFinished = function() {
+    return this._finished;
+  };
+  Track2.prototype.setFinished = function() {
+    this._finished = true;
+    if (this._additiveTrack) {
+      this._additiveTrack.setFinished();
+    }
+  };
+  Track2.prototype.needsAnimate = function() {
+    return this.keyframes.length >= 1;
+  };
+  Track2.prototype.getAdditiveTrack = function() {
+    return this._additiveTrack;
+  };
+  Track2.prototype.addKeyframe = function(time, rawValue, easing) {
+    this._needsSort = true;
+    var keyframes = this.keyframes;
+    var len = keyframes.length;
+    var discrete = false;
+    var valType = VALUE_TYPE_UNKOWN;
+    var value = rawValue;
+    if (isArrayLike(rawValue)) {
+      var arrayDim = guessArrayDim(rawValue);
+      valType = arrayDim;
+      if (arrayDim === 1 && !isNumber(rawValue[0]) || arrayDim === 2 && !isNumber(rawValue[0][0])) {
+        discrete = true;
+      }
+    } else {
+      if (isNumber(rawValue) && !eqNaN(rawValue)) {
+        valType = VALUE_TYPE_NUMBER;
+      } else if (isString(rawValue)) {
+        if (!isNaN(+rawValue)) {
+          valType = VALUE_TYPE_NUMBER;
+        } else {
+          var colorArray = parse(rawValue);
+          if (colorArray) {
+            value = colorArray;
+            valType = VALUE_TYPE_COLOR;
+          }
+        }
+      } else if (isGradientObject(rawValue)) {
+        var parsedGradient = extend({}, value);
+        parsedGradient.colorStops = map(rawValue.colorStops, function(colorStop) {
+          return {
+            offset: colorStop.offset,
+            color: parse(colorStop.color)
+          };
+        });
+        if (isLinearGradient(rawValue)) {
+          valType = VALUE_TYPE_LINEAR_GRADIENT;
+        } else if (isRadialGradient(rawValue)) {
+          valType = VALUE_TYPE_RADIAL_GRADIENT;
+        }
+        value = parsedGradient;
+      }
+    }
+    if (len === 0) {
+      this.valType = valType;
+    } else if (valType !== this.valType || valType === VALUE_TYPE_UNKOWN) {
+      discrete = true;
+    }
+    this.discrete = this.discrete || discrete;
+    var kf = {
+      time,
+      value,
+      rawValue,
+      percent: 0
+    };
+    if (easing) {
+      kf.easing = easing;
+      kf.easingFunc = isFunction(easing) ? easing : easingFuncs[easing] || createCubicEasingFunc(easing);
+    }
+    keyframes.push(kf);
+    return kf;
+  };
+  Track2.prototype.prepare = function(maxTime, additiveTrack) {
+    var kfs = this.keyframes;
+    if (this._needsSort) {
+      kfs.sort(function(a, b) {
+        return a.time - b.time;
+      });
+    }
+    var valType = this.valType;
+    var kfsLen = kfs.length;
+    var lastKf = kfs[kfsLen - 1];
+    var isDiscrete = this.discrete;
+    var isArr = isArrayValueType(valType);
+    var isGradient = isGradientValueType(valType);
+    for (var i = 0; i < kfsLen; i++) {
+      var kf = kfs[i];
+      var value = kf.value;
+      var lastValue = lastKf.value;
+      kf.percent = kf.time / maxTime;
+      if (!isDiscrete) {
+        if (isArr && i !== kfsLen - 1) {
+          fillArray(value, lastValue, valType);
+        } else if (isGradient) {
+          fillColorStops(value.colorStops, lastValue.colorStops);
+        }
+      }
+    }
+    if (!isDiscrete && valType !== VALUE_TYPE_RADIAL_GRADIENT && additiveTrack && this.needsAnimate() && additiveTrack.needsAnimate() && valType === additiveTrack.valType && !additiveTrack._finished) {
+      this._additiveTrack = additiveTrack;
+      var startValue = kfs[0].value;
+      for (var i = 0; i < kfsLen; i++) {
+        if (valType === VALUE_TYPE_NUMBER) {
+          kfs[i].additiveValue = kfs[i].value - startValue;
+        } else if (valType === VALUE_TYPE_COLOR) {
+          kfs[i].additiveValue = add1DArray([], kfs[i].value, startValue, -1);
+        } else if (isArrayValueType(valType)) {
+          kfs[i].additiveValue = valType === VALUE_TYPE_1D_ARRAY ? add1DArray([], kfs[i].value, startValue, -1) : add2DArray([], kfs[i].value, startValue, -1);
+        }
+      }
+    }
+  };
+  Track2.prototype.step = function(target, percent) {
+    if (this._finished) {
+      return;
+    }
+    if (this._additiveTrack && this._additiveTrack._finished) {
+      this._additiveTrack = null;
+    }
+    var isAdditive = this._additiveTrack != null;
+    var valueKey = isAdditive ? "additiveValue" : "value";
+    var valType = this.valType;
+    var keyframes = this.keyframes;
+    var kfsNum = keyframes.length;
+    var propName = this.propName;
+    var isValueColor = valType === VALUE_TYPE_COLOR;
+    var frameIdx;
+    var lastFrame = this._lastFr;
+    var mathMin = Math.min;
+    var frame;
+    var nextFrame;
+    if (kfsNum === 1) {
+      frame = nextFrame = keyframes[0];
+    } else {
+      if (percent < 0) {
+        frameIdx = 0;
+      } else if (percent < this._lastFrP) {
+        var start = mathMin(lastFrame + 1, kfsNum - 1);
+        for (frameIdx = start; frameIdx >= 0; frameIdx--) {
+          if (keyframes[frameIdx].percent <= percent) {
+            break;
+          }
+        }
+        frameIdx = mathMin(frameIdx, kfsNum - 2);
+      } else {
+        for (frameIdx = lastFrame; frameIdx < kfsNum; frameIdx++) {
+          if (keyframes[frameIdx].percent > percent) {
+            break;
+          }
+        }
+        frameIdx = mathMin(frameIdx - 1, kfsNum - 2);
+      }
+      nextFrame = keyframes[frameIdx + 1];
+      frame = keyframes[frameIdx];
+    }
+    if (!(frame && nextFrame)) {
+      return;
+    }
+    this._lastFr = frameIdx;
+    this._lastFrP = percent;
+    var interval = nextFrame.percent - frame.percent;
+    var w = interval === 0 ? 1 : mathMin((percent - frame.percent) / interval, 1);
+    if (nextFrame.easingFunc) {
+      w = nextFrame.easingFunc(w);
+    }
+    var targetArr = isAdditive ? this._additiveValue : isValueColor ? tmpRgba : target[propName];
+    if ((isArrayValueType(valType) || isValueColor) && !targetArr) {
+      targetArr = this._additiveValue = [];
+    }
+    if (this.discrete) {
+      target[propName] = w < 1 ? frame.rawValue : nextFrame.rawValue;
+    } else if (isArrayValueType(valType)) {
+      valType === VALUE_TYPE_1D_ARRAY ? interpolate1DArray(targetArr, frame[valueKey], nextFrame[valueKey], w) : interpolate2DArray(targetArr, frame[valueKey], nextFrame[valueKey], w);
+    } else if (isGradientValueType(valType)) {
+      var val = frame[valueKey];
+      var nextVal_1 = nextFrame[valueKey];
+      var isLinearGradient_1 = valType === VALUE_TYPE_LINEAR_GRADIENT;
+      target[propName] = {
+        type: isLinearGradient_1 ? "linear" : "radial",
+        x: interpolateNumber(val.x, nextVal_1.x, w),
+        y: interpolateNumber(val.y, nextVal_1.y, w),
+        colorStops: map(val.colorStops, function(colorStop, idx) {
+          var nextColorStop = nextVal_1.colorStops[idx];
+          return {
+            offset: interpolateNumber(colorStop.offset, nextColorStop.offset, w),
+            color: rgba2String(interpolate1DArray([], colorStop.color, nextColorStop.color, w))
+          };
+        }),
+        global: nextVal_1.global
+      };
+      if (isLinearGradient_1) {
+        target[propName].x2 = interpolateNumber(val.x2, nextVal_1.x2, w);
+        target[propName].y2 = interpolateNumber(val.y2, nextVal_1.y2, w);
+      } else {
+        target[propName].r = interpolateNumber(val.r, nextVal_1.r, w);
+      }
+    } else if (isValueColor) {
+      interpolate1DArray(targetArr, frame[valueKey], nextFrame[valueKey], w);
+      if (!isAdditive) {
+        target[propName] = rgba2String(targetArr);
+      }
+    } else {
+      var value = interpolateNumber(frame[valueKey], nextFrame[valueKey], w);
+      if (isAdditive) {
+        this._additiveValue = value;
+      } else {
+        target[propName] = value;
+      }
+    }
+    if (isAdditive) {
+      this._addToTarget(target);
+    }
+  };
+  Track2.prototype._addToTarget = function(target) {
+    var valType = this.valType;
+    var propName = this.propName;
+    var additiveValue = this._additiveValue;
+    if (valType === VALUE_TYPE_NUMBER) {
+      target[propName] = target[propName] + additiveValue;
+    } else if (valType === VALUE_TYPE_COLOR) {
+      parse(target[propName], tmpRgba);
+      add1DArray(tmpRgba, tmpRgba, additiveValue, 1);
+      target[propName] = rgba2String(tmpRgba);
+    } else if (valType === VALUE_TYPE_1D_ARRAY) {
+      add1DArray(target[propName], target[propName], additiveValue, 1);
+    } else if (valType === VALUE_TYPE_2D_ARRAY) {
+      add2DArray(target[propName], target[propName], additiveValue, 1);
+    }
+  };
+  return Track2;
+})();
+var Animator = (function() {
+  function Animator2(target, loop, allowDiscreteAnimation, additiveTo) {
+    this._tracks = {};
+    this._trackKeys = [];
+    this._maxTime = 0;
+    this._started = 0;
+    this._clip = null;
+    this._target = target;
+    this._loop = loop;
+    if (loop && additiveTo) {
+      logError("Can' use additive animation on looped animation.");
+      return;
+    }
+    this._additiveAnimators = additiveTo;
+    this._allowDiscrete = allowDiscreteAnimation;
+  }
+  Animator2.prototype.getMaxTime = function() {
+    return this._maxTime;
+  };
+  Animator2.prototype.getDelay = function() {
+    return this._delay;
+  };
+  Animator2.prototype.getLoop = function() {
+    return this._loop;
+  };
+  Animator2.prototype.getTarget = function() {
+    return this._target;
+  };
+  Animator2.prototype.changeTarget = function(target) {
+    this._target = target;
+  };
+  Animator2.prototype.when = function(time, props, easing) {
+    return this.whenWithKeys(time, props, keys(props), easing);
+  };
+  Animator2.prototype.whenWithKeys = function(time, props, propNames, easing) {
+    var tracks = this._tracks;
+    for (var i = 0; i < propNames.length; i++) {
+      var propName = propNames[i];
+      var track = tracks[propName];
+      if (!track) {
+        track = tracks[propName] = new Track(propName);
+        var initialValue = void 0;
+        var additiveTrack = this._getAdditiveTrack(propName);
+        if (additiveTrack) {
+          var addtiveTrackKfs = additiveTrack.keyframes;
+          var lastFinalKf = addtiveTrackKfs[addtiveTrackKfs.length - 1];
+          initialValue = lastFinalKf && lastFinalKf.value;
+          if (additiveTrack.valType === VALUE_TYPE_COLOR && initialValue) {
+            initialValue = rgba2String(initialValue);
+          }
+        } else {
+          initialValue = this._target[propName];
+        }
+        if (initialValue == null) {
+          continue;
+        }
+        if (time > 0) {
+          track.addKeyframe(0, cloneValue(initialValue), easing);
+        }
+        this._trackKeys.push(propName);
+      }
+      track.addKeyframe(time, cloneValue(props[propName]), easing);
+    }
+    this._maxTime = Math.max(this._maxTime, time);
+    return this;
+  };
+  Animator2.prototype.pause = function() {
+    this._clip.pause();
+    this._paused = true;
+  };
+  Animator2.prototype.resume = function() {
+    this._clip.resume();
+    this._paused = false;
+  };
+  Animator2.prototype.isPaused = function() {
+    return !!this._paused;
+  };
+  Animator2.prototype.duration = function(duration) {
+    this._maxTime = duration;
+    this._force = true;
+    return this;
+  };
+  Animator2.prototype._doneCallback = function() {
+    this._setTracksFinished();
+    this._clip = null;
+    var doneList = this._doneCbs;
+    if (doneList) {
+      var len = doneList.length;
+      for (var i = 0; i < len; i++) {
+        doneList[i].call(this);
+      }
+    }
+  };
+  Animator2.prototype._abortedCallback = function() {
+    this._setTracksFinished();
+    var animation = this.animation;
+    var abortedList = this._abortedCbs;
+    if (animation) {
+      animation.removeClip(this._clip);
+    }
+    this._clip = null;
+    if (abortedList) {
+      for (var i = 0; i < abortedList.length; i++) {
+        abortedList[i].call(this);
+      }
+    }
+  };
+  Animator2.prototype._setTracksFinished = function() {
+    var tracks = this._tracks;
+    var tracksKeys = this._trackKeys;
+    for (var i = 0; i < tracksKeys.length; i++) {
+      tracks[tracksKeys[i]].setFinished();
+    }
+  };
+  Animator2.prototype._getAdditiveTrack = function(trackName) {
+    var additiveTrack;
+    var additiveAnimators = this._additiveAnimators;
+    if (additiveAnimators) {
+      for (var i = 0; i < additiveAnimators.length; i++) {
+        var track = additiveAnimators[i].getTrack(trackName);
+        if (track) {
+          additiveTrack = track;
+        }
+      }
+    }
+    return additiveTrack;
+  };
+  Animator2.prototype.start = function(easing) {
+    if (this._started > 0) {
+      return;
+    }
+    this._started = 1;
+    var self = this;
+    var tracks = [];
+    var maxTime = this._maxTime || 0;
+    for (var i = 0; i < this._trackKeys.length; i++) {
+      var propName = this._trackKeys[i];
+      var track = this._tracks[propName];
+      var additiveTrack = this._getAdditiveTrack(propName);
+      var kfs = track.keyframes;
+      var kfsNum = kfs.length;
+      track.prepare(maxTime, additiveTrack);
+      if (track.needsAnimate()) {
+        if (!this._allowDiscrete && track.discrete) {
+          var lastKf = kfs[kfsNum - 1];
+          if (lastKf) {
+            self._target[track.propName] = lastKf.rawValue;
+          }
+          track.setFinished();
+        } else {
+          tracks.push(track);
+        }
+      }
+    }
+    if (tracks.length || this._force) {
+      var clip = new Clip({
+        life: maxTime,
+        loop: this._loop,
+        delay: this._delay || 0,
+        onframe: function(percent) {
+          self._started = 2;
+          var additiveAnimators = self._additiveAnimators;
+          if (additiveAnimators) {
+            var stillHasAdditiveAnimator = false;
+            for (var i2 = 0; i2 < additiveAnimators.length; i2++) {
+              if (additiveAnimators[i2]._clip) {
+                stillHasAdditiveAnimator = true;
+                break;
+              }
+            }
+            if (!stillHasAdditiveAnimator) {
+              self._additiveAnimators = null;
+            }
+          }
+          for (var i2 = 0; i2 < tracks.length; i2++) {
+            tracks[i2].step(self._target, percent);
+          }
+          var onframeList = self._onframeCbs;
+          if (onframeList) {
+            for (var i2 = 0; i2 < onframeList.length; i2++) {
+              onframeList[i2](self._target, percent);
+            }
+          }
+        },
+        ondestroy: function() {
+          self._doneCallback();
+        }
+      });
+      this._clip = clip;
+      if (this.animation) {
+        this.animation.addClip(clip);
+      }
+      if (easing) {
+        clip.setEasing(easing);
+      }
+    } else {
+      this._doneCallback();
+    }
+    return this;
+  };
+  Animator2.prototype.stop = function(forwardToLast) {
+    if (!this._clip) {
+      return;
+    }
+    var clip = this._clip;
+    if (forwardToLast) {
+      clip.onframe(1);
+    }
+    this._abortedCallback();
+  };
+  Animator2.prototype.delay = function(time) {
+    this._delay = time;
+    return this;
+  };
+  Animator2.prototype.during = function(cb) {
+    if (cb) {
+      if (!this._onframeCbs) {
+        this._onframeCbs = [];
+      }
+      this._onframeCbs.push(cb);
+    }
+    return this;
+  };
+  Animator2.prototype.done = function(cb) {
+    if (cb) {
+      if (!this._doneCbs) {
+        this._doneCbs = [];
+      }
+      this._doneCbs.push(cb);
+    }
+    return this;
+  };
+  Animator2.prototype.aborted = function(cb) {
+    if (cb) {
+      if (!this._abortedCbs) {
+        this._abortedCbs = [];
+      }
+      this._abortedCbs.push(cb);
+    }
+    return this;
+  };
+  Animator2.prototype.getClip = function() {
+    return this._clip;
+  };
+  Animator2.prototype.getTrack = function(propName) {
+    return this._tracks[propName];
+  };
+  Animator2.prototype.getTracks = function() {
+    var _this = this;
+    return map(this._trackKeys, function(key) {
+      return _this._tracks[key];
+    });
+  };
+  Animator2.prototype.stopTracks = function(propNames, forwardToLast) {
+    if (!propNames.length || !this._clip) {
+      return true;
+    }
+    var tracks = this._tracks;
+    var tracksKeys = this._trackKeys;
+    for (var i = 0; i < propNames.length; i++) {
+      var track = tracks[propNames[i]];
+      if (track && !track.isFinished()) {
+        if (forwardToLast) {
+          track.step(this._target, 1);
+        } else if (this._started === 1) {
+          track.step(this._target, 0);
+        }
+        track.setFinished();
+      }
+    }
+    var allAborted = true;
+    for (var i = 0; i < tracksKeys.length; i++) {
+      if (!tracks[tracksKeys[i]].isFinished()) {
+        allAborted = false;
+        break;
+      }
+    }
+    if (allAborted) {
+      this._abortedCallback();
+    }
+    return allAborted;
+  };
+  Animator2.prototype.saveTo = function(target, trackKeys, firstOrLast) {
+    if (!target) {
+      return;
+    }
+    trackKeys = trackKeys || this._trackKeys;
+    for (var i = 0; i < trackKeys.length; i++) {
+      var propName = trackKeys[i];
+      var track = this._tracks[propName];
+      if (!track || track.isFinished()) {
+        continue;
+      }
+      var kfs = track.keyframes;
+      var kf = kfs[firstOrLast ? 0 : kfs.length - 1];
+      if (kf) {
+        target[propName] = cloneValue(kf.rawValue);
+      }
+    }
+  };
+  Animator2.prototype.__changeFinalValue = function(finalProps, trackKeys) {
+    trackKeys = trackKeys || keys(finalProps);
+    for (var i = 0; i < trackKeys.length; i++) {
+      var propName = trackKeys[i];
+      var track = this._tracks[propName];
+      if (!track) {
+        continue;
+      }
+      var kfs = track.keyframes;
+      if (kfs.length > 1) {
+        var lastKf = kfs.pop();
+        track.addKeyframe(lastKf.time, finalProps[propName]);
+        track.prepare(this._maxTime, track.getAdditiveTrack());
+      }
+    }
+  };
+  return Animator2;
+})();
 export {
-  enableAriaDecalForTree as default
+  cloneValue,
+  Animator as default
 };