index: rewrite to use underscore.js' implementation

It's a lot more robust.

index.js

@@ -1,32 +1,53 @@
+
+/**
+ * Module dependencies.
+ */
+
+var now = require('date-now');
+
 /**
- * Debounces a function by the given threshold.
+ * Returns a function, that, as long as it continues to be invoked, will not
+ * be triggered. The function will be called after it stops being called for
+ * N milliseconds. If `immediate` is passed, trigger the function on the
+ * leading edge, instead of the trailing.
  *
+ * @source underscore.js
  * @see http:https://unscriptable.com/2009/03/20/debouncing-javascript-methods/
  * @param {Function} function to wrap
  * @param {Number} timeout in ms (`100`)
  * @param {Boolean} whether to execute at the beginning (`false`)
  * @api public
  */
 
-module.exports = function debounce(func, threshold, execAsap){
- var timeout;
+module.exports = function debounce(func, wait, immediate){
+ var timeout, args, context, timestamp, result;
+ if (null == wait) wait = 100;
 
- return function debounced(){
- var obj = this, args = arguments;
+ function later() {
+ var last = now() - timestamp;
 
- function delayed () {
- if (!execAsap) {
- func.apply(obj, args);
- }
+ if (last < wait && last > 0) {
+ timeout = setTimeout(later, wait - last);
+ } else {
  timeout = null;
+ if (!immediate) {
+ result = func.apply(context, args);
+ if (!timeout) context = args = null;
+ }
  }
+ };
 
- if (timeout) {
- clearTimeout(timeout);
- } else if (execAsap) {
- func.apply(obj, args);
+ return function debounced() {
+ context = this;
+ args = arguments;
+ timestamp = now();
+ var callNow = immediate && !timeout;
+ if (!timeout) timeout = setTimeout(later, wait);
+ if (callNow) {
+ result = func.apply(context, args);
+ context = args = null;
  }
 
- timeout = setTimeout(delayed, threshold || 100);
+ return result;
  };
 };