simpler library: just expose a (a,b,c,d)=>number=>number function

It is also a performance boost see below.

Performance before:
BezierEasing: instanciation x 147,240 ops/sec ±5.24% (73 runs sampled)
BezierEasing: call x 2,807,525 ops/sec ±1.18% (88 runs sampled)
BezierEasing: instanciation + call x 124,917 ops/sec ±4.78% (83 runs sampled)

Performance after:
BezierEasing: instanciation x 1,043,725 ops/sec ±1.46% (82 runs sampled)
BezierEasing: call x 7,866,642 ops/sec ±0.93% (85 runs sampled)
BezierEasing: instanciation + call x 803,051 ops/sec ±1.58% (74 runs sampled)

Author: gre

.eslintrc

@@ -0,0 +1,24 @@
+{
+  "env": {
+    "node": true
+  },
+  "extends": "eslint:recommended",
+  "rules": {
+    "indent": [
+      2,
+      2
+    ],
+    "linebreak-style": [
+      2,
+      "unix"
+    ],
+    "quotes": [
+      2,
+      "single"
+    ],
+    "semi": [
+      2,
+      "always"
+    ]
+  }
+}

.gitignore

@@ -0,0 +1 @@
+node_modules

.jshintrc

@@ -15,9 +15,9 @@ Usage
 ```javascript
 var easing = BezierEasing(0, 0, 1, 0.5);
 // easing allows to project x in [0.0,1.0] range onto the bezier-curve defined by the 4 points (see schema below).
-console.log(easing.get(0.0)); // 0.0
-console.log(easing.get(0.5)); // 0.3125
-console.log(easing.get(1.0)); // 1.0
+console.log(easing(0.0)); // 0.0
+console.log(easing(0.5)); // 0.3125
+console.log(easing(1.0)); // 1.0
 ```
 
 (this schema is from the CSS spec)
@@ -33,25 +33,7 @@ It is the equivalent to [CSS Transitions' `transition-timing-function`](http://w
 
 
 In the same way you can define in CSS `cubic-bezier(0.42, 0, 0.58, 1)`,
-with BezierEasing, you can define it using `BezierEasing(0.42, 0, 0.58, 1)` which have the `.get` function taking an X and computing the Y interpolated easing value (see schema).
-
-
-Predefined BezierEasing functions
----
-
-**bezier-easing** also define a mapping from existing CSS `transition-timing-function` :
-
-```javscript
-BezierEasing.css = {
-  "ease":        BezierEasing.ease = BezierEasing(0.25, 0.1, 0.25, 1.0),
-  "linear":      BezierEasing.linear = BezierEasing(0.00, 0.0, 1.00, 1.0),
-  "ease-in":     BezierEasing.easeIn = BezierEasing(0.42, 0.0, 1.00, 1.0),
-  "ease-out":    BezierEasing.easeOut = BezierEasing(0.00, 0.0, 0.58, 1.0),
-  "ease-in-out": BezierEasing.easeInOut = BezierEasing(0.42, 0.0, 0.58, 1.0)
-};
-```
-
-There is also a `toCSS()` method that returns the transition-timing-function value string (so the library is agnostic).
+with BezierEasing, you can define it using `BezierEasing(0.42, 0, 0.58, 1)` which have the `` function taking an X and computing the Y interpolated easing value (see schema).
 
 License
 -------

README.md

@@ -5,18 +5,18 @@ var suite = new Benchmark.Suite();
 
 var random = Math.random;
 
-var bezier = BezierEasing([ 0.2, 0.3, 1.0, 0.5 ]);
+var bezier = BezierEasing(0.2, 0.3, 1.0, 0.5);
 
 suite
 .add('BezierEasing: instanciation', function() {
-  BezierEasing([ random(), random(), random(), random() ]);
+  BezierEasing(random(), random(), random(), random());
 })
 .add('BezierEasing: call', function() {
-  bezier.get(random());
+  bezier(random());
 })
 .add('BezierEasing: instanciation + call', function() {
-  var bezier = BezierEasing([ random(), random(), random(), random() ]);
-  bezier.get(random());
+  var bezier = BezierEasing(random(), random(), random(), random());
+  bezier(random());
 })
 // add listeners
 .on('cycle', function(event) {

benchmark.js

@@ -2,11 +2,7 @@
  * BezierEasing - use bezier curve for transition easing function
  * by Gaëtan Renaudeau 2014 - 2015 – MIT License
  *
- * Credits: is based on Firefox's nsSMILKeySpline.cpp
- * Usage:
- * var spline = BezierEasing([ 0.25, 0.1, 0.25, 1.0 ])
- * spline.get(x) => returns the easing value | x must be in [0, 1] range
- *
+ * @providesModule bezier
  */
 
 // These values are established by empiricism with tests (tradeoff: performance VS precision)
@@ -18,21 +14,17 @@ var SUBDIVISION_MAX_ITERATIONS = 10;
 var kSplineTableSize = 11;
 var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
 
-var float32ArraySupported = typeof Float32Array === "function";
+var float32ArraySupported = typeof Float32Array === 'function';
 
 function A (aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; }
 function B (aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1; }
 function C (aA1)      { return 3.0 * aA1; }
 
 // Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
-function calcBezier (aT, aA1, aA2) {
-  return ((A(aA1, aA2)*aT + B(aA1, aA2))*aT + C(aA1))*aT;
-}
+function calcBezier (aT, aA1, aA2) { return((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT; }
 
 // Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
-function getSlope (aT, aA1, aA2) {
-  return 3.0 * A(aA1, aA2)*aT*aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
-}
+function getSlope (aT, aA1, aA2) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1); }
 
 function binarySubdivide (aX, aA, aB, mX1, mX2) {
   var currentX, currentT, i = 0;
@@ -49,111 +41,42 @@ function binarySubdivide (aX, aA, aB, mX1, mX2) {
 }
 
 function newtonRaphsonIterate (aX, aGuessT, mX1, mX2) {
-  for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
-    var currentSlope = getSlope(aGuessT, mX1, mX2);
-    if (currentSlope === 0.0) return aGuessT;
-    var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
-    aGuessT -= currentX / currentSlope;
-  }
-  return aGuessT;
+ for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
+   var currentSlope = getSlope(aGuessT, mX1, mX2);
+   if (currentSlope === 0.0) {
+     return aGuessT;
+   }
+   var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
+   aGuessT -= currentX / currentSlope;
+ }
+ return aGuessT;
 }
 
-/**
- * points is an array of [ mX1, mY1, mX2, mY2 ]
- */
-function BezierEasing (points, b, c, d) {
-  if (arguments.length === 4) {
-    return new BezierEasing([ points, b, c, d ]);
-  }
-  if (!(this instanceof BezierEasing)) return new BezierEasing(points);
-
-  if (!points || points.length !== 4) {
-    throw new Error("BezierEasing: points must contains 4 values");
+module.exports = function bezier (mX1, mY1, mX2, mY2) {
+  if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) {
+    throw new Error('bezier x values must be in [0, 1] range');
   }
-  for (var i=0; i<4; ++i) {
-    if (typeof points[i] !== "number" || isNaN(points[i]) || !isFinite(points[i])) {
-      throw new Error("BezierEasing: points should be integers.");
-    }
-  }
-  if (points[0] < 0 || points[0] > 1 || points[2] < 0 || points[2] > 1) {
-    throw new Error("BezierEasing x values must be in [0, 1] range.");
-  }
-
-  this._str = "BezierEasing("+points+")";
-  this._css = "cubic-bezier("+points+")";
-  this._p = points;
-  this._mSampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
-  this._precomputed = false;
-
-  this.get = this.get.bind(this);
-}
-
-BezierEasing.prototype = {
 
-  get: function (x) {
-    var mX1 = this._p[0],
-      mY1 = this._p[1],
-      mX2 = this._p[2],
-      mY2 = this._p[3];
-    if (!this._precomputed) this._precompute();
-    if (mX1 === mY1 && mX2 === mY2) return x; // linear
-    // Because JavaScript number are imprecise, we should guarantee the extremes are right.
-    if (x === 0) return 0;
-    if (x === 1) return 1;
-    return calcBezier(this._getTForX(x), mY1, mY2);
-  },
-
-  getPoints: function() {
-    return this._p;
-  },
-
-  toString: function () {
-    return this._str;
-  },
-
-  toCSS: function () {
-    return this._css;
-  },
-
-  // Private part
-
-  _precompute: function () {
-    var mX1 = this._p[0],
-      mY1 = this._p[1],
-      mX2 = this._p[2],
-      mY2 = this._p[3];
-    this._precomputed = true;
-    if (mX1 !== mY1 || mX2 !== mY2)
-      this._calcSampleValues();
-  },
-
-  _calcSampleValues: function () {
-    var mX1 = this._p[0],
-      mX2 = this._p[2];
+  // Precompute samples table
+  var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
+  if (mX1 !== mY1 || mX2 !== mY2) {
     for (var i = 0; i < kSplineTableSize; ++i) {
-      this._mSampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
+      sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
     }
-  },
-
-  /**
-   * getTForX chose the fastest heuristic to determine the percentage value precisely from a given X projection.
-   */
-  _getTForX: function (aX) {
-    var mX1 = this._p[0],
-      mX2 = this._p[2],
-      mSampleValues = this._mSampleValues;
+  }
 
+  function getTForX (aX) {
     var intervalStart = 0.0;
     var currentSample = 1;
     var lastSample = kSplineTableSize - 1;
 
-    for (; currentSample !== lastSample && mSampleValues[currentSample] <= aX; ++currentSample) {
+    for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
       intervalStart += kSampleStepSize;
     }
     --currentSample;
 
     // Interpolate to provide an initial guess for t
-    var dist = (aX - mSampleValues[currentSample]) / (mSampleValues[currentSample+1] - mSampleValues[currentSample]);
+    var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
     var guessForT = intervalStart + dist * kSampleStepSize;
 
     var initialSlope = getSlope(guessForT, mX1, mX2);
@@ -165,15 +88,18 @@ BezierEasing.prototype = {
       return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
     }
   }
-};
 
-// CSS mapping
-BezierEasing.css = {
-  "ease":        BezierEasing.ease      = BezierEasing(0.25, 0.1, 0.25, 1.0),
-  "linear":      BezierEasing.linear    = BezierEasing(0.00, 0.0, 1.00, 1.0),
-  "ease-in":     BezierEasing.easeIn    = BezierEasing(0.42, 0.0, 1.00, 1.0),
-  "ease-out":    BezierEasing.easeOut   = BezierEasing(0.00, 0.0, 0.58, 1.0),
-  "ease-in-out": BezierEasing.easeInOut = BezierEasing(0.42, 0.0, 0.58, 1.0)
+  return function (x) {
+    if (mX1 === mY1 && mX2 === mY2) {
+      return x; // linear
+    }
+    // Because JavaScript number are imprecise, we should guarantee the extremes are right.
+    if (x === 0) {
+      return 0;
+    }
+    if (x === 1) {
+      return 1;
+    }
+    return calcBezier(getTForX(x), mY1, mY2);
+  };
 };
-
-module.exports = BezierEasing;

bower.json

@@ -21,12 +21,12 @@
     "build": "browserify --standalone BezierEasing index.js | uglifyjs -cm > build.js"
   },
   "devDependencies": {
-    "assert": "1.0.x",
-    "benchmark": "^1.0.0",
-    "browserify": "^10.2.4",
-    "budo": "^4.0.0",
-    "mocha": "1.16.x",
-    "uglify-js": "^2.4.23"
+    "assert": "^1.3.0",
+    "benchmark": "^2.1.0",
+    "browserify": "^13.0.0",
+    "budo": "^8.1.0",
+    "mocha": "^2.4.5",
+    "uglify-js": "^2.6.2"
   },
   "repository": {
     "type": "git",