anchor.diff:  import 'dart:collection';
   
   /// a list/map of all functions, use for test, demo, editor
  -final all = new LinkedHashMap<String, Function>()
  +final all = new LinkedHashMap<String, Ease>()
     ..['linear'] = linear
     ..['random'] = random
     ..['inQuad'] = inQuad
  
positive.code: // For more information, please refer to <http://unlicense.org/>
  
  /**
   * A set of common "easing" function to compute intermediate value of a variable,
   * generally from [baseValue] to [baseValue] + [change],
   * used for transition, interpolation.
   *
   * Every function follow the same signature :
   * * [ratio] is the progression (0.0 .. 1.0).
   * * [change] is the "amplitute" of the variation for the final variable,
   * or the difference between [baseValue] and the final value.
   * * [baseValue] the initiale value of the variable
   * * return the intermediate value.
   *
   * Functions can be used without dartemis or dartemis_addons (there are fully standalone)
   *
   * [graphical representation](http://davidb.github.io/dartemis_addons/ease_graphics.html)
   */
  library ease;
  
  
negative.code:   ;
  
  /// create a new ease function by chaining 2 ease function
  chain(Ease f0, Ease 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;
  };
  
  reverse(Ease f0) => (double ratio, num change, num baseValue) {
    return f0(ratio, -change, baseValue + change);
  };
  
  /// create a new ease function by chaining 2 ease function
  goback(Ease f0) => (double ratio, num change, num baseValue) {
    ratio = ratio * 2.0;
    var c = change;
    return (ratio < 1.0) ? f0(ratio, c, baseValue) : reverse(f0)(ratio - 1.0, c, baseValue);
  };
  
  easeRatio(Ease f0, Ease ease4ratio) => (double ratio, num change, num baseValue) {
    ratio = ease4ratio(ratio, 1.0, 0.0);
    return f0(ratio, change, baseValue);
  };
  
  periodicRatio(Ease f0, num duration) => (double ratio, num change, num baseValue) {
    ratio = (ratio / duration);
    ratio = ratio - ratio.toInt();
    return f0(ratio, change, baseValue);
  };
  
  onceRatio(Ease f0, num duration) => (double ratio, num change, num baseValue) {
    ratio = (ratio < duration) ? (ratio / duration) : 1.0;
    return f0(ratio, change, baseValue);
  };
  
  /// generally from [baseValue] to [baseValue] + [change],
  /// used for transition, interpolation.
  ///
  /// Every function follow the same signature :
  /// * [ratio] is the progression (0.0 .. 1.0).
  /// * [change] is the "amplitute" of the variation for the final variable,
  /// or the difference between [baseValue] and the final value.
  /// * [baseValue] the initiale value of the variable
  /// * return the intermediate value.
  typedef num Ease(double ratio, num change, num baseValue);
  
  /**
   * Performs a linear.
  