ruby-wisp-source 0.7.0

data/vendor/node_modules/browserify/node_modules/syntax-error/node_modules/esprima/test/3rdparty/benchmark.js

@@ -0,0 +1,3261 @@
+/*!
+ * Benchmark.js <http://benchmarkjs.com/>
+ * Copyright 2010-2011 Mathias Bynens <http://mths.be/>
+ * Based on JSLitmus.js, copyright Robert Kieffer <http://broofa.com/>
+ * Modified by John-David Dalton <http://allyoucanleet.com/>
+ * Available under MIT license <http://mths.be/mit>
+ */
+;(function(window, undefined) {
+
+  /** Detect free variable `define` */
+  var freeDefine = typeof define == 'function' &&
+    typeof define.amd == 'object' && define.amd && define,
+
+  /** Detect free variable `exports` */
+  freeExports = typeof exports == 'object' && exports &&
+    (typeof global == 'object' && global && global == global.global && (window = global), exports),
+
+  /** Detect free variable `require` */
+  freeRequire = typeof require == 'function' && require,
+
+  /** Used to assign each benchmark an incrimented id */
+  counter = 0,
+
+  /** Used to crawl all properties regardless of enumerability */
+  getAllKeys = Object.getOwnPropertyNames,
+
+  /** Used to get property descriptors */
+  getDescriptor = Object.getOwnPropertyDescriptor,
+
+  /** Used in case an object doesn't have its own method */
+  hasOwnProperty = {}.hasOwnProperty,
+
+  /** Used to check if an object is extensible */
+  isExtensible = Object.isExtensible || function() { return true; },
+
+  /** Used to check if an own property is enumerable */
+  propertyIsEnumerable = {}.propertyIsEnumerable,
+
+  /** Used to set property descriptors */
+  setDescriptor = Object.defineProperty,
+
+  /** Used to resolve a value's internal [[Class]] */
+  toString = {}.toString,
+
+  /** Used to integrity check compiled tests */
+  uid = 'uid' + (+new Date),
+
+  /** Used to avoid infinite recursion when methods call each other */
+  calledBy = {},
+
+  /** Used to avoid hz of Infinity */
+  divisors = {
+    '1': 4096,
+    '2': 512,
+    '3': 64,
+    '4': 8,
+    '5': 0
+  },
+
+  /**
+   * T-Distribution two-tailed critical values for 95% confidence
+   * http://www.itl.nist.gov/div898/handbook/eda/section3/eda3672.htm
+   */
+  distribution = {
+    '1':  12.706,'2':  4.303, '3':  3.182, '4':  2.776, '5':  2.571, '6':  2.447,
+    '7':  2.365, '8':  2.306, '9':  2.262, '10': 2.228, '11': 2.201, '12': 2.179,
+    '13': 2.16,  '14': 2.145, '15': 2.131, '16': 2.12,  '17': 2.11,  '18': 2.101,
+    '19': 2.093, '20': 2.086, '21': 2.08,  '22': 2.074, '23': 2.069, '24': 2.064,
+    '25': 2.06,  '26': 2.056, '27': 2.052, '28': 2.048, '29': 2.045, '30': 2.042,
+    'infinity': 1.96
+  },
+
+  /** Used to flag environments/features */
+  has = {
+
+    /** Detect Adobe AIR */
+    'air': isClassOf(window.runtime, 'ScriptBridgingProxyObject'),
+
+    /** Detect if `arguments` objects have the correct internal [[Class]] value */
+    'argumentsClass': isClassOf(arguments, 'Arguments'),
+
+    /** Detect if strings support accessing characters by index */
+    'charByIndex':
+      // IE8 supports indexes on string literals but not string objects
+      Object('x')[0] == 'x',
+
+    /** Detect if strings have indexes as own properties */
+    'charByOwnIndex':
+      // Narwhal, Rhino, RingoJS, and Opera < 10.52 support indexes on strings
+      // but don't detect them as own properties
+      hasKey('x', '0'),
+
+    /** Detect if functions support decompilation */
+    'decompilation': !!(function() {
+      try{
+        // Safari 2.x removes commas in object literals
+        // from Function#toString results
+        // http://webk.it/11609
+        // Firefox 3.6 and Opera 9.25 strip grouping
+        // parentheses from Function#toString results
+        // http://bugzil.la/559438
+        return Function(
+          'return (' + (function(x) { return { 'x': '' + (1 + x) + '', 'y': 0 }; }) + ')'
+        )()(0).x === '1';
+      } catch(e) { }
+    }()),
+
+    /** Detect ES5+ property descriptor API */
+    'descriptors' : !!(function() {
+      try {
+        var o = {};
+        return (setDescriptor(o, o, o), 'value' in getDescriptor(o, o));
+      } catch(e) { }
+    }()),
+
+    /** Detect ES5+ Object.getOwnPropertyNames() */
+    'getAllKeys': !!(function() {
+      try {
+        return /\bvalueOf\b/.test(getAllKeys(Object.prototype));
+      } catch(e) { }
+    }()),
+
+    /** Detect if Java is enabled/exposed */
+    'java': isClassOf(window.java, 'JavaPackage'),
+
+    /** Detect if the Timers API exists */
+    'timeout': isHostType(window, 'setTimeout') && isHostType(window, 'clearTimeout')
+  },
+
+  /**
+   * Timer utility object used by `clock()` and `Deferred#resolve`.
+   * @private
+   * @type Object
+   */
+  timer = {
+
+   /**
+    * The timer namespace object or constructor.
+    * @private
+    * @memberOf timer
+    * @type Function|Object
+    */
+    'ns': Date,
+
+   /**
+    * Starts the deferred timer.
+    * @private
+    * @memberOf timer
+    * @param {Object} deferred The deferred instance.
+    */
+    'start': null, // lazy defined in `clock()`
+
+   /**
+    * Stops the deferred timer.
+    * @private
+    * @memberOf timer
+    * @param {Object} deferred The deferred instance.
+    */
+    'stop': null // lazy defined in `clock()`
+  },
+
+  /** Shortcut for inverse results */
+  noArgumentsClass = !has.argumentsClass,
+  noCharByIndex = !has.charByIndex,
+  noCharByOwnIndex = !has.charByOwnIndex,
+
+  /** Math shortcuts */
+  abs   = Math.abs,
+  floor = Math.floor,
+  max   = Math.max,
+  min   = Math.min,
+  pow   = Math.pow,
+  sqrt  = Math.sqrt;
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Benchmark constructor.
+   * @constructor
+   * @param {String} name A name to identify the benchmark.
+   * @param {Function|String} fn The test to benchmark.
+   * @param {Object} [options={}] Options object.
+   * @example
+   *
+   * // basic usage (the `new` operator is optional)
+   * var bench = new Benchmark(fn);
+   *
+   * // or using a name first
+   * var bench = new Benchmark('foo', fn);
+   *
+   * // or with options
+   * var bench = new Benchmark('foo', fn, {
+   *
+   *   // displayed by Benchmark#toString if `name` is not available
+   *   'id': 'xyz',
+   *
+   *   // called when the benchmark starts running
+   *   'onStart': onStart,
+   *
+   *   // called after each run cycle
+   *   'onCycle': onCycle,
+   *
+   *   // called when aborted
+   *   'onAbort': onAbort,
+   *
+   *   // called when a test errors
+   *   'onError': onError,
+   *
+   *   // called when reset
+   *   'onReset': onReset,
+   *
+   *   // called when the benchmark completes running
+   *   'onComplete': onComplete,
+   *
+   *   // compiled/called before the test loop
+   *   'setup': setup,
+   *
+   *   // compiled/called after the test loop
+   *   'teardown': teardown
+   * });
+   *
+   * // or name and options
+   * var bench = new Benchmark('foo', {
+   *
+   *   // a flag to indicate the benchmark is deferred
+   *   'deferred': true,
+   *
+   *   // benchmark test function
+   *   'fn': function(deferred) {
+   *     // call resolve() when the deferred test is finished
+   *     deferred.resolve();
+   *   }
+   * });
+   *
+   * // or options only
+   * var bench = new Benchmark({
+   *
+   *   // benchmark name
+   *   'name': 'foo',
+   *
+   *   // benchmark test as a string
+   *   'fn': '[1,2,3,4].sort()'
+   * });
+   *
+   * // a test's `this` binding is set to the benchmark instance
+   * var bench = new Benchmark('foo', function() {
+   *   'My name is '.concat(this.name); // My name is foo
+   * });
+   */
+  function Benchmark(name, fn, options) {
+    var me = this;
+
+    // allow instance creation without the `new` operator
+    if (me && me.constructor != Benchmark) {
+      return new Benchmark(name, fn, options);
+    }
+    // juggle arguments
+    if (isClassOf(name, 'Object')) {
+      // 1 argument (options)
+      options = name;
+    }
+    else if (isClassOf(name, 'Function')) {
+      // 2 arguments (fn, options)
+      options = fn;
+      fn = name;
+    }
+    else if (isClassOf(fn, 'Object')) {
+      // 2 arguments (name, options)
+      options = fn;
+      fn = null;
+      me.name = name;
+    }
+    else {
+      // 3 arguments (name, fn [, options])
+      me.name = name;
+    }
+    setOptions(me, options);
+    me.id || (me.id = ++counter);
+    me.fn == null && (me.fn = fn);
+    me.stats = extend({}, me.stats);
+    me.times = extend({}, me.times);
+  }
+
+  /**
+   * Deferred constructor.
+   * @constructor
+   * @memberOf Benchmark
+   * @param {Object} bench The benchmark instance.
+   */
+  function Deferred(bench) {
+    var me = this;
+    if (me && me.constructor != Deferred) {
+      return new Deferred(bench);
+    }
+    me.benchmark = bench;
+    clock(me);
+  }
+
+  /**
+   * Event constructor.
+   * @constructor
+   * @memberOf Benchmark
+   * @param {String|Object} type The event type.
+   */
+  function Event(type) {
+    var me = this;
+    return (me && me.constructor != Event)
+      ? new Event(type)
+      : (type instanceof Event)
+          ? type
+          : extend(me, typeof type == 'string' ? { 'type': type } : type);
+  }
+
+  /**
+   * Suite constructor.
+   * @constructor
+   * @memberOf Benchmark
+   * @param {String} name A name to identify the suite.
+   * @param {Object} [options={}] Options object.
+   * @example
+   *
+   * // basic usage (the `new` operator is optional)
+   * var suite = new Benchmark.Suite;
+   *
+   * // or using a name first
+   * var suite = new Benchmark.Suite('foo');
+   *
+   * // or with options
+   * var suite = new Benchmark.Suite('foo', {
+   *
+   *   // called when the suite starts running
+   *   'onStart': onStart,
+   *
+   *   // called between running benchmarks
+   *   'onCycle': onCycle,
+   *
+   *   // called when aborted
+   *   'onAbort': onAbort,
+   *
+   *   // called when a test errors
+   *   'onError': onError,
+   *
+   *   // called when reset
+   *   'onReset': onReset,
+   *
+   *   // called when the suite completes running
+   *   'onComplete': onComplete
+   * });
+   */
+  function Suite(name, options) {
+    var me = this;
+
+    // allow instance creation without the `new` operator
+    if (me && me.constructor != Suite) {
+      return new Suite(name, options);
+    }
+    // juggle arguments
+    if (isClassOf(name, 'Object')) {
+      // 1 argument (options)
+      options = name;
+    } else {
+      // 2 arguments (name [, options])
+      me.name = name;
+    }
+    setOptions(me, options);
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Note: Some array methods have been implemented in plain JavaScript to avoid
+   * bugs in IE, Opera, Rhino, and Mobile Safari.
+   *
+   * IE compatibility mode and IE < 9 have buggy Array `shift()` and `splice()`
+   * functions that fail to remove the last element, `object[0]`, of
+   * array-like-objects even though the `length` property is set to `0`.
+   * The `shift()` method is buggy in IE 8 compatibility mode, while `splice()`
+   * is buggy regardless of mode in IE < 9 and buggy in compatibility mode in IE 9.
+   *
+   * In Opera < 9.50 and some older/beta Mobile Safari versions using `unshift()`
+   * generically to augment the `arguments` object will pave the value at index 0
+   * without incrimenting the other values's indexes.
+   * https://github.com/documentcloud/underscore/issues/9
+   *
+   * Rhino and environments it powers, like Narwhal and RingoJS, may have
+   * buggy Array `concat()`, `reverse()`, `shift()`, `slice()`, `splice()` and
+   * `unshift()` functions that make sparse arrays non-sparse by assigning the
+   * undefined indexes a value of undefined.
+   * https://github.com/mozilla/rhino/commit/702abfed3f8ca043b2636efd31c14ba7552603dd
+   */
+
+  /**
+   * Creates an array containing the elements of the host array followed by the
+   * elements of each argument in order.
+   * @memberOf Benchmark.Suite
+   * @returns {Array} The new array.
+   */
+  function concat() {
+    var value,
+        j = -1,
+        length = arguments.length,
+        result = slice.call(this),
+        index = result.length;
+
+    while (++j < length) {
+      value = arguments[j];
+      if (isClassOf(value, 'Array')) {
+        for (var k = 0, l = value.length; k < l; k++, index++) {
+          if (k in value) {
+            result[index] = value[k];
+          }
+        }
+      } else {
+        result[index] = value;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Utility function used by `shift()`, `splice()`, and `unshift()`.
+   * @private
+   * @param {Number} start The index to start inserting elements.
+   * @param {Number} deleteCount The number of elements to delete from the insert point.
+   * @param {Array} elements The elements to insert.
+   * @returns {Array} An array of deleted elements.
+   */
+  function insert(start, deleteCount, elements) {
+    var deleteEnd = start + deleteCount,
+        elementCount = elements ? elements.length : 0,
+        index = start - 1,
+        length = start + elementCount,
+        object = this,
+        result = [],
+        tail = slice.call(object, deleteEnd);
+
+    // delete elements from the array
+    while (++index < deleteEnd) {
+      if (index in object) {
+        result[index - start] = object[index];
+        delete object[index];
+      }
+    }
+    // insert elements
+    index = start - 1;
+    while (++index < length) {
+      object[index] = elements[index - start];
+    }
+    // append tail elements
+    start = index--;
+    length = (object.length >>> 0) - deleteCount + elementCount;
+    while (++index < length) {
+      if ((index - start) in tail) {
+        object[index] = tail[index - start];
+      } else {
+        delete object[index];
+      }
+    }
+    // delete excess elements
+    deleteCount = deleteCount > elementCount ? deleteCount - elementCount : 0;
+    while (deleteCount--) {
+      delete object[length + deleteCount];
+    }
+    object.length = length;
+    return result;
+  }
+
+  /**
+   * Rearrange the host array's elements in reverse order.
+   * @memberOf Benchmark.Suite
+   * @returns {Array} The reversed array.
+   */
+  function reverse() {
+    var upperIndex,
+        value,
+        index = -1,
+        object = Object(this),
+        length = object.length >>> 0,
+        middle = floor(length / 2);
+
+    if (length > 1) {
+      while (++index < middle) {
+        upperIndex = length - index - 1;
+        value = upperIndex in object ? object[upperIndex] : uid;
+        if (index in object) {
+          object[upperIndex] = object[index];
+        } else {
+          delete object[upperIndex];
+        }
+        if (value != uid) {
+          object[index] = value;
+        } else {
+          delete object[index];
+        }
+      }
+    }
+    return object;
+  }
+
+  /**
+   * Removes the first element of the host array and returns it.
+   * @memberOf Benchmark.Suite
+   * @returns {Mixed} The first element of the array.
+   */
+  function shift() {
+    return insert.call(this, 0, 1)[0];
+  }
+
+  /**
+   * Creates an array of the host array's elements from the start index up to,
+   * but not including, the end index.
+   * @memberOf Benchmark.Suite
+   * @returns {Array} The new array.
+   */
+  function slice(start, end) {
+    var index = -1,
+        object = Object(this),
+        length = object.length >>> 0,
+        result = [];
+
+    start = toInteger(start);
+    start = start < 0 ? max(length + start, 0) : min(start, length);
+    start--;
+    end = end == null ? length : toInteger(end);
+    end = end < 0 ? max(length + end, 0) : min(end, length);
+
+    while ((++index, ++start) < end) {
+      if (start in object) {
+        result[index] = object[start];
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Allows removing a range of elements and/or inserting elements into the host array.
+   * @memberOf Benchmark.Suite
+   * @returns {Array} An array of removed elements.
+   */
+  function splice(start, deleteCount) {
+    var object = Object(this),
+        length = object.length >>> 0;
+
+    start = toInteger(start);
+    start = start < 0 ? max(length + start, 0) : min(start, length);
+    deleteCount = min(max(toInteger(deleteCount), 0), length - start);
+    return insert.call(object, start, deleteCount, slice.call(arguments, 2));
+  }
+
+  /**
+   * Converts the specified `value` to an integer.
+   * @private
+   * @param {Mixed} value The value to convert.
+   * @returns {Number} The resulting integer.
+   */
+  function toInteger(value) {
+    value = +value;
+    return value === 0 || !isFinite(value) ? value || 0 : value - (value % 1);
+  }
+
+  /**
+   * Appends arguments to the host array.
+   * @memberOf Benchmark.Suite
+   * @returns {Number} The new length.
+   */
+  function unshift() {
+    var object = Object(this);
+    insert.call(object, 0, 0, arguments);
+    return object.length;
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Executes a function, associated with a benchmark, synchronously or asynchronously.
+   * @private
+   * @param {Object} options The options object.
+   */
+  function call(options) {
+    options || (options = {});
+    var fn = options.fn;
+
+    (!options.async && fn || function() {
+      var bench = options.benchmark,
+          ids = bench._timerIds || (bench._timerIds = []),
+          index = ids.length;
+
+      // under normal use there should only be one id at any time per benchmark
+      ids.push(setTimeout(function() {
+        ids.splice(index, 1);
+        ids.length || delete bench._timerIds;
+        fn();
+      }, bench.delay * 1e3));
+    })();
+  }
+
+  /**
+   * Creates a function from the given arguments string and body.
+   * @private
+   * @param {String} args The comma separated function arguments.
+   * @param {String} body The function body.
+   * @returns {Function} The new function.
+   */
+  function createFunction() {
+    // lazy defined to fork based on supported features
+    createFunction = function(args, body) {
+      var anchor = freeDefine ? define.amd : Benchmark,
+          prop = uid + 'createFunction';
+
+      runScript((freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '=function(' + args + '){' + body + '}');
+      return [anchor[prop], delete anchor[prop]][0];
+    };
+    // fix JaegerMonkey bug
+    // http://bugzil.la/639720
+    createFunction = (createFunction('', 'return"' + uid + '"') || noop)() == uid ? createFunction : Function;
+    return createFunction.apply(null, arguments);
+  }
+
+  /**
+   * Iterates over an object's properties, executing the `callback` for each.
+   * Callbacks may terminate the loop by explicitly returning `false`.
+   * @private
+   * @param {Object} object The object to iterate over.
+   * @param {Function} callback The function executed per own property.
+   * @param {Object} options The options object.
+   * @returns {Object} Returns the object iterated over.
+   */
+  function forProps() {
+    var forShadowed,
+        skipSeen,
+        forArgs = true,
+        shadowed = ['constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf'];
+
+    (function(enumFlag, key) {
+      // must use a non-native constructor to catch the Safari 2 issue
+      function Klass() { this.valueOf = 0; };
+      Klass.prototype.valueOf = 0;
+      // check various for..in bugs
+      for (key in new Klass) {
+        enumFlag += key == 'valueOf' ? 1 : 0;
+      }
+      // check if `arguments` objects have non-enumerable indexes
+      for (key in arguments) {
+        key == '0' && (forArgs = false);
+      }
+      // Safari 2 iterates over shadowed properties twice
+      // http://replay.waybackmachine.org/20090428222941/http://tobielangel.com/2007/1/29/for-in-loop-broken-in-safari/
+      skipSeen = enumFlag == 2;
+      // IE < 9 incorrectly makes an object's properties non-enumerable if they have
+      // the same name as other non-enumerable properties in its prototype chain.
+      forShadowed = !enumFlag;
+    }(0));
+
+    // lazy define
+    forProps = function(object, callback, options) {
+      options || (options = {});
+
+      var ctor,
+          key,
+          keys,
+          skipCtor,
+          done = !object,
+          result = [object, object = Object(object)][0],
+          which = options.which,
+          allFlag = which == 'all',
+          fn = callback,
+          index = -1,
+          iteratee = object,
+          length = object.length,
+          ownFlag = allFlag || which == 'own',
+          seen = {},
+          skipProto = isClassOf(object, 'Function'),
+          thisArg = options.bind;
+
+      object = Object(object);
+
+      if (thisArg !== undefined) {
+        callback = function(value, key, object) {
+          return fn.call(thisArg, value, key, object);
+        };
+      }
+      // iterate all properties
+      if (allFlag && has.getAllKeys) {
+        for (index = 0, keys = getAllKeys(object), length = keys.length; index < length; index++) {
+          key = keys[index];
+          if (callback(object[key], key, object) === false) {
+            break;
+          }
+        }
+      }
+      // else iterate only enumerable properties
+      else {
+        for (key in object) {
+          // Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1
+          // (if the prototype or a property on the prototype has been set)
+          // incorrectly set a function's `prototype` property [[Enumerable]] value
+          // to `true`. Because of this we standardize on skipping the `prototype`
+          // property of functions regardless of their [[Enumerable]] value.
+          if ((done =
+              !(skipProto && key == 'prototype') &&
+              !(skipSeen && (hasKey(seen, key) || !(seen[key] = true))) &&
+              (!ownFlag || ownFlag && hasKey(object, key)) &&
+              callback(object[key], key, object) === false)) {
+            break;
+          }
+        }
+        // in IE < 9 strings don't support accessing characters by index
+        if (!done && (
+            forArgs && isArguments(object) ||
+            (noCharByIndex || noCharByOwnIndex) && isClassOf(object, 'String'))) {
+          noCharByIndex && (iteratee = object.split(''));
+          while (++index < length) {
+            if ((done =
+                callback(iteratee[index], String(index), object) === false)) {
+              break;
+            }
+          }
+        }
+        if (!done && forShadowed) {
+          // Because IE < 9 can't set the `[[Enumerable]]` attribute of an existing
+          // property and the `constructor` property of a prototype defaults to
+          // non-enumerable, we manually skip the `constructor` property when we
+          // think we are iterating over a `prototype` object.
+          ctor = object.constructor;
+          skipCtor = ctor && ctor.prototype && ctor.prototype.constructor === ctor;
+          for (index = 0; index < 7; index++) {
+            key = shadowed[index];
+            if (!(skipCtor && key == 'constructor') &&
+                hasKey(object, key) &&
+                callback(object[key], key, object) === false) {
+              break;
+            }
+          }
+        }
+      }
+      return result;
+    };
+    return forProps.apply(null, arguments);
+  }
+
+  /**
+   * Gets the critical value for the specified degrees of freedom.
+   * @private
+   * @param {Number} df The degrees of freedom.
+   * @returns {Number} The critical value.
+   */
+  function getCriticalValue(df) {
+    return distribution[Math.round(df) || 1] || distribution.infinity;
+  }
+
+  /**
+   * Gets the name of the first argument from a function's source.
+   * @private
+   * @param {Function} fn The function.
+   * @param {String} altName A string used when the name of the first argument is unretrievable.
+   * @returns {String} The argument name.
+   */
+  function getFirstArgument(fn, altName) {
+    return (!hasKey(fn, 'toString') &&
+      (/^[\s(]*function[^(]*\(([^\s,)]+)/.exec(fn) || 0)[1]) || altName || '';
+  }
+
+  /**
+   * Computes the arithmetic mean of a sample.
+   * @private
+   * @param {Array} sample The sample.
+   * @returns {Number} The mean.
+   */
+  function getMean(sample) {
+    return reduce(sample, function(sum, x) {
+      return sum + x;
+    }, 0) / sample.length || 0;
+  }
+
+  /**
+   * Gets the source code of a function.
+   * @private
+   * @param {Function} fn The function.
+   * @param {String} altSource A string used when a function's source code is unretrievable.
+   * @returns {String} The function's source code.
+   */
+  function getSource(fn, altSource) {
+    var result = altSource;
+    if (isStringable(fn)) {
+      result = String(fn);
+    } else if (has.decompilation) {
+      result = (/^[^{]+{([\s\S]*)}\s*$/.exec(fn) || 0)[1];
+    }
+    return (result || '').replace(/^\s+|\s+$/g, '');
+  }
+
+  /**
+   * Modify a string by replacing named tokens with matching object property values.
+   * @private
+   * @param {String} string The string to modify.
+   * @param {Object} object The template object.
+   * @returns {String} The modified string.
+   */
+  function interpolate(string, object) {
+    forOwn(object, function(value, key) {
+      string = string.replace(RegExp('#\\{' + key + '\\}', 'g'), value);
+    });
+    return string;
+  }
+
+  /**
+   * Checks if a value is an `arguments` object.
+   * @private
+   * @param {Mixed} value The value to check.
+   * @returns {Boolean} Returns `true` if the value is an `arguments` object, else `false`.
+   */
+  function isArguments() {
+    // lazy define
+    isArguments = function(value) {
+      return toString.call(value) == '[object Arguments]';
+    };
+    if (noArgumentsClass) {
+      isArguments = function(value) {
+        return hasKey(value, 'callee') &&
+          !(propertyIsEnumerable && propertyIsEnumerable.call(value, 'callee'));
+      };
+    }
+    return isArguments(arguments[0]);
+  }
+
+  /**
+   * Checks if an object is of the specified class.
+   * @private
+   * @param {Mixed} value The value to check.
+   * @param {String} name The name of the class.
+   * @returns {Boolean} Returns `true` if the value is of the specified class, else `false`.
+   */
+  function isClassOf(value, name) {
+    return value != null && toString.call(value) == '[object ' + name + ']';
+  }
+
+  /**
+   * Host objects can return type values that are different from their actual
+   * data type. The objects we are concerned with usually return non-primitive
+   * types of object, function, or unknown.
+   * @private
+   * @param {Mixed} object The owner of the property.
+   * @param {String} property The property to check.
+   * @returns {Boolean} Returns `true` if the property value is a non-primitive, else `false`.
+   */
+  function isHostType(object, property) {
+    var type = object != null ? typeof object[property] : 'number';
+    return !/^(?:boolean|number|string|undefined)$/.test(type) &&
+      (type == 'object' ? !!object[property] : true);
+  }
+
+  /**
+   * Checks if the specified `value` is an object created by the `Object` constructor.
+   * @private
+   * @param {Mixed} value The value to check.
+   * @returns {Boolean} Returns `true` if `value` is an object, else `false`.
+   */
+  function isObject(value) {
+    var ctor,
+        result = !!value && toString.call(value) == '[object Object]';
+
+    if (result && noArgumentsClass) {
+      // avoid false positives for `arguments` objects in IE < 9
+      result = !isArguments(value);
+    }
+    if (result) {
+      // IE < 9 presents nodes like `Object` objects:
+      // IE < 8 are missing the node's constructor property
+      // IE 8 node constructors are typeof "object"
+      ctor = value.constructor;
+      // check if the constructor is `Object` as `Object instanceof Object` is `true`
+      if ((result = isClassOf(ctor, 'Function') && ctor instanceof ctor)) {
+        // assume objects created by the `Object` constructor have no inherited enumerable properties
+        // (we assume there are no `Object.prototype` extensions)
+        forProps(value, function(subValue, subKey) {
+          result = subKey;
+        });
+        // An object's own properties are iterated before inherited properties.
+        // If the last iterated key belongs to an object's own property then
+        // there are no inherited enumerable properties.
+        result = result === true || hasKey(value, result);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Checks if a value can be safely coerced to a string.
+   * @private
+   * @param {Mixed} value The value to check.
+   * @returns {Boolean} Returns `true` if the value can be coerced, else `false`.
+   */
+  function isStringable(value) {
+    return hasKey(value, 'toString') || isClassOf(value, 'String');
+  }
+
+  /**
+   * Wraps a function and passes `this` to the original function as the first argument.
+   * @private
+   * @param {Function} fn The function to be wrapped.
+   * @returns {Function} The new function.
+   */
+  function methodize(fn) {
+    return function() {
+      var args = [this];
+      args.push.apply(args, arguments);
+      return fn.apply(null, args);
+    };
+  }
+
+  /**
+   * A no-operation function.
+   * @private
+   */
+  function noop() {
+    // no operation performed
+  }
+
+  /**
+   * A wrapper around require() to suppress `module missing` errors.
+   * @private
+   * @param {String} id The module id.
+   * @returns {Mixed} The exported module or `null`.
+   */
+  function req(id) {
+    try {
+      return freeExports && freeRequire(id);
+    } catch(e) { }
+    return null;
+  }
+
+  /**
+   * Runs a snippet of JavaScript via script injection.
+   * @private
+   * @param {String} code The code to run.
+   */
+  function runScript(code) {
+    var parent,
+        script,
+        sibling,
+        anchor = freeDefine ? define.amd : Benchmark,
+        prop = uid + 'runScript',
+        prefix = '(' + (freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '||function(){})();';
+
+    // Non-browser environments, Firefox 2.0.0.2 (executes asynchronously),
+    // and IE < 9 will error here and that's OK.
+    // Script injection is only used to avoid the previously commented JaegerMonkey bug.
+    // We remove the inserted script *before* running the code to avoid differences
+    // in the expected script element count/order of the document.
+    try {
+      sibling = document.getElementsByTagName('script')[0];
+      parent = sibling.parentNode;
+      script = document.createElement('script');
+      anchor[prop] = function() { parent.removeChild(script); };
+      script.appendChild(document.createTextNode(prefix + code));
+      parent.insertBefore(script, sibling);
+    } catch(e) { }
+
+    delete anchor[prop];
+  }
+
+  /**
+   * A helper function for setting options/event handlers.
+   * @private
+   * @param {Object} bench The benchmark instance.
+   * @param {Object} [options={}] Options object.
+   */
+  function setOptions(bench, options) {
+    options = extend({}, bench.constructor.options, options);
+    bench.options = forOwn(options, function(value, key) {
+      if (value != null) {
+        // add event listeners
+        if (/^on[A-Z]/.test(key)) {
+          forEach(key.split(' '), function(key) {
+            bench.on(key.slice(2).toLowerCase(), value);
+          });
+        } else {
+          bench[key] = deepClone(value);
+        }
+      }
+    });
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Handles cycling/completing the deferred benchmark.
+   * @memberOf Benchmark.Deferred
+   */
+  function resolve() {
+    var me = this,
+        bench = me.benchmark;
+
+    if (++me.cycles < bench.count) {
+      (bench._host || bench).compiled.call(me, timer.ns, timer);
+    } else {
+      timer.stop(me);
+      call({
+        'async': true,
+        'benchmark': bench,
+        'fn': function() {
+          cycle({ 'benchmark': bench, 'deferred': me });
+        }
+      });
+    }
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * A deep clone utility.
+   * @static
+   * @memberOf Benchmark
+   * @param {Mixed} value The value to clone.
+   * @returns {Mixed} The cloned value.
+   */
+  function deepClone(value) {
+    var accessor,
+        circular,
+        clone,
+        ctor,
+        data,
+        descriptor,
+        extensible,
+        key,
+        length,
+        markerKey,
+        parent,
+        result,
+        source,
+        subIndex,
+        index = -1,
+        marked = [],
+        unmarked = [],
+        queue = { '0': { 'value': value }, 'length': 1 };
+
+    /**
+     * An easily detectable decorator for cloned values.
+     */
+    function Marker(object) {
+      this.raw = object;
+    }
+
+    /**
+     * Gets an available marker key for the given object.
+     */
+    function getMarkerKey(object) {
+      // avoid collisions with existing keys
+      var result = uid;
+      while (object[result] && object[result].constructor != Marker) {
+        result += 1;
+      }
+      return result;
+    }
+
+    /**
+     * The callback used by `forProps()`.
+     */
+    function propCallback(subValue, subKey) {
+      // exit early to avoid cloning the marker
+      if (subValue && subValue.constructor == Marker) {
+        return;
+      }
+      // add objects to the queue
+      if (subValue === Object(subValue)) {
+        queue[queue.length++] = { 'key': subKey, 'parent': clone, 'source': value };
+      }
+      // assign non-objects
+      else {
+        clone[subKey] = subValue;
+      }
+    }
+
+    while ((data = queue[++index])) {
+      key = data.key;
+      parent = data.parent;
+      source = data.source;
+      clone = value = source ? source[key] : data.value;
+      accessor = circular = descriptor = false;
+      delete queue[index - 1];
+
+      // create a basic clone to filter out functions, DOM elements, and
+      // other non `Object` objects
+      if (value === Object(value)) {
+        ctor = value.constructor;
+        switch (toString.call(value)) {
+          case '[object Array]':
+            clone = new ctor(value.length);
+            break;
+
+          case '[object Boolean]':
+            clone = new ctor(value == true);
+            break;
+
+          case '[object Date]':
+            clone = new ctor(+value);
+            break;
+
+          case '[object Object]':
+            isObject(value) && (clone = new ctor);
+            break;
+
+          case '[object Number]':
+          case '[object String]':
+            clone = new ctor(value);
+            break;
+
+          case '[object RegExp]':
+            clone = ctor(value.source,
+              (value.global     ? 'g' : '') +
+              (value.ignoreCase ? 'i' : '') +
+              (value.multiline  ? 'm' : ''));
+        }
+        // continue clone if `value` doesn't have an accessor descriptor
+        // http://es5.github.com/#x8.10.1
+        if (clone != value &&
+            !(descriptor = source && has.descriptors && getDescriptor(source, key),
+              accessor = descriptor && (descriptor.get || descriptor.set))) {
+          // use an existing clone (circular reference)
+          if ((extensible = isExtensible(value))) {
+            markerKey = getMarkerKey(value);
+            if (value[markerKey]) {
+              circular = clone = value[markerKey].raw;
+            }
+          } else {
+            // for frozen/sealed objects
+            for (subIndex = 0, length = unmarked.length; subIndex < length; subIndex++) {
+              data = unmarked[subIndex];
+              if (data.object === value) {
+                circular = clone = data.clone;
+                break;
+              }
+            }
+          }
+          if (!circular) {
+            // mark object to allow quickly detecting circular references and tie it to its clone
+            if (extensible) {
+              value[markerKey] = new Marker(clone);
+              marked.push({ 'key': markerKey, 'object': value });
+            } else {
+              // for frozen/sealed objects
+              unmarked.push({ 'clone': clone, 'object': value });
+            }
+            // iterate over object properties
+            forProps(value, propCallback, { 'which': 'all' });
+          }
+        }
+      }
+      if (parent) {
+        // for custom property descriptors
+        if (accessor || (descriptor &&
+            !(descriptor.configurable && descriptor.enumerable && descriptor.writable))) {
+          descriptor.value && (descriptor.value = clone);
+          setDescriptor(parent, key, descriptor);
+        }
+        // for default property descriptors
+        else {
+          parent[key] = clone;
+        }
+      } else {
+        result = clone;
+      }
+    }
+    // remove markers
+    for (index = 0, length = marked.length; index < length; index++) {
+      data = marked[index];
+      delete data.object[data.key];
+    }
+    return result;
+  }
+
+  /**
+   * An iteration utility for arrays and objects.
+   * Callbacks may terminate the loop by explicitly returning `false`.
+   * @static
+   * @memberOf Benchmark
+   * @param {Array|Object} object The object to iterate over.
+   * @param {Function} callback The function called per iteration.
+   * @param {Object} thisArg The `this` binding for the callback function.
+   * @returns {Array|Object} Returns the object iterated over.
+   */
+  function each(object, callback, thisArg) {
+    var fn = callback,
+        index = -1,
+        result = [object, object = Object(object)][0],
+        origObject = object,
+        length = object.length,
+        isSnapshot = !!(object.snapshotItem && (length = object.snapshotLength)),
+        isSplittable = (noCharByIndex || noCharByOwnIndex) && isClassOf(object, 'String'),
+        isConvertable = isSnapshot || isSplittable || 'item' in object;
+
+    // in Opera < 10.5 `hasKey(object, 'length')` returns `false` for NodeLists
+    if (length === length >>> 0) {
+      if (isConvertable) {
+        // the third argument of the callback is the original non-array object
+        callback = function(value, index) {
+          return fn.call(this, value, index, origObject);
+        };
+        // in IE < 9 strings don't support accessing characters by index
+        if (isSplittable) {
+          object = object.split('');
+        } else {
+          object = [];
+          while (++index < length) {
+            // in Safari 2 `index in object` is always `false` for NodeLists
+            object[index] = isSnapshot ? result.snapshotItem(index) : result[index];
+          }
+        }
+      }
+      forEach(object, callback, thisArg);
+    } else {
+      forOwn(object, callback, thisArg);
+    }
+    return result;
+  }
+
+  /**
+   * Copies own/inherited properties of a source object to the destination object.
+   * @static
+   * @memberOf Benchmark
+   * @param {Object} destination The destination object.
+   * @param {Object} [source={}] The source object.
+   * @returns {Object} The destination object.
+   */
+  function extend(destination, source) {
+    // Chrome < 14 incorrectly sets `destination` to `undefined` when we `delete arguments[0]`
+    // http://code.google.com/p/v8/issues/detail?id=839
+    destination = [destination, delete arguments[0]][0];
+    forEach(arguments, function(source) {
+      forProps(source, function(value, key) {
+        destination[key] = value;
+      });
+    });
+    return destination;
+  }
+
+  /**
+   * A generic `Array#filter` like method.
+   * @static
+   * @memberOf Benchmark
+   * @param {Array} array The array to iterate over.
+   * @param {Function|String} callback The function/alias called per iteration.
+   * @param {Object} thisArg The `this` binding for the callback function.
+   * @returns {Array} A new array of values that passed callback filter.
+   * @example
+   *
+   * // get odd numbers
+   * Benchmark.filter([1, 2, 3, 4, 5], function(n) {
+   *   return n % 2;
+   * }); // -> [1, 3, 5];
+   *
+   * // get fastest benchmarks
+   * Benchmark.filter(benches, 'fastest');
+   *
+   * // get slowest benchmarks
+   * Benchmark.filter(benches, 'slowest');
+   *
+   * // get benchmarks that completed without erroring
+   * Benchmark.filter(benches, 'successful');
+   */
+  function filter(array, callback, thisArg) {
+    var result;
+
+    if (callback == 'successful') {
+      // callback to exclude errored or unrun benchmarks
+      callback = function(bench) { return bench.cycles; };
+    }
+    else if (callback == 'fastest' || callback == 'slowest') {
+      // get successful, sort by period + margin of error, and filter fastest/slowest
+      result = filter(array, 'successful').sort(function(a, b) {
+        a = a.stats; b = b.stats;
+        return (a.mean + a.moe > b.mean + b.moe ? 1 : -1) * (callback == 'fastest' ? 1 : -1);
+      });
+      result = filter(result, function(bench) {
+        return !result[0].compare(bench);
+      });
+    }
+    return result || reduce(array, function(result, value, index) {
+      return callback.call(thisArg, value, index, array) ? (result.push(value), result) : result;
+    }, []);
+  }
+
+  /**
+   * A generic `Array#forEach` like method.
+   * Callbacks may terminate the loop by explicitly returning `false`.
+   * @static
+   * @memberOf Benchmark
+   * @param {Array} array The array to iterate over.
+   * @param {Function} callback The function called per iteration.
+   * @param {Object} thisArg The `this` binding for the callback function.
+   * @returns {Array} Returns the array iterated over.
+   */
+  function forEach(array, callback, thisArg) {
+    var fn = callback,
+        index = -1,
+        length = (array = Object(array)).length >>> 0;
+
+    if (thisArg !== undefined) {
+      callback = function(value, index, array) {
+        return fn.call(thisArg, value, index, array);
+      };
+    }
+    while (++index < length) {
+      if (index in array &&
+          callback(array[index], index, array) === false) {
+        break;
+      }
+    }
+    return array;
+  }
+
+  /**
+   * Iterates over an object's own properties, executing the `callback` for each.
+   * Callbacks may terminate the loop by explicitly returning `false`.
+   * @static
+   * @memberOf Benchmark
+   * @param {Object} object The object to iterate over.
+   * @param {Function} callback The function executed per own property.
+   * @param {Object} thisArg The `this` binding for the callback function.
+   * @returns {Object} Returns the object iterated over.
+   */
+  function forOwn(object, callback, thisArg) {
+    return forProps(object, callback, { 'bind': thisArg, 'which': 'own' });
+  }
+
+  /**
+   * Converts a number to a more readable comma-separated string representation.
+   * @static
+   * @memberOf Benchmark
+   * @param {Number} number The number to convert.
+   * @returns {String} The more readable string representation.
+   */
+  function formatNumber(number) {
+    number = String(number).split('.');
+    return number[0].replace(/(?=(?:\d{3})+$)(?!\b)/g, ',') +
+      (number[1] ? '.' + number[1] : '');
+  }
+
+  /**
+   * Checks if an object has the specified key as a direct property.
+   * @static
+   * @memberOf Benchmark
+   * @param {Object} object The object to check.
+   * @param {String} key The key to check for.
+   * @returns {Boolean} Returns `true` if key is a direct property, else `false`.
+   */
+  function hasKey() {
+    // lazy define for worst case fallback (not as accurate)
+    hasKey = function(object, key) {
+      var parent = object != null && (object.constructor || Object).prototype;
+      return !!parent && key in Object(object) && !(key in parent && object[key] === parent[key]);
+    };
+    // for modern browsers
+    if (isClassOf(hasOwnProperty, 'Function')) {
+      hasKey = function(object, key) {
+        return object != null && hasOwnProperty.call(object, key);
+      };
+    }
+    // for Safari 2
+    else if ({}.__proto__ == Object.prototype) {
+      hasKey = function(object, key) {
+        var result = false;
+        if (object != null) {
+          object = Object(object);
+          object.__proto__ = [object.__proto__, object.__proto__ = null, result = key in object][0];
+        }
+        return result;
+      };
+    }
+    return hasKey.apply(this, arguments);
+  }
+
+  /**
+   * A generic `Array#indexOf` like method.
+   * @static
+   * @memberOf Benchmark
+   * @param {Array} array The array to iterate over.
+   * @param {Mixed} value The value to search for.
+   * @param {Number} [fromIndex=0] The index to start searching from.
+   * @returns {Number} The index of the matched value or `-1`.
+   */
+  function indexOf(array, value, fromIndex) {
+    var index = toInteger(fromIndex),
+        length = (array = Object(array)).length >>> 0;
+
+    index = (index < 0 ? max(0, length + index) : index) - 1;
+    while (++index < length) {
+      if (index in array && value === array[index]) {
+        return index;
+      }
+    }
+    return -1;
+  }
+
+  /**
+   * Invokes a method on all items in an array.
+   * @static
+   * @memberOf Benchmark
+   * @param {Array} benches Array of benchmarks to iterate over.
+   * @param {String|Object} name The name of the method to invoke OR options object.
+   * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
+   * @returns {Array} A new array of values returned from each method invoked.
+   * @example
+   *
+   * // invoke `reset` on all benchmarks
+   * Benchmark.invoke(benches, 'reset');
+   *
+   * // invoke `emit` with arguments
+   * Benchmark.invoke(benches, 'emit', 'complete', listener);
+   *
+   * // invoke `run(true)`, treat benchmarks as a queue, and register invoke callbacks
+   * Benchmark.invoke(benches, {
+   *
+   *   // invoke the `run` method
+   *   'name': 'run',
+   *
+   *   // pass a single argument
+   *   'args': true,
+   *
+   *   // treat as queue, removing benchmarks from front of `benches` until empty
+   *   'queued': true,
+   *
+   *   // called before any benchmarks have been invoked.
+   *   'onStart': onStart,
+   *
+   *   // called between invoking benchmarks
+   *   'onCycle': onCycle,
+   *
+   *   // called after all benchmarks have been invoked.
+   *   'onComplete': onComplete
+   * });
+   */
+  function invoke(benches, name) {
+    var args,
+        bench,
+        queued,
+        index = -1,
+        options = { 'onStart': noop, 'onCycle': noop, 'onComplete': noop },
+        result = map(benches, function(bench) { return bench; });
+
+    /**
+     * Checks if invoking `run` with asynchronous cycles.
+     */
+    function isAsync(object) {
+      var async = args[0] && args[0].async;
+      return isRun(object) && (async == null ? object.options.async : async) && has.timeout;
+    }
+
+    /**
+     * Checks if invoking `run` on a benchmark instance.
+     */
+    function isRun(object) {
+      // avoid using `instanceof` here because of IE memory leak issues with host objects
+      return Object(object).constructor == Benchmark && name == 'run';
+    }
+
+    /**
+     * Checks if invoking `run` with synchronous cycles.
+     */
+    function isSync(object) {
+      // if not asynchronous or deferred
+      return !isAsync(object) && !(isRun(object) && object.defer);
+    }
+
+    /**
+     * Executes the method and if synchronous, fetches the next bench.
+     */
+    function execute() {
+      var listeners,
+          sync = isSync(bench);
+
+      if (!sync) {
+        // use `getNext` as a listener
+        bench.on('complete', getNext);
+        listeners = bench.events.complete;
+        listeners.splice(0, 0, listeners.pop());
+      }
+      // execute method
+      result[index] = isClassOf(bench && bench[name], 'Function') ? bench[name].apply(bench, args) : undefined;
+      // if synchronous return true until finished
+      return sync && getNext();
+    }
+
+    /**
+     * Fetches the next bench or executes `onComplete` callback.
+     */
+    function getNext() {
+      var last = bench,
+          sync = isSync(last);
+
+      if (!sync) {
+        last.removeListener('complete', getNext);
+        last.emit('complete');
+      }
+      // choose next benchmark if not exiting early
+      if (options.onCycle.call(benches, Event('cycle'), last) !== false && raiseIndex() !== false) {
+        bench = queued ? benches[0] : result[index];
+        if (!isSync(bench)) {
+          call({ 'async': isAsync(bench), 'benchmark': bench, 'fn': execute });
+        }
+        else if (!sync) {
+          // resume synchronous execution
+          while (execute()) { }
+        }
+        else {
+          // continue synchronous execution
+          return true;
+        }
+      } else {
+        options.onComplete.call(benches, Event('complete'), last);
+      }
+      // when async the `return false` will cancel the rest of the "complete"
+      // listeners because they were called above and when synchronous it will
+      // exit the while-loop
+      return false;
+    }
+
+    /**
+     * Raises `index` to the next defined index or returns `false`.
+     */
+    function raiseIndex() {
+      var length = result.length;
+      // if queued then remove the previous bench and subsequent skipped non-entries
+      if (queued) {
+        do {
+          ++index > 0 && shift.call(benches);
+        } while ((length = benches.length) && !('0' in benches));
+      }
+      else {
+        while (++index < length && !(index in result)) { }
+      }
+      // if we reached the last index then return `false`
+      return (queued ? length : index < length) ? index : (index = false);
+    }
+
+    // juggle arguments
+    if (isClassOf(name, 'String')) {
+      // 2 arguments (array, name)
+      args = slice.call(arguments, 2);
+    } else {
+      // 2 arguments (array, options)
+      options = extend(options, name);
+      name = options.name;
+      args = isClassOf(args = 'args' in options ? options.args : [], 'Array') ? args : [args];
+      queued = options.queued;
+    }
+    // start iterating over the array
+    if (raiseIndex() !== false) {
+      bench = result[index];
+      options.onStart.call(benches, Event('start'), bench);
+
+      // end early if the suite was aborted in an "onStart" listener
+      if (benches.aborted && benches.constructor == Suite && name == 'run') {
+        options.onCycle.call(benches, Event('cycle'), bench);
+        options.onComplete.call(benches, Event('complete'), bench);
+      }
+      // else start
+      else {
+        if (isAsync(bench)) {
+          call({ 'async': true, 'benchmark': bench, 'fn': execute });
+        } else {
+          while (execute()) { }
+        }
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Creates a string of joined array values or object key-value pairs.
+   * @static
+   * @memberOf Benchmark
+   * @param {Array|Object} object The object to operate on.
+   * @param {String} [separator1=','] The separator used between key-value pairs.
+   * @param {String} [separator2=': '] The separator used between keys and values.
+   * @returns {String} The joined result.
+   */
+  function join(object, separator1, separator2) {
+    var result = [],
+        length = (object = Object(object)).length,
+        arrayLike = length === length >>> 0;
+
+    separator2 || (separator2 = ': ');
+    each(object, function(value, key) {
+      result.push(arrayLike ? value : key + separator2 + value);
+    });
+    return result.join(separator1 || ',');
+  }
+
+  /**
+   * A generic `Array#map` like method.
+   * @static
+   * @memberOf Benchmark
+   * @param {Array} array The array to iterate over.
+   * @param {Function} callback The function called per iteration.
+   * @param {Object} thisArg The `this` binding for the callback function.
+   * @returns {Array} A new array of values returned by the callback.
+   */
+  function map(array, callback, thisArg) {
+    return reduce(array, function(result, value, index) {
+      result[index] = callback.call(thisArg, value, index, array);
+      return result;
+    }, Array(Object(array).length >>> 0));
+  }
+
+  /**
+   * Retrieves the value of a specified property from all items in an array.
+   * @static
+   * @memberOf Benchmark
+   * @param {Array} array The array to iterate over.
+   * @param {String} property The property to pluck.
+   * @returns {Array} A new array of property values.
+   */
+  function pluck(array, property) {
+    return map(array, function(object) {
+      return object == null ? undefined : object[property];
+    });
+  }
+
+  /**
+   * A generic `Array#reduce` like method.
+   * @static
+   * @memberOf Benchmark
+   * @param {Array} array The array to iterate over.
+   * @param {Function} callback The function called per iteration.
+   * @param {Mixed} accumulator Initial value of the accumulator.
+   * @returns {Mixed} The accumulator.
+   */
+  function reduce(array, callback, accumulator) {
+    var noaccum = arguments.length < 3;
+    forEach(array, function(value, index) {
+      accumulator = noaccum ? (noaccum = 0, value) : callback(accumulator, value, index, array);
+    });
+    return accumulator;
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Aborts all benchmarks in the suite.
+   * @name abort
+   * @memberOf Benchmark.Suite
+   * @returns {Object} The suite instance.
+   */
+  function abortSuite() {
+    var me = this;
+
+    if (me.running) {
+      calledBy.abortSuite = true;
+      me.reset();
+      delete calledBy.abortSuite;
+
+      me.aborted = true;
+      !calledBy.resetSuite && invoke(me, 'abort');
+      me.emit('abort');
+    }
+    return me;
+  }
+
+  /**
+   * Adds a test to the benchmark suite.
+   * @memberOf Benchmark.Suite
+   * @param {String} name A name to identify the benchmark.
+   * @param {Function|String} fn The test to benchmark.
+   * @param {Object} [options={}] Options object.
+   * @returns {Object} The benchmark instance.
+   * @example
+   *
+   * // basic usage
+   * suite.add(fn);
+   *
+   * // or using a name first
+   * suite.add('foo', fn);
+   *
+   * // or with options
+   * suite.add('foo', fn, {
+   *   'onCycle': onCycle,
+   *   'onComplete': onComplete
+   * });
+   */
+  function add(name, fn, options) {
+    var me = this,
+        bench = Benchmark(name, fn, options);
+
+    me.push(bench);
+    me.emit('add', bench);
+    return me;
+  }
+
+  /**
+   * Creates a new suite with cloned benchmarks.
+   * @name clone
+   * @memberOf Benchmark.Suite
+   * @param {Object} options Options object to overwrite cloned options.
+   * @returns {Object} The new suite instance.
+   */
+  function cloneSuite(options) {
+    var me = this,
+        result = new me.constructor(extend({}, me.options, options));
+
+    // copy own properties
+    forOwn(me, function(value, key) {
+      if (!hasKey(result, key)) {
+        result[key] = value && isClassOf(value.clone, 'Function') ? value.clone() : deepClone(value);
+      }
+    });
+    return result;
+  }
+
+  /**
+   * An `Array#filter` like method.
+   * @name filter
+   * @memberOf Benchmark.Suite
+   * @param {Function|String} callback The function/alias called per iteration.
+   * @returns {Object} A new suite of benchmarks that passed callback filter.
+   */
+  function filterSuite(callback) {
+    var me = this,
+        result = new me.constructor;
+
+    result.push.apply(result, filter(me, callback));
+    return result;
+  }
+
+  /**
+   * Resets all benchmarks in the suite.
+   * @name reset
+   * @memberOf Benchmark.Suite
+   * @returns {Object} The suite instance.
+   */
+  function resetSuite() {
+    var me = this,
+        notAborting = !calledBy.abortSuite;
+
+    if (me.running && notAborting) {
+      calledBy.resetSuite = true;
+      me.abort();
+      delete calledBy.resetSuite;
+      me.aborted = false;
+    }
+    else if (me.aborted !== false || me.running !== false) {
+      me.aborted = me.running = false;
+      notAborting && invoke(me, 'reset');
+      me.emit('reset');
+    }
+    return me;
+  }
+
+  /**
+   * Runs the suite.
+   * @name run
+   * @memberOf Benchmark.Suite
+   * @param {Object} [options={}] Options object.
+   * @returns {Object} The suite instance.
+   * @example
+   *
+   * // basic usage
+   * suite.run();
+   *
+   * // or with options
+   * suite.run({ 'async': true, 'queued': true });
+   */
+  function runSuite(options) {
+    var me = this,
+        benches = [];
+
+    me.reset();
+    me.running = true;
+    options || (options = {});
+
+    invoke(me, {
+      'name': 'run',
+      'args': options,
+      'queued': options.queued,
+      'onStart': function(event, bench) {
+        me.emit('start', bench);
+      },
+      'onCycle': function(event, bench) {
+        if (bench.error) {
+          me.emit('error', bench);
+        } else if (bench.cycles) {
+          benches.push(bench);
+        }
+        return !me.aborted && me.emit('cycle', bench);
+      },
+      'onComplete': function(event, bench) {
+        me.running = false;
+        me.emit('complete', bench);
+      }
+    });
+    return me;
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Registers a single listener for the specified event type(s).
+   * @memberOf Benchmark, Benchmark.Suite
+   * @param {String} type The event type.
+   * @param {Function} listener The function called when the event occurs.
+   * @returns {Object} The benchmark instance.
+   * @example
+   *
+   * // register a listener for an event type
+   * bench.addListener('cycle', listener);
+   *
+   * // register a listener for multiple event types
+   * bench.addListener('start cycle', listener);
+   */
+  function addListener(type, listener) {
+    var me = this,
+        events = me.events || (me.events = {});
+
+    forEach(type.split(' '), function(type) {
+      (events[type] || (events[type] = [])).push(listener);
+    });
+    return me;
+  }
+
+  /**
+   * Executes all registered listeners of the specified event type.
+   * @memberOf Benchmark, Benchmark.Suite
+   * @param {String|Object} type The event type or object.
+   * @returns {Boolean} Returns `true` if all listeners were executed, else `false`.
+   */
+  function emit(type) {
+    var me = this,
+        event = Event(type),
+        args = (arguments[0] = event, arguments),
+        events = me.events,
+        listeners = events && events[event.type] || [],
+        result = true;
+
+    forEach(listeners.slice(), function(listener) {
+      return (result = listener.apply(me, args) !== false);
+    });
+    return result;
+  }
+
+  /**
+   * Unregisters a single listener for the specified event type(s).
+   * @memberOf Benchmark, Benchmark.Suite
+   * @param {String} type The event type.
+   * @param {Function} listener The function to unregister.
+   * @returns {Object} The benchmark instance.
+   * @example
+   *
+   * // unregister a listener for an event type
+   * bench.removeListener('cycle', listener);
+   *
+   * // unregister a listener for multiple event types
+   * bench.removeListener('start cycle', listener);
+   */
+  function removeListener(type, listener) {
+    var me = this,
+        events = me.events;
+
+    forEach(type.split(' '), function(type) {
+      var listeners = events && events[type] || [],
+          index = indexOf(listeners, listener);
+      if (index > -1) {
+        listeners.splice(index, 1);
+      }
+    });
+    return me;
+  }
+
+  /**
+   * Unregisters all listeners or those for the specified event type(s).
+   * @memberOf Benchmark, Benchmark.Suite
+   * @param {String} type The event type.
+   * @returns {Object} The benchmark instance.
+   * @example
+   *
+   * // unregister all listeners
+   * bench.removeAllListeners();
+   *
+   * // unregister all listeners for an event type
+   * bench.removeAllListeners('cycle');
+   *
+   * // unregister all listeners for multiple event types
+   * bench.removeAllListeners('start cycle complete');
+   */
+  function removeAllListeners(type) {
+    var me = this,
+        events = me.events;
+
+    forEach(type ? type.split(' ') : events, function(type) {
+      (events && events[type] || []).length = 0;
+    });
+    return me;
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Aborts the benchmark without recording times.
+   * @memberOf Benchmark
+   * @returns {Object} The benchmark instance.
+   */
+  function abort() {
+    var me = this;
+
+    if (me.running) {
+      if (has.timeout) {
+        forEach(me._timerIds || [], clearTimeout);
+        delete me._timerIds;
+      }
+      // avoid infinite recursion
+      calledBy.abort = true;
+      me.reset();
+      delete calledBy.abort;
+
+      me.aborted = true;
+      me.emit('abort');
+    }
+    return me;
+  }
+
+  /**
+   * Creates a new benchmark using the same test and options.
+   * @memberOf Benchmark
+   * @param {Object} options Options object to overwrite cloned options.
+   * @returns {Object} The new benchmark instance.
+   * @example
+   *
+   * var bizarro = bench.clone({
+   *   'name': 'doppelganger'
+   * });
+   */
+  function clone(options) {
+    var me = this,
+        result = new me.constructor(extend({}, me, options));
+
+    // correct the `options` object
+    result.options = extend({}, me.options, options);
+
+    // copy own custom properties
+    forOwn(me, function(value, key) {
+      if (!hasKey(result, key)) {
+        result[key] = deepClone(value);
+      }
+    });
+    return result;
+  }
+
+  /**
+   * Determines if a benchmark is faster than another.
+   * @memberOf Benchmark
+   * @param {Object} other The benchmark to compare.
+   * @returns {Number} Returns `-1` if slower, `1` if faster, and `0` if indeterminate.
+   */
+  function compare(other) {
+    // unpaired two-sample t-test assuming equal variance
+    // http://en.wikipedia.org/wiki/Student's_t-test
+    // http://www.chem.utoronto.ca/coursenotes/analsci/StatsTutorial/12tailed.html
+    var a = this.stats,
+        b = other.stats,
+        df = a.size + b.size - 2,
+        pooled = (((a.size - 1) * a.variance) + ((b.size - 1) * b.variance)) / df,
+        tstat = (a.mean - b.mean) / sqrt(pooled * (1 / a.size + 1 / b.size)),
+        near = abs(1 - a.mean / b.mean) < 0.055 && a.rme < 3 && b.rme < 3;
+
+    // check if the means aren't close and the t-statistic is significant
+    // (a larger `mean` indicates a slower benchmark)
+    return !near && abs(tstat) > getCriticalValue(df) ? (tstat > 0 ? -1 : 1) : 0;
+  }
+
+  /**
+   * Reset properties and abort if running.
+   * @memberOf Benchmark
+   * @returns {Object} The benchmark instance.
+   */
+  function reset() {
+    var changed,
+        pair,
+        me = this,
+        source = extend({}, me.constructor.prototype, me.options),
+        pairs = [[source, me]];
+
+    if (me.running && !calledBy.abort) {
+      // no worries, `reset()` is called within `abort()`
+      me.abort();
+      me.aborted = source.aborted;
+    }
+    else {
+      // a non-recursive solution to check if properties have changed
+      // http://www.jslab.dk/articles/non.recursive.preorder.traversal.part4
+      while ((pair = pairs.pop())) {
+        forOwn(pair[0], function(value, key) {
+          var other = pair[1][key];
+          if (value && isClassOf(value, 'Object')) {
+            pairs.push([value, other]);
+          }
+          else if (value !== other && !(value == null || isClassOf(value, 'Function'))) {
+            pair[1][key] = value;
+            changed = true;
+          }
+        });
+      }
+      if (changed) {
+        me.emit('reset');
+      }
+    }
+    return me;
+  }
+
+  /**
+   * Displays relevant benchmark information when coerced to a string.
+   * @name toString
+   * @memberOf Benchmark
+   * @returns {String} A string representation of the benchmark instance.
+   */
+  function toStringBench() {
+    var me = this,
+        error = me.error,
+        hz = me.hz,
+        id = me.id,
+        stats = me.stats,
+        size = stats.size,
+        pm = has.java ? '+/-' : '\xb1',
+        result = me.name || (typeof id == 'number' ? '<Test #' + id + '>' : id);
+
+    if (error) {
+      result += ': ' + join(error);
+    } else {
+      result += ' x ' + formatNumber(hz.toFixed(hz < 100 ? 2 : 0)) + ' ops/sec ' + pm +
+        stats.rme.toFixed(2) + '% (' + size + ' run' + (size == 1 ? '' : 's') + ' sampled)';
+    }
+    return result;
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * Clocks the time taken to execute a test per cycle (secs).
+   * @private
+   * @param {Object} bench The benchmark instance.
+   * @returns {Number} The time taken.
+   */
+  function clock() {
+    var applet,
+        options = Benchmark.options,
+        template = { 'begin': 's$=new n$', 'end': 'r$=(new n$-s$)/1e3', 'uid': uid },
+        timers = [{ 'ns': timer.ns, 'res': max(0.0015, getRes('ms')), 'unit': 'ms' }];
+
+    // lazy defined for hi-res timers
+    clock = function(bench) {
+      var deferred = bench instanceof Deferred && [bench, bench = bench.benchmark][0],
+          host = bench._host || bench,
+          fn = host.fn,
+          fnArg = deferred ? getFirstArgument(fn, 'deferred') : '',
+          stringable = isStringable(fn),
+          decompilable = has.decompilation || stringable,
+          source = {
+            'setup': getSource(host.setup, preprocess('m$.setup()')),
+            'fn': getSource(fn, preprocess('f$(' + fnArg + ')')),
+            'fnArg': fnArg,
+            'teardown': getSource(host.teardown, preprocess('m$.teardown()'))
+          },
+          compiled = fn.compiled,
+          count = host.count = bench.count,
+          id = host.id,
+          isEmpty = !(source.fn || stringable),
+          name = host.name || (typeof id == 'number' ? '<Test #' + id + '>' : id),
+          ns = timer.ns,
+          result = 0;
+
+      // init `minTime` if needed
+      bench.minTime = host.minTime || (host.minTime = host.options.minTime = options.minTime);
+
+      // repair nanosecond timer
+      // (some Chrome builds erase the `ns` variable after millions of executions)
+      if (applet) {
+        try {
+          ns.nanoTime();
+        } catch(e) {
+          // use non-element to avoid issues with libs that augment them
+          ns = timer.ns = new applet.Packages.nano;
+        }
+      }
+
+      if(!compiled) {
+        // compile in setup/teardown functions and the test loop
+        compiled = host.compiled = createFunction(preprocess('n$,t$'), interpolate(
+          preprocess(deferred
+            ? 'var d$=this,#{fnArg}=d$,r$=d$.resolve,m$=(m$=d$.benchmark)._host||m$,f$=m$.fn;' +
+              'if(!d$.cycles){d$.resolve=function(){d$.resolve=r$;r$.call(d$);' +
+              'if(d$.cycles==m$.count){#{teardown}\n}};#{setup}\nt$.start(d$);}#{fn}\nreturn{}'
+            : 'var r$,s$,m$=this,f$=m$.fn,i$=m$.count;#{setup}\n#{begin};' +
+              'while(i$--){#{fn}\n}#{end};#{teardown}\nreturn{time:r$,uid:"#{uid}"}'),
+          source
+        ));
+
+        try {
+          if (isEmpty) {
+            // Firefox may remove dead code from Function#toString results
+            // http://bugzil.la/536085
+            throw new Error('The test, ' + name + ', is empty. This may be the result of dead code removal.');
+          }
+          else if (!deferred) {
+            // pretest to determine if compiled code is exits early, usually by a
+            // rogue `return` statement, by checking for a return object with the uid
+            host.count = 1;
+            compiled = (compiled.call(host, ns) || {}).uid == uid && compiled;
+            host.count = count;
+          }
+        } catch(e) {
+          compiled = false;
+          bench.error = e || new Error(String(e));
+          host.count = count;
+        }
+        // fallback when a test exits early or errors during pretest
+        if (decompilable && !compiled && !deferred && !isEmpty) {
+          compiled = createFunction(preprocess('n$'), interpolate(
+            preprocess((bench.error && !stringable
+              ? 'var r$,s$,m$=this,f$=m$.fn,i$=m$.count;'
+              : 'function f$(){#{fn}\n}var r$,s$,i$=this.count;'
+            ) + '#{setup}\n#{begin};while(i$--){f$()}#{end};#{teardown}\nreturn{time:r$}'),
+            source
+          ));
+
+          try {
+            // pretest one more time to check for errors
+            host.count = 1;
+            compiled.call(host, ns);
+            host.compiled = compiled;
+            host.count = count;
+            delete bench.error;
+          }
+          catch(e) {
+            host.count = count;
+            if (!bench.error) {
+              host.compiled = compiled;
+              bench.error = e || new Error(String(e));
+            }
+          }
+        }
+      }
+      // if no errors run the full test loop
+      if (!bench.error) {
+        result = compiled.call(deferred || host, ns, timer).time;
+      }
+      return result;
+    };
+
+    /*------------------------------------------------------------------------*/
+
+    /**
+     * Gets the current timer's minimum resolution (secs).
+     */
+    function getRes(unit) {
+      var measured,
+          begin,
+          count = 30,
+          divisor = 1e3,
+          ns = timer.ns,
+          sample = [];
+
+      // get average smallest measurable time
+      while (count--) {
+        if (unit == 'us') {
+          divisor = 1e6;
+          if (ns.stop) {
+            ns.start();
+            while (!(measured = ns.microseconds())) { }
+          } else {
+            begin = timer.ns();
+            while (!(measured = ns() - begin)) { }
+          }
+        }
+        else if (unit == 'ns') {
+          divisor = 1e9;
+          begin = ns.nanoTime();
+          while (!(measured = ns.nanoTime() - begin)) { }
+        }
+        else {
+          begin = new ns;
+          while (!(measured = new ns - begin)) { }
+        }
+        // check for broken timers (nanoTime may have issues)
+        // http://alivebutsleepy.srnet.cz/unreliable-system-nanotime/
+        if (measured > 0) {
+          sample.push(measured);
+        } else {
+          sample.push(Infinity);
+          break;
+        }
+      }
+      // convert to seconds
+      return getMean(sample) / divisor;
+    }
+
+    /**
+     * Replaces all occurrences of `$` with a unique number and
+     * template tokens with content.
+     */
+    function preprocess(code) {
+      return interpolate(code, template).replace(/\$/g, /\d+/.exec(uid));
+    }
+
+    /*------------------------------------------------------------------------*/
+
+    // detect nanosecond support from a Java applet
+    each(window.document && document.applets || [], function(element) {
+      return !(timer.ns = applet = 'nanoTime' in element && element);
+    });
+
+    // check type in case Safari returns an object instead of a number
+    try {
+      if (typeof timer.ns.nanoTime() == 'number') {
+        timers.push({ 'ns': timer.ns, 'res': getRes('ns'), 'unit': 'ns' });
+      }
+    } catch(e) { }
+
+    // detect Chrome's microsecond timer:
+    // enable benchmarking via the --enable-benchmarking command
+    // line switch in at least Chrome 7 to use chrome.Interval
+    try {
+      if ((timer.ns = new (window.chrome || window.chromium).Interval)) {
+        timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });
+      }
+    } catch(e) { }
+
+    // detect Node's microtime module:
+    // npm install microtime
+    if ((timer.ns = (req('microtime') || { 'now': 0 }).now)) {
+      timers.push({ 'ns': timer.ns,  'res': getRes('us'), 'unit': 'us' });
+    }
+
+    // pick timer with highest resolution
+    timer = reduce(timers, function(timer, other) {
+      return other.res < timer.res ? other : timer;
+    });
+
+    // remove unused applet
+    if (timer.unit != 'ns' && applet) {
+      applet = (applet.parentNode.removeChild(applet), null);
+    }
+    // error if there are no working timers
+    if (timer.res == Infinity) {
+      throw new Error('Benchmark.js was unable to find a working timer.');
+    }
+    // use API of chosen timer
+    if (timer.unit == 'ns') {
+      extend(template, {
+        'begin': 's$=n$.nanoTime()',
+        'end': 'r$=(n$.nanoTime()-s$)/1e9'
+      });
+    }
+    else if (timer.unit == 'us') {
+      extend(template, timer.ns.stop ? {
+        'begin': 's$=n$.start()',
+        'end': 'r$=n$.microseconds()/1e6'
+      } : {
+        'begin': 's$=n$()',
+        'end': 'r$=(n$()-s$)/1e6'
+      });
+    }
+
+    // define `timer` methods
+    timer.start = createFunction(preprocess('d$'),
+      preprocess('var n$=this.ns,#{begin};d$.timeStamp=s$'));
+
+    timer.stop = createFunction(preprocess('d$'),
+      preprocess('var n$=this.ns,s$=d$.timeStamp,#{end};d$.elapsed=r$'));
+
+    // resolve time span required to achieve a percent uncertainty of at most 1%
+    // http://spiff.rit.edu/classes/phys273/uncert/uncert.html
+    options.minTime || (options.minTime = max(timer.res / 2 / 0.01, 0.05));
+    return clock.apply(null, arguments);
+  }
+
+  /**
+   * Computes stats on benchmark results.
+   * @private
+   * @param {Object} options The options object.
+   */
+  function compute(options) {
+    options || (options = {});
+
+    var async = options.async,
+        bench = options.benchmark,
+        elapsed = 0,
+        queue = [],
+        sample = [],
+        initCount = bench.initCount;
+
+    /**
+     * Adds a number of clones to the queue.
+     */
+    function enqueue(count) {
+      while (count--) {
+        queue.push(bench.clone({
+          '_host': bench,
+          'events': { 'start': [update], 'cycle': [update] }
+        }));
+      }
+    }
+
+    /**
+     * Updates the clone/host benchmarks to keep their data in sync.
+     */
+    function update(event) {
+      var clone = this,
+          cycles = clone.cycles,
+          type = event.type;
+
+      if (bench.running) {
+        if (type == 'cycle') {
+          if (clone.error) {
+            bench.abort();
+            bench.error = clone.error;
+            bench.emit('error');
+          }
+          else {
+            // Note: the host's bench.count prop is updated in `clock()`
+            bench.hz = clone.hz;
+            bench.initCount = clone.initCount;
+            bench.times.period = clone.times.period;
+            if (cycles > bench.cycles) {
+              bench.cycles = cycles;
+            }
+          }
+          bench.emit(type);
+        }
+        else {
+          // reached in clone's onStart
+          // Note: clone.minTime prop is inited in `clock()`
+          clone.count = bench.initCount;
+        }
+      } else if (bench.aborted) {
+        clone.abort();
+      }
+    }
+
+    /**
+     * Determines if more clones should be queued or if cycling should stop.
+     */
+    function evaluate(event, clone) {
+      var mean,
+          moe,
+          rme,
+          sd,
+          sem,
+          variance,
+          now = +new Date,
+          times = bench.times,
+          done = bench.aborted,
+          maxedOut = (elapsed += now - clone.times.timeStamp) / 1e3 > bench.maxTime,
+          size = sample.push(clone.times.period),
+          varOf = function(sum, x) { return sum + pow(x - mean, 2); };
+
+      // exit early for aborted or unclockable tests
+      if (done || clone.hz == Infinity) {
+        maxedOut = !(size = sample.length = queue.length = 0);
+      }
+      // set host values
+      if (!done) {
+        // sample mean (estimate of the population mean)
+        mean = getMean(sample);
+        // sample variance (estimate of the population variance)
+        variance = reduce(sample, varOf, 0) / (size - 1) || 0;
+        // sample standard deviation (estimate of the population standard deviation)
+        sd = sqrt(variance);
+        // standard error of the mean (aka the standard deviation of the sampling distribution of the sample mean)
+        sem = sd / sqrt(size);
+        // margin of error
+        moe = sem * getCriticalValue(size - 1);
+        // relative margin of error
+        rme = (moe / mean) * 100 || 0;
+
+        extend(bench.stats, {
+          'moe': moe,
+          'rme': rme,
+          'sem': sem,
+          'deviation': sd,
+          'mean': mean,
+          'size': size,
+          'variance': variance
+        });
+
+        // We exit early when the elapsed time exceeds the maximum time allowed
+        // per benchmark. To prevent massive wait times, we do this even if the
+        // minimum sample size has not been reached. We don't count cycle delays
+        // toward the max time because delays may be increased by browsers that
+        // clamp timeouts in inactive tabs.
+        // https://developer.mozilla.org/en/window.setTimeout#Inactive_tabs
+        if (maxedOut) {
+          done = true;
+          bench.running = false;
+          bench.initCount = initCount;
+          times.elapsed = (now - times.timeStamp) / 1e3;
+        }
+        if (bench.hz != Infinity) {
+          times.period = mean;
+          times.cycle = mean * bench.count;
+          bench.hz = 1 / mean;
+        }
+      }
+      // if time permits, increase sample size to reduce the margin of error
+      if (queue.length < 2 && !maxedOut) {
+        enqueue(1);
+      }
+      // stop the invoke cycle when done
+      return !done;
+    }
+
+    // init queue and begin
+    enqueue(bench.minSamples);
+    invoke(queue, {
+      'name': 'run',
+      'args': { 'async': async },
+      'queued': true,
+      'onCycle': evaluate,
+      'onComplete': function() {
+        bench.emit('complete');
+      }
+    });
+  }
+
+  /**
+   * Cycles a benchmark until a run `count` can be established.
+   * @private
+   * @param {Object} options The options object.
+   */
+  function cycle(options) {
+    options || (options = {});
+
+    var clocked,
+        divisor,
+        minTime,
+        period,
+        async = options.async,
+        bench = options.benchmark,
+        count = bench.count,
+        deferred = options.deferred,
+        times = bench.times;
+
+    // continue, if not aborted between cycles
+    if (bench.running) {
+      // host `minTime` is set to `Benchmark.options.minTime` in `clock()`
+      bench.cycles++;
+      clocked = deferred ? deferred.elapsed : clock(bench);
+      minTime = bench.minTime;
+
+      if (bench.error) {
+        bench.abort();
+        bench.emit('error');
+      }
+    }
+    // continue, if not errored
+    if (bench.running) {
+      // time taken to complete last test cycle
+      times.cycle = clocked;
+      // seconds per operation
+      period = times.period = clocked / count;
+      // ops per second
+      bench.hz = 1 / period;
+      // do we need to do another cycle?
+      bench.running = clocked < minTime;
+      // avoid working our way up to this next time
+      bench.initCount = count;
+
+      if (bench.running) {
+        // tests may clock at `0` when `initCount` is a small number,
+        // to avoid that we set its count to something a bit higher
+        if (!clocked && (divisor = divisors[bench.cycles]) != null) {
+          count = floor(4e6 / divisor);
+        }
+        // calculate how many more iterations it will take to achive the `minTime`
+        if (count <= bench.count) {
+          count += Math.ceil((minTime - clocked) / period);
+        }
+        bench.running = count != Infinity;
+      }
+    }
+    // should we exit early?
+    if (bench.emit('cycle') === false) {
+      bench.abort();
+    }
+    // figure out what to do next
+    if (bench.running) {
+      bench.count = count;
+      if (deferred) {
+        (bench._host || bench).compiled.call(deferred, timer.ns, timer);
+      } else {
+        call({
+          'async': async,
+          'benchmark': bench,
+          'fn': function() {
+            cycle({ 'async': async, 'benchmark': bench });
+          }
+        });
+      }
+    } else {
+      // fix TraceMonkey bug associated with clock fallbacks
+      // http://bugzil.la/509069
+      runScript('try{' + uid + '=1;delete ' + uid + '}catch(e){}');
+      // done
+      bench.emit('complete');
+    }
+  }
+
+  /**
+   * Runs the benchmark.
+   * @memberOf Benchmark
+   * @param {Object} [options={}] Options object.
+   * @returns {Object} The benchmark instance.
+   * @example
+   *
+   * // basic usage
+   * bench.run();
+   *
+   * // or with options
+   * bench.run({ 'async': true });
+   */
+  function run(options) {
+    var me = this,
+        async = ((async = options && options.async) == null ? me.async : async) && has.timeout;
+
+    // set running to false so reset() won't call abort()
+    me.running = false;
+    me.reset();
+    me.running = true;
+
+    me.count = me.initCount;
+    me.times.timeStamp = +new Date;
+    me.emit('start');
+
+    if (me._host) {
+      if (me.defer) {
+        Deferred(me);
+      } else {
+        cycle({ 'async': async, 'benchmark': me });
+      }
+    } else {
+      compute({ 'async': async, 'benchmark': me });
+    }
+    return me;
+  }
+
+  /*--------------------------------------------------------------------------*/
+
+  extend(Benchmark, {
+
+    /**
+     * The version number.
+     * @static
+     * @memberOf Benchmark
+     * @type String
+     */
+    'version': '0.3.0',
+
+    /**
+     * The default options copied by benchmark instances.
+     * @static
+     * @memberOf Benchmark
+     * @type Object
+     */
+    'options': {
+
+      /**
+       * A flag to indicate that benchmark cycles will execute asynchronously by default.
+       * @memberOf Benchmark.options
+       * @type Boolean
+       */
+      'async': false,
+
+      /**
+       * A flag to indicate that the benchmark clock is deferred.
+       * @memberOf Benchmark.options
+       * @type Boolean
+       */
+      'defer': false,
+
+      /**
+       * The delay between test cycles (secs).
+       * @memberOf Benchmark.options
+       * @type Number
+       */
+      'delay': 0.005,
+
+      /**
+       * Displayed by Benchmark#toString when a `name` is not available (auto-generated if `null`).
+       * @memberOf Benchmark.options
+       * @type String|Null
+       */
+      'id': null,
+
+      /**
+       * The default number of times to execute a test on a benchmark's first cycle.
+       * @memberOf Benchmark.options
+       * @type Number
+       */
+      'initCount': 1,
+
+      /**
+       * The maximum time a benchmark is allowed to run before finishing (secs).
+       * Note: Cycle delays aren't counted toward the maximum time.
+       * @memberOf Benchmark.options
+       * @type Number
+       */
+      'maxTime': 5,
+
+      /**
+       * The minimum sample size required to perform statistical analysis.
+       * @memberOf Benchmark.options
+       * @type Number
+       */
+      'minSamples': 5,
+
+      /**
+       * The time needed to reduce the percent uncertainty of measurement to 1% (secs).
+       * @memberOf Benchmark.options
+       * @type Number
+       */
+      'minTime': 0,
+
+      /**
+       * The name of the benchmark.
+       * @memberOf Benchmark.options
+       * @type String|Null
+       */
+      'name': null
+    },
+
+    /**
+     * Platform object with properties describing things like browser name,
+     * version, and operating system.
+     * @static
+     * @memberOf Benchmark
+     * @type Object
+     */
+    'platform': req('platform') || window.platform || {
+
+      /**
+       * The platform description.
+       * @memberOf Benchmark.platform
+       * @type String
+       */
+      'description': window.navigator && navigator.userAgent || null,
+
+      /**
+       * The name of the browser layout engine.
+       * @memberOf Benchmark.platform
+       * @type String|Null
+       */
+      'layout': null,
+
+      /**
+       * The name of the product hosting the browser.
+       * @memberOf Benchmark.platform
+       * @type String|Null
+       */
+      'product': null,
+
+      /**
+       * The name of the browser/environment.
+       * @memberOf Benchmark.platform
+       * @type String|Null
+       */
+      'name': null,
+
+      /**
+       * The name of the product's manufacturer.
+       * @memberOf Benchmark.platform
+       * @type String|Null
+       */
+      'manufacturer': null,
+
+      /**
+       * The name of the operating system.
+       * @memberOf Benchmark.platform
+       * @type String|Null
+       */
+      'os': null,
+
+      /**
+       * The alpha/beta release indicator.
+       * @memberOf Benchmark.platform
+       * @type String|Null
+       */
+      'prerelease': null,
+
+      /**
+       * The browser/environment version.
+       * @memberOf Benchmark.platform
+       * @type String|Null
+       */
+      'version': null,
+
+      /**
+       * Return platform description when the platform object is coerced to a string.
+       * @memberOf Benchmark.platform
+       * @type Function
+       * @returns {String} The platform description.
+       */
+      'toString': function() {
+        return this.description || '';
+      }
+    },
+
+    // clone objects
+    'deepClone': deepClone,
+
+    // iteration utility
+    'each': each,
+
+    // augment objects
+    'extend': extend,
+
+    // generic Array#filter
+    'filter': filter,
+
+    // generic Array#forEach
+    'forEach': forEach,
+
+    // generic own property iteration utility
+    'forOwn': forOwn,
+
+    // converts a number to a comma-separated string
+    'formatNumber': formatNumber,
+
+    // generic Object#hasOwnProperty
+    // (trigger hasKey's lazy define before assigning it to Benchmark)
+    'hasKey': (hasKey(Benchmark, ''), hasKey),
+
+    // generic Array#indexOf
+    'indexOf': indexOf,
+
+    // invokes a method on each item in an array
+    'invoke': invoke,
+
+    // generic Array#join for arrays and objects
+    'join': join,
+
+    // generic Array#map
+    'map': map,
+
+    // retrieves a property value from each item in an array
+    'pluck': pluck,
+
+    // generic Array#reduce
+    'reduce': reduce
+  });
+
+  /*--------------------------------------------------------------------------*/
+
+  extend(Benchmark.prototype, {
+
+    /**
+     * The number of times a test was executed.
+     * @memberOf Benchmark
+     * @type Number
+     */
+    'count': 0,
+
+    /**
+     * The number of cycles performed while benchmarking.
+     * @memberOf Benchmark
+     * @type Number
+     */
+    'cycles': 0,
+
+    /**
+     * The number of executions per second.
+     * @memberOf Benchmark
+     * @type Number
+     */
+    'hz': 0,
+
+    /**
+     * The compiled test function.
+     * @memberOf Benchmark
+     * @type Function|String
+     */
+    'compiled': null,
+
+    /**
+     * The error object if the test failed.
+     * @memberOf Benchmark
+     * @type Object|Null
+     */
+    'error': null,
+
+    /**
+     * The test to benchmark.
+     * @memberOf Benchmark
+     * @type Function|String
+     */
+    'fn': null,
+
+    /**
+     * A flag to indicate if the benchmark is aborted.
+     * @memberOf Benchmark
+     * @type Boolean
+     */
+    'aborted': false,
+
+    /**
+     * A flag to indicate if the benchmark is running.
+     * @memberOf Benchmark
+     * @type Boolean
+     */
+    'running': false,
+
+    /**
+     * Alias of [`Benchmark#addListener`](#Benchmark:addListener).
+     * @memberOf Benchmark, Benchmark.Suite
+     * @type Function
+     */
+    'on': addListener,
+
+    /**
+     * Compiled into the test and executed immediately **before** the test loop.
+     * @memberOf Benchmark
+     * @type Function|String
+     * @example
+     *
+     * // basic usage
+     * var bench = Benchmark({
+     *   'setup': function() {
+     *     var c = this.count,
+     *         element = document.getElementById('container');
+     *     while (c--) {
+     *       element.appendChild(document.createElement('div'));
+     *     }
+     *   },
+     *   'fn': function() {
+     *     element.removeChild(element.lastChild);
+     *   }
+     * });
+     *
+     * // compiles to something like:
+     * var c = this.count,
+     *     element = document.getElementById('container');
+     * while (c--) {
+     *   element.appendChild(document.createElement('div'));
+     * }
+     * var start = new Date;
+     * while (count--) {
+     *   element.removeChild(element.lastChild);
+     * }
+     * var end = new Date - start;
+     *
+     * // or using strings
+     * var bench = Benchmark({
+     *   'setup': '\
+     *     var a = 0;\n\
+     *     (function() {\n\
+     *       (function() {\n\
+     *         (function() {',
+     *   'fn': 'a += 1;',
+     *   'teardown': '\
+     *          }())\n\
+     *        }())\n\
+     *      }())'
+     * });
+     *
+     * // compiles to something like:
+     * var a = 0;
+     * (function() {
+     *   (function() {
+     *     (function() {
+     *       var start = new Date;
+     *       while (count--) {
+     *         a += 1;
+     *       }
+     *       var end = new Date - start;
+     *     }())
+     *   }())
+     * }())
+     */
+    'setup': noop,
+
+    /**
+     * Compiled into the test and executed immediately **after** the test loop.
+     * @memberOf Benchmark
+     * @type Function|String
+     */
+    'teardown': noop,
+
+    /**
+     * An object of stats including mean, margin or error, and standard deviation.
+     * @memberOf Benchmark
+     * @type Object
+     */
+    'stats': {
+
+      /**
+       * The margin of error.
+       * @memberOf Benchmark#stats
+       * @type Number
+       */
+      'moe': 0,
+
+      /**
+       * The relative margin of error (expressed as a percentage of the mean).
+       * @memberOf Benchmark#stats
+       * @type Number
+       */
+      'rme': 0,
+
+      /**
+       * The standard error of the mean.
+       * @memberOf Benchmark#stats
+       * @type Number
+       */
+      'sem': 0,
+
+      /**
+       * The sample standard deviation.
+       * @memberOf Benchmark#stats
+       * @type Number
+       */
+      'deviation': 0,
+
+      /**
+       * The sample arithmetic mean.
+       * @memberOf Benchmark#stats
+       * @type Number
+       */
+      'mean': 0,
+
+      /**
+       * The sample size.
+       * @memberOf Benchmark#stats
+       * @type Number
+       */
+      'size': 0,
+
+      /**
+       * The sample variance.
+       * @memberOf Benchmark#stats
+       * @type Number
+       */
+      'variance': 0
+    },
+
+    /**
+     * An object of timing data including cycle, elapsed, period, start, and stop.
+     * @memberOf Benchmark
+     * @type Object
+     */
+    'times': {
+
+      /**
+       * The time taken to complete the last cycle (secs).
+       * @memberOf Benchmark#times
+       * @type Number
+       */
+      'cycle': 0,
+
+      /**
+       * The time taken to complete the benchmark (secs).
+       * @memberOf Benchmark#times
+       * @type Number
+       */
+      'elapsed': 0,
+
+      /**
+       * The time taken to execute the test once (secs).
+       * @memberOf Benchmark#times
+       * @type Number
+       */
+      'period': 0,
+
+      /**
+       * A timestamp of when the benchmark started (ms).
+       * @memberOf Benchmark#times
+       * @type Number
+       */
+      'timeStamp': 0
+    },
+
+    // aborts benchmark (does not record times)
+    'abort': abort,
+
+    // registers a single listener
+    'addListener': addListener,
+
+    // creates a new benchmark using the same test and options
+    'clone': clone,
+
+    // compares benchmark's hertz with another
+    'compare': compare,
+
+    // executes listeners of a specified type
+    'emit': emit,
+
+    // removes all listeners of a specified type
+    'removeAllListeners': removeAllListeners,
+
+    // removes a single listener
+    'removeListener': removeListener,
+
+    // reset benchmark properties
+    'reset': reset,
+
+    // runs the benchmark
+    'run': run,
+
+    // pretty print benchmark info
+    'toString': toStringBench
+  });
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * The default options copied by suite instances.
+   * @static
+   * @memberOf Benchmark.Suite
+   * @type Object
+   */
+  Suite.options = {
+
+    /**
+     * The name of the suite.
+     * @memberOf Benchmark.Suite.options
+     * @type String|Null
+     */
+    'name': null
+  };
+
+  /*--------------------------------------------------------------------------*/
+
+  extend(Suite.prototype, {
+
+    /**
+     * The number of benchmarks in the suite.
+     * @memberOf Benchmark.Suite
+     * @type Number
+     */
+    'length': 0,
+
+    /**
+     * A flag to indicate if the suite is aborted.
+     * @memberOf Benchmark.Suite
+     * @type Boolean
+     */
+    'aborted': false,
+
+    /**
+     * A flag to indicate if the suite is running.
+     * @memberOf Benchmark.Suite
+     * @type Boolean
+     */
+    'running': false,
+
+    /**
+     * An `Array#forEach` like method.
+     * Callbacks may terminate the loop by explicitly returning `false`.
+     * @memberOf Benchmark.Suite
+     * @param {Function} callback The function called per iteration.
+     * @returns {Object} The suite iterated over.
+     */
+    'forEach': methodize(forEach),
+
+    /**
+     * An `Array#indexOf` like method.
+     * @memberOf Benchmark.Suite
+     * @param {Mixed} value The value to search for.
+     * @returns {Number} The index of the matched value or `-1`.
+     */
+    'indexOf': methodize(indexOf),
+
+    /**
+     * Invokes a method on all benchmarks in the suite.
+     * @memberOf Benchmark.Suite
+     * @param {String|Object} name The name of the method to invoke OR options object.
+     * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
+     * @returns {Array} A new array of values returned from each method invoked.
+     */
+    'invoke': methodize(invoke),
+
+    /**
+     * Converts the array to a string.
+     * @memberOf Benchmark.Suite
+     * @param {String} [separator=','] A string to separate each element of the array.
+     * @returns {String} The removed element.
+     */
+    'join': [].join,
+
+    /**
+     * An `Array#map` like method.
+     * @memberOf Benchmark.Suite
+     * @param {Function} callback The function called per iteration.
+     * @returns {Array} A new array of values returned by the callback.
+     */
+    'map': methodize(map),
+
+    /**
+     * Retrieves the value of a specified property from all benchmarks in the suite.
+     * @memberOf Benchmark.Suite
+     * @param {String} property The property to pluck.
+     * @returns {Array} A new array of property values.
+     */
+    'pluck': methodize(pluck),
+
+    /**
+     * Removes the last element of the host array and returns it.
+     * @memberOf Benchmark.Suite
+     * @returns {Mixed} The removed element.
+     */
+    'pop': [].pop,
+
+    /**
+     * Appends arguments to the end of the array.
+     * @memberOf Benchmark.Suite
+     * @returns {Number} The array length.
+     */
+    'push': [].push,
+
+    /**
+     * Sorts the elements of the host array.
+     * @memberOf Benchmark.Suite
+     * @param {Function} [compareFn=null] A function that defines the sort order.
+     * @returns {Array} The sorted host array.
+     */
+    'sort': [].sort,
+
+    /**
+     * An `Array#reduce` like method.
+     * @memberOf Benchmark.Suite
+     * @param {Function} callback The function called per iteration.
+     * @param {Mixed} accumulator Initial value of the accumulator.
+     * @returns {Mixed} The accumulator.
+     */
+    'reduce': methodize(reduce),
+
+    // aborts all benchmarks in the suite
+    'abort': abortSuite,
+
+    // adds a benchmark to the suite
+    'add': add,
+
+    // registers a single listener
+    'addListener': addListener,
+
+    // creates a new suite with cloned benchmarks
+    'clone': cloneSuite,
+
+    // executes listeners of a specified type
+    'emit': emit,
+
+    // creates a new suite of filtered benchmarks
+    'filter': filterSuite,
+
+    // alias of addListener
+    'on': addListener,
+
+    // removes all listeners of a specified type
+    'removeAllListeners': removeAllListeners,
+
+    // removes a single listener
+    'removeListener': removeListener,
+
+    // resets all benchmarks in the suite
+    'reset': resetSuite,
+
+    // runs all benchmarks in the suite
+    'run': runSuite,
+
+    // array methods
+    'concat': concat,
+
+    'reverse': reverse,
+
+    'shift': shift,
+
+    'slice': slice,
+
+    'splice': splice,
+
+    'unshift': unshift
+  });
+
+  /*--------------------------------------------------------------------------*/
+
+  extend(Deferred.prototype, {
+
+    /**
+     * The deferred benchmark instance.
+     * @memberOf Benchmark.Deferred
+     * @type Object
+     */
+    'benchmark': null,
+
+    /**
+     * The number of deferred cycles performed while benchmarking.
+     * @memberOf Benchmark.Deferred
+     * @type Number
+     */
+    'cycles': 0,
+
+    /**
+     * The time taken to complete the deferred benchmark (secs).
+     * @memberOf Benchmark.Deferred
+     * @type Number
+     */
+    'elapsed': 0,
+
+    /**
+     * A timestamp of when the deferred benchmark started (ms).
+     * @memberOf Benchmark.Deferred
+     * @type Number
+     */
+    'timeStamp': 0,
+
+    // cycles/completes the deferred benchmark
+    'resolve': resolve
+  });
+
+  /*--------------------------------------------------------------------------*/
+
+  /**
+   * The event type.
+   * @memberOf Benchmark.Event
+   * @type String
+   */
+  Event.prototype.type = '';
+
+  /*--------------------------------------------------------------------------*/
+
+  // expose Deferred, Event and Suite
+  extend(Benchmark, {
+    'Deferred': Deferred,
+    'Event': Event,
+    'Suite': Suite
+  });
+
+  // expose Benchmark
+  if (freeExports) {
+    // in Node.js or RingoJS v0.8.0+
+    if (typeof module == 'object' && module && module.exports == freeExports) {
+      (module.exports = Benchmark).Benchmark = Benchmark;
+    }
+    // in Narwhal or RingoJS v0.7.0-
+    else {
+      freeExports.Benchmark = Benchmark;
+    }
+  }
+  // via curl.js or RequireJS
+  else if (freeDefine) {
+    define('benchmark', function() {
+      return Benchmark;
+    });
+  }
+  // in a browser or Rhino
+  else {
+    // use square bracket notation so Closure Compiler won't munge `Benchmark`
+    // http://code.google.com/closure/compiler/docs/api-tutorial3.html#export
+    window['Benchmark'] = Benchmark;
+  }
+
+  // trigger clock's lazy define early to avoid a security error
+  if (has.air) {
+    clock({ 'fn': noop, 'count': 1, 'options': {} });
+  }
+}(this));