anchor.diff:  /// a list/map of all functions, use for test, demo, editor
   final all = new LinkedHashMap<String, Function>()
     ..['linear'] = linear
  +  ..['random'] = random
     ..['inQuad'] = inQuad
     ..['outQuad'] = outQuad
     ..['inOutQuad'] = inOutQuad
  +  ..['outInQuad'] = outInQuad
     ..['inCubic'] = inCubic
     ..['outCubic'] = outCubic
     ..['inOutCubic'] = inOutCubic
  +  ..['outInCubic'] = outInCubic
     ..['inQuartic'] = inQuartic
     ..['outQuartic'] = outQuartic
     ..['inOutQuartic'] = inOutQuartic
  +  ..['outInQuartic'] = outInQuartic
     ..['inQuintic'] = inQuintic
     ..['outQuintic'] = outQuintic
     ..['inOutQuintic'] = inOutQuintic
  +  ..['outInQuintic'] = outInQuintic
     ..['inSine'] = inSine
     ..['outSine'] = outSine
  +  ..['inOutSine'] = inOutSine
  +  ..['outInSine'] = outInSine
     ..['inExponential'] = inExponential
     ..['outExponential'] = outExponential
     ..['inOutExponential'] = inOutExponential
  +  ..['outInExponential'] = outInExponential
     ..['inCircular'] = inCircular
     ..['outCircular'] = outCircular
     ..['inOutCircular'] = inOutCircular
  +  ..['outInCircular'] = outInCircular
  +  ..['inBack'] = inBack
  +  ..['outBack'] = outBack
  +  ..['inOutBack'] = inOutBack
  +  ..['outInBack'] = outInBack
  +  ..['inElastic'] = inElastic
  +  ..['outElastic'] = outElastic
  +  ..['inOutElastic'] = inOutElastic
  +  ..['outInElastic'] = outInElastic
  +  ..['inBounce'] = inBounce
  +  ..['outBounce'] = outBounce
  +  ..['inOutBounce'] = inOutBounce
  +  ..['outInBounce'] = outInBounce
     ;
  +
  +/// create a new ease function by chaining 2 ease function
  +chain(f0, f1) => (double ratio, num change, num baseValue) {
  +  ratio = ratio * 2.0;
  +  var c = change / 2;
  +  return (ratio < 1.0) ? f0(ratio, c, baseValue) : f1(ratio - 1.0, c, baseValue) + c;
  +};
  +
  +/// create a new ease function by chaining 2 ease function
  +goback(f0) => (double ratio, num change, num baseValue) {
  +  ratio = ratio * 2.0;
  +  var c = change;
  +  return (ratio < 1.0) ? f0(ratio, c, baseValue) : f0(ratio - 1.0, -c, baseValue + c);
  +};
   
   /**
    * Performs a linear.
  
positive.code:   return change * ratio * ratio * ratio * ratio * ratio + baseValue;
  }
  
  /**
   * Performs a quintic easy-out.
   */
  num outQuintic(double ratio, num change, num baseValue) {
    ratio--;
    return change * (ratio * ratio * ratio * ratio * ratio + 1) + baseValue;
  }
  
  /**
   * Performs a quintic easy-in-out.
   */
  num inOutQuintic(double ratio, num change, num baseValue) {
    var r = 2 * ratio;
  
    if (r < 1)
      return change / 2 * r * r * r * r * r + baseValue;
  
    r -= 2;
  
    return change / 2 * (r * r * r * r * r + 2) + baseValue;
  }
  
  // SINUSOIDAL
  
  /**
   * Performs a sine easy-in.
   */
  num inSine(double ratio, num change, num baseValue) {
    return -change * cos(ratio * (PI / 2)) + change + baseValue;
  }
  
  /**
   * Performs a sine easy-out.
   */
  num outSine(double ratio, num change, num baseValue) {
    return change * sin(ratio * (PI / 2)) + baseValue;
  }
  
  /**
   * Performs a sine easy-in-out.
   */
  num inOutSine(double ratio, num change, num baseValue) {
    return -change / 2 * (cos(ratio * PI) - 1) + baseValue;
  }
  
  // EXPONENTIAL
  
  /**
   * Performs an exponential easy-in.
   */
  num inExponential(double ratio, num change, num baseValue) {
    return change * pow(2, 10 * (ratio - 1)) + baseValue;
  }
  
  /**
   * Performs an exponential easy-out.
   */
  num outExponential(double ratio, num change, num baseValue) {
    return change * (-pow(2, -10 * ratio) + 1) + baseValue;
  }
  
  /**
   * Performs an exponential easy-in-out.
   */
  num inOutExponential(double ratio, num change, num baseValue) {
    var r = 2 * ratio;
  
    if (r < 1)
      return change / 2 * pow(2, 10 * (r - 1)) + baseValue;
  
    r--;
  
    return change / 2 * (-pow(2, -10 * r) + 2) + baseValue;
  }
  
  // CIRCULAR
  
  /**
   * Performs a circular easy-in.
   */
  num inCircular(double ratio, num change, num baseValue) {
    return -change * (sqrt(1 - ratio * ratio) - 1) + baseValue;
  }
  
  /**
   * Performs a circular easy-out.
   */
  num outCircular(double ratio, num change, num baseValue) {
    ratio--;
  
    return change * sqrt(1 - ratio * ratio) + baseValue;
  }
  
  /**
   * Performs a circular easy-in-out.
   */
  num inOutCircular(double ratio, num change, num baseValue) {
    var r = 2 * ratio;
  
    if (r < 1)
      return -change / 2 * (sqrt(1 - r * r) - 1) + baseValue;
  
    r -= 2;
    return change / 2 * (sqrt(1 - r * r) + 1) + baseValue;
  }
  
  
negative.code:   return change * ratio + baseValue;
  }
  
  /**
   * Performs a random value (except for ratio == 0 or ratio == 1).
   */
  num random(double ratio, num change, num baseValue) {
    var r = (ratio > 0.0 && ratio < 1.0) ? _randomRatio.nextDouble() : ratio;
    return change * r + baseValue;
  }
  final _randomRatio = new Random();
  
  // QUADRATIC
  
  num inQuad(double ratio, num change, num baseValue) {
    return change * ratio * ratio + baseValue;
  }
  
  num outQuad(double ratio, num change, num baseValue) {
    return -change * ratio * (ratio - 2) + baseValue;
  }
  
  final inOutQuad = chain(inQuad, outQuad);
  
  final outInQuad = chain(outQuad, inQuad);
  
  // CUBIC
  
  num inCubic(double ratio, num change, num baseValue) {
    return change * ratio * ratio * ratio + baseValue;
  }
  
  num outCubic(double ratio, num change, num baseValue) {
    ratio--;
    return change * (ratio * ratio * ratio + 1) + baseValue;
  }
  
  final inOutCubic = chain(inCubic, outCubic);
  
  final outInCubic = chain(outCubic, inCubic);
  
  // QUARTIC
  
  num inQuartic(double ratio, num change, num baseValue) {
    return change * ratio * ratio * ratio * ratio + baseValue;
  }
  
  num outQuartic(double ratio, num change, num baseValue) {
    ratio--;
    return -change * (ratio * ratio * ratio * ratio - 1) + baseValue;
  }
  
  final inOutQuartic = chain(inQuartic, outQuartic);
  
  final outInQuartic = chain(outQuartic, inQuartic);
  
  // QUINTIC
  
  