From 33a0a59cd9b0ad0366a0c8e10bef991bef1d7470 Mon Sep 17 00:00:00 2001 From: Mathias Bynens Date: Tue, 27 Mar 2012 11:42:35 +0200 Subject: [PATCH] Add Benchmark.js v0.3.0 --- ajax/libs/benchmark/0.3.0/benchmark.js | 3284 ++++++++++++++++++++ ajax/libs/benchmark/0.3.0/benchmark.min.js | 8 + ajax/libs/benchmark/package.json | 54 + 3 files changed, 3346 insertions(+) create mode 100644 ajax/libs/benchmark/0.3.0/benchmark.js create mode 100644 ajax/libs/benchmark/0.3.0/benchmark.min.js create mode 100644 ajax/libs/benchmark/package.json diff --git a/ajax/libs/benchmark/0.3.0/benchmark.js b/ajax/libs/benchmark/0.3.0/benchmark.js new file mode 100644 index 000000000..640bc2433 --- /dev/null +++ b/ajax/libs/benchmark/0.3.0/benchmark.js @@ -0,0 +1,3284 @@ +/*! + * Benchmark.js + * Copyright 2010-2012 Mathias Bynens + * Based on JSLitmus.js, copyright Robert Kieffer + * Modified by John-David Dalton + * Available under MIT license + */ +;(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 in a browser environment */ + 'browser': isHostType(window, 'document') && isHostType(window, 'navigator'), + + /** Detect if strings support accessing characters by index */ + 'charByIndex': + // IE 8 supports indexes on string literals but not string objects + ('x'[0] + Object('x')[0]) == 'xx', + + /** Detect if strings have indexes as own properties */ + 'charByOwnIndex': + // Narwhal, Rhino, RingoJS, IE 8*, and Opera < 10.52 support indexes on + // strings but don't detect them as own properties + 'x'[0] == 'x' && 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 define + 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 = has.browser && (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') && + (iteratee = noCharByIndex ? object.split('') : object)))) { + 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; + }) / 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) { + // escape the `{` for Firefox 1 + result = (/^[^{]+\{([\s\S]*)}\s*$/.exec(fn) || 0)[1]; + } + return (result || '').replace(/^\s+|\s+$/g, ''); + } + + /** + * 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 anchor = freeDefine ? define.amd : Benchmark, + script = document.createElement('script'), + sibling = document.getElementsByTagName('script')[0], + parent = sibling.parentNode, + prop = uid + 'runScript', + prefix = '(' + (freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '||function(){})();'; + + // Firefox 2.0.0.2 cannot use script injection as intended because it executes + // asynchronously, but that's OK because script injection is only used to avoid + // the previously commented JaegerMonkey bug. + try { + // remove the inserted script *before* running the code to avoid differences + // in the expected script element count/order of the document. + script.appendChild(document.createTextNode(prefix + code)); + anchor[prop] = function() { parent.removeChild(script); }; + } catch(e) { + parent = parent.cloneNode(false); + sibling = null; + script.text = code; + } + parent.insertBefore(script, sibling); + 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) { + // continue the test loop + (bench._host || bench).compiled.call(me, 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, + descriptor, + extensible, + key, + length, + markerKey, + parent, + result, + source, + subIndex, + data = { 'value': value }, + index = 0, + marked = [], + queue = { 'length': 0 }, + unmarked = []; + + /** + * 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; + } + } + + do { + key = data.key; + parent = data.parent; + source = data.source; + clone = value = source ? source[key] : data.value; + accessor = circular = descriptor = false; + + // create a basic clone to filter out functions, DOM elements, and + // other non `Object` objects + if (value === Object(value)) { + // use custom deep clone function if available + if (isClassOf(value.deepClone, 'Function')) { + clone = value.deepClone(); + } else { + 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 && 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; + } + } while ((data = queue[index++])); + + // 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 those that are errored, unrun, or have hz of Infinity + callback = function(bench) { return bench.cycles && isFinite(bench.hz); }; + } + 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) == 0; + }); + } + 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; + } + + /** + * Modify a string by replacing named tokens with matching object property values. + * @static + * @memberOf Benchmark + * @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; + } + + /** + * 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' ? '' : 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 define 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 = host.compiled, + count = host.count = bench.count, + id = host.id, + isEmpty = !(source.fn || stringable), + name = host.name || (typeof id == 'number' ? '' : 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('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,n$=t$.ns;#{setup}\n#{begin};' + + 'while(i$--){#{fn}\n}#{end};#{teardown}\nreturn{elapsed: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, timer) || {}).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('t$'), 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' + ) + ',n$=t$.ns;#{setup}\n#{begin};while(i$--){f$()}#{end};#{teardown}\nreturn{elapsed:r$}'), + source + )); + + try { + // pretest one more time to check for errors + host.count = 1; + compiled.call(host, timer); + 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, timer).elapsed; + } + 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('o$'), + preprocess('var n$=this.ns,#{begin};o$.timeStamp=s$')); + + timer.stop = createFunction(preprocess('o$'), + preprocess('var n$=this.ns,s$=o$.timeStamp,#{end};o$.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 (a.k.a. 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 + }); + + // 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) { + // start a new cycle + bench.count = count; + if (deferred) { + (bench._host || bench).compiled.call(deferred, 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 + if (has.browser) { + runScript(uid + '=1;delete ' + uid); + } + // 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; + } + + /*--------------------------------------------------------------------------*/ + + // Firefox 1 erroneously defines variable and argument names of functions on + // the function itself as non-configurable properties with `undefined` values. + // The bugginess continues as the `Benchmark` constructor has an argument + // named `options` and Firefox 1 will not assign a value to `Benchmark.options`, + // making it non-writable in the process, unless it is the first property + // assigned by for-in loop of `extend()`. + extend(Benchmark, { + + /** + * 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 || ''; + } + }, + + /** + * The version number. + * @static + * @memberOf Benchmark + * @type String + */ + 'version': '0.3.0', + + // 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, + + // template utility + 'interpolate': interpolate, + + // 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)); \ No newline at end of file diff --git a/ajax/libs/benchmark/0.3.0/benchmark.min.js b/ajax/libs/benchmark/0.3.0/benchmark.min.js new file mode 100644 index 000000000..b70da2f39 --- /dev/null +++ b/ajax/libs/benchmark/0.3.0/benchmark.min.js @@ -0,0 +1,8 @@ +/*! + * Benchmark.js + * Copyright 2010-2012 Mathias Bynens + * Based on JSLitmus.js, copyright Robert Kieffer + * Modified by John-David Dalton + * Available under MIT license + */ +(function(aF,v){var e=typeof define=="function"&&typeof define.amd=="object"&&define.amd&&define,s=typeof exports=="object"&&exports&&(typeof global=="object"&&global&&global==global.global&&(aF=global),exports),af=typeof require=="function"&&require,aC=0,E=Object.getOwnPropertyNames,W=Object.getOwnPropertyDescriptor,am={}.hasOwnProperty,O=Object.isExtensible||function(){return true},al={}.propertyIsEnumerable,X=Object.defineProperty,ao={}.toString,av="uid"+(+new Date),ae={},aH={"1":4096,"2":512,"3":64,"4":8,"5":0},K={"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},L={air:U(aF.runtime,"ScriptBridgingProxyObject"),argumentsClass:U(arguments,"Arguments"),browser:aM(aF,"document")&&aM(aF,"navigator"),charByIndex:("x"[0]+Object("x")[0])=="xx",charByOwnIndex:"x"[0]=="x"&&aa("x","0"),decompilation:!!(function(){try{return Function("return ("+(function(aQ){return{x:""+(1+aQ)+"",y:0}})+")")()(0).x==="1"}catch(aP){}}()),descriptors:!!(function(){try{var aQ={};return(X(aQ,aQ,aQ),"value" in W(aQ,aQ))}catch(aP){}}()),getAllKeys:!!(function(){try{return/\bvalueOf\b/.test(E(Object.prototype))}catch(aP){}}()),java:U(aF.java,"JavaPackage"),timeout:aM(aF,"setTimeout")&&aM(aF,"clearTimeout")},T={ns:Date,start:null,stop:null},H=!L.argumentsClass,y=!L.charByIndex,g=!L.charByOwnIndex,Q=Math.abs,V=Math.floor,t=Math.max,aK=Math.min,aD=Math.pow,F=Math.sqrt;function aO(aQ,aR,aP){var aS=this;if(aS&&aS.constructor!=aO){return new aO(aQ,aR,aP)}if(U(aQ,"Object")){aP=aQ}else{if(U(aQ,"Function")){aP=aR;aR=aQ}else{if(U(aR,"Object")){aP=aR;aR=null;aS.name=aQ}else{aS.name=aQ}}}ak(aS,aP);aS.id||(aS.id=++aC);aS.fn==null&&(aS.fn=aR);aS.stats=aj({},aS.stats);aS.times=aj({},aS.times)}function f(aP){var aQ=this;if(aQ&&aQ.constructor!=f){return new f(aP)}aQ.benchmark=aP;d(aQ)}function R(aP){var aQ=this;return(aQ&&aQ.constructor!=R)?new R(aP):(aP instanceof R)?aP:aj(aQ,typeof aP=="string"?{type:aP}:aP)}function aw(aQ,aP){var aR=this;if(aR&&aR.constructor!=aw){return new aw(aQ,aP)}if(U(aQ,"Object")){aP=aQ}else{aR.name=aQ}ak(aR,aP)}function aI(){var aV,aT=-1,aU=arguments.length,aP=x.call(this),aS=aP.length;while(++aT>>0)-aS+aT;while(++aWaT?aS-aT:0;while(aS--){delete aU[aR+aS]}aU.length=aR;return aY}function c(){var aT,aU,aR=-1,aQ=Object(this),aS=aQ.length>>>0,aP=V(aS/2);if(aS>1){while(++aR>>0,aP=[];aU=aA(aU);aU=aU<0?t(aT+aU,0):aK(aU,aT);aU--;aQ=aQ==null?aT:aA(aQ);aQ=aQ<0?t(aT+aQ,0):aK(aQ,aT);while((++aS,++aU)>>0;aS=aA(aS);aS=aS<0?t(aR+aS,0):aK(aS,aR);aQ=aK(t(aA(aQ),0),aR-aS);return J.call(aP,aS,aQ,x.call(arguments,2))}function aA(aP){aP=+aP;return aP===0||!isFinite(aP)?aP||0:aP-(aP%1)}function aG(){var aP=Object(this);J.call(aP,0,0,arguments);return aP.length}function S(aP){aP||(aP={});var aQ=aP.fn;(!aP.async&&aQ||function(){var aS=aP.benchmark,aT=aS._timerIds||(aS._timerIds=[]),aR=aT.length;aT.push(setTimeout(function(){aT.splice(aR,1);aT.length||delete aS._timerIds;aQ()},aS.delay*1000))})()}function p(){p=function(aR,aP){var aQ=e?define.amd:aO,aS=av+"createFunction";ai((e?"define.amd.":"Benchmark.")+aS+"=function("+aR+"){"+aP+"}");return[aQ[aS],delete aQ[aS]][0]};p=L.browser&&(p("",'return"'+av+'"')||ay)()==av?p:Function;return p.apply(null,arguments)}function q(){var aS,aP,aR=true,aQ=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"];(function(aV,aT){function aU(){this.valueOf=0}aU.prototype.valueOf=0;for(aT in new aU){aV+=aT=="valueOf"?1:0}for(aT in arguments){aT=="0"&&(aR=false)}aP=aV==2;aS=!aV}(0));q=function(ba,aY,aW){aW||(aW={});var aZ,bb,a6,aT,a7=!ba,a3=[ba,ba=Object(ba)][0],a5=aW.which,a8=a5=="all",a2=aY,a0=-1,a4=ba,aX=ba.length,a1=a8||a5=="own",aU={},aV=U(ba,"Function"),a9=aW.bind;ba=Object(ba);if(a9!==v){aY=function(be,bd,bc){return a2.call(a9,be,bd,bc)}}if(a8&&L.getAllKeys){for(a0=0,a6=E(ba),aX=a6.length;a0>>0){if(aR){aY=function(a1,a0){return aW.call(this,a1,a0,aS)};if(aT){aQ=aQ.split("")}else{aQ=[];while(++aVaT.mean+aT.moe?1:-1)*(aR=="fastest"?1:-1)});aP=B(aP,function(aT){return aP[0].compare(aT)==0})}}return aP||k(aS,function(aT,aV,aU){return aR.call(aQ,aV,aU,aS)?(aT.push(aV),aT):aT},[])}function az(aU,aT,aP){var aR=aT,aQ=-1,aS=(aU=Object(aU)).length>>>0;if(aP!==v){aT=function(aW,aV,aX){return aR.call(aP,aW,aV,aX)}}while(++aQ>>0;aP=(aP<0?t(0,aR+aP):aP)-1;while(++aP0&&ad.call(aS)}while((a3=aS.length)&&!("0" in aS))}else{while(++aX>>0;aR||(aR=": ");aL(aS,function(aW,aV){aQ.push(aP?aW:aV+aR+aW)});return aQ.join(aT||",")}function w(aR,aQ,aP){return k(aR,function(aS,aU,aT){aS[aT]=aQ.call(aP,aU,aT,aR);return aS},Array(Object(aR).length>>>0))}function M(aQ,aP){return w(aQ,function(aR){return aR==null?v:aR[aP]})}function k(aS,aR,aP){var aQ=arguments.length<3;az(aS,function(aU,aT){aP=aQ?(aQ=0,aU):aR(aP,aU,aT,aS)});return aP}function Y(){var aP=this;if(aP.running){ae.abortSuite=true;aP.reset();delete ae.abortSuite;aP.aborted=true;!ae.resetSuite&&G(aP,"abort");aP.emit("abort")}return aP}function r(aQ,aS,aP){var aT=this,aR=aO(aQ,aS,aP);aT.push(aR);aT.emit("add",aR);return aT}function at(aQ){var aR=this,aP=new aR.constructor(aj({},aR.options,aQ));ag(aR,function(aT,aS){if(!aa(aP,aS)){aP[aS]=aT&&U(aT.clone,"Function")?aT.clone():au(aT)}});return aP}function h(aR){var aQ=this,aP=new aQ.constructor;aP.push.apply(aP,B(aQ,aR));return aP}function j(){var aQ=this,aP=!ae.abortSuite;if(aQ.running&&aP){ae.resetSuite=true;aQ.abort();delete ae.resetSuite;aQ.aborted=false}else{if(aQ.aborted!==false||aQ.running!==false){aQ.aborted=aQ.running=false;aP&&G(aQ,"reset");aQ.emit("reset")}}return aQ}function u(aQ){var aR=this,aP=[];aR.reset();aR.running=true;aQ||(aQ={});G(aR,{name:"run",args:aQ,queued:aQ.queued,onStart:function(aT,aS){aR.emit("start",aS)},onCycle:function(aT,aS){if(aS.error){aR.emit("error",aS)}else{if(aS.cycles){aP.push(aS)}}return !aR.aborted&&aR.emit("cycle",aS)},onComplete:function(aT,aS){aR.running=false;aR.emit("complete",aS)}});return aR}function a(aQ,aS){var aR=this,aP=aR.events||(aR.events={});az(aQ.split(" "),function(aT){(aP[aT]||(aP[aT]=[])).push(aS)});return aR}function ab(aT){var aV=this,aU=R(aT),aQ=(arguments[0]=aU,arguments),aR=aV.events,aS=aR&&aR[aU.type]||[],aP=true;az(aS.slice(),function(aW){return(aP=aW.apply(aV,aQ)!==false)});return aP}function z(aQ,aS){var aR=this,aP=aR.events;az(aQ.split(" "),function(aV){var aU=aP&&aP[aV]||[],aT=o(aU,aS);if(aT>-1){aU.splice(aT,1)}});return aR}function m(aQ){var aR=this,aP=aR.events;az(aQ?aQ.split(" "):aP,function(aS){(aP&&aP[aS]||[]).length=0});return aR}function ap(){var aP=this;if(aP.running){if(L.timeout){az(aP._timerIds||[],clearTimeout);delete aP._timerIds}ae.abort=true;aP.reset();delete ae.abort;aP.aborted=true;aP.emit("abort")}return aP}function A(aQ){var aR=this,aP=new aR.constructor(aj({},aR,aQ));aP.options=aj({},aR.options,aQ);ag(aR,function(aT,aS){if(!aa(aP,aS)){aP[aS]=au(aT)}});return aP}function aJ(aQ){var aR=this.stats,aP=aQ.stats,aV=aR.size+aP.size-2,aS=(((aR.size-1)*aR.variance)+((aP.size-1)*aP.variance))/aV,aU=(aR.mean-aP.mean)/F(aS*(1/aR.size+1/aP.size)),aT=Q(1-aR.mean/aP.mean)<0.055&&aR.rme<3&&aP.rme<3;return !aT&&Q(aU)>l(aV)?(aU>0?-1:1):0}function Z(){var aT,aS,aP=this,aR=aj({},aP.constructor.prototype,aP.options),aQ=[[aR,aP]];if(aP.running&&!ae.abort){aP.abort();aP.aborted=aR.aborted}else{while((aS=aQ.pop())){ag(aS[0],function(aW,aV){var aU=aS[1][aV];if(aW&&U(aW,"Object")){aQ.push([aW,aU])}else{if(aW!==aU&&!(aW==null||U(aW,"Function"))){aS[1][aV]=aW;aT=true}}})}if(aT){aP.emit("reset")}}return aP}function aq(){var aU=this,aQ=aU.error,aV=aU.hz,aW=aU.id,aT=aU.stats,aS=aT.size,aR=L.java?"+/-":"\xb1",aP=aU.name||(typeof aW=="number"?"":aW);if(aQ){aP+=": "+an(aQ)}else{aP+=" x "+n(aV.toFixed(aV<100?2:0))+" ops/sec "+aR+aT.rme.toFixed(2)+"% ("+aS+" run"+(aS==1?"":"s")+" sampled)"}return aP}function d(){var aR,aQ=aO.options,aS={begin:"s$=new n$",end:"r$=(new n$-s$)/1e3",uid:av},aU=[{ns:T.ns,res:t(0.0015,aP("ms")),unit:"ms"}];d=function(aY){var ba=aY instanceof f&&[aY,aY=aY.benchmark][0],a9=aY._host||aY,a6=a9.fn,a1=ba?N(a6,"deferred"):"",a7=I(a6),a8=L.decompilation||a7,aW={setup:ah(a9.setup,aT("m$.setup()")),fn:ah(a6,aT("f$("+a1+")")),fnArg:a1,teardown:ah(a9.teardown,aT("m$.teardown()"))},a4=a9.compiled,a2=a9.count=aY.count,aZ=a9.id,a0=!(aW.fn||a7),aX=a9.name||(typeof aZ=="number"?"":aZ),a5=T.ns,bb=0;aY.minTime=a9.minTime||(a9.minTime=a9.options.minTime=aQ.minTime);if(aR){try{a5.nanoTime()}catch(a3){a5=T.ns=new aR.Packages.nano}}if(!a4){a4=a9.compiled=p(aT("t$"),ar(aT(ba?"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,n$=t$.ns;#{setup}\n#{begin};while(i$--){#{fn}\n}#{end};#{teardown}\nreturn{elapsed:r$,uid:"#{uid}"}'),aW));try{if(a0){throw new Error("The test, "+aX+", is empty. This may be the result of dead code removal.")}else{if(!ba){a9.count=1;a4=(a4.call(a9,T)||{}).uid==av&&a4;a9.count=a2}}}catch(a3){a4=false;aY.error=a3||new Error(String(a3));a9.count=a2}if(a8&&!a4&&!ba&&!a0){a4=p(aT("t$"),ar(aT((aY.error&&!a7?"var r$,s$,m$=this,f$=m$.fn,i$=m$.count":"function f$(){#{fn}\n}var r$,s$,i$=this.count")+",n$=t$.ns;#{setup}\n#{begin};while(i$--){f$()}#{end};#{teardown}\nreturn{elapsed:r$}"),aW));try{a9.count=1;a4.call(a9,T);a9.compiled=a4;a9.count=a2;delete aY.error}catch(a3){a9.count=a2;if(!aY.error){a9.compiled=a4;aY.error=a3||new Error(String(a3))}}}}if(!aY.error){bb=a4.call(ba||a9,T).elapsed}return bb};function aP(a1){var aW,aY,a0=30,a2=1000,aX=T.ns,aZ=[];while(a0--){if(a1=="us"){a2=1000000;if(aX.stop){aX.start();while(!(aW=aX.microseconds())){}}else{aY=T.ns();while(!(aW=aX()-aY)){}}}else{if(a1=="ns"){a2=1000000000;aY=aX.nanoTime();while(!(aW=aX.nanoTime()-aY)){}}else{aY=new aX;while(!(aW=new aX-aY)){}}}if(aW>0){aZ.push(aW)}else{aZ.push(Infinity);break}}return i(aZ)/a2}function aT(aW){return ar(aW,aS).replace(/\$/g,/\d+/.exec(av))}aL(aF.document&&document.applets||[],function(aW){return !(T.ns=aR="nanoTime" in aW&&aW)});try{if(typeof T.ns.nanoTime()=="number"){aU.push({ns:T.ns,res:aP("ns"),unit:"ns"})}}catch(aV){}try{if((T.ns=new (aF.chrome||aF.chromium).Interval)){aU.push({ns:T.ns,res:aP("us"),unit:"us"})}}catch(aV){}if((T.ns=(P("microtime")||{now:0}).now)){aU.push({ns:T.ns,res:aP("us"),unit:"us"})}T=k(aU,function(aX,aW){return aW.resaP.cycles){aP.cycles=a1}}aP.emit(aZ)}else{a2.count=aP.initCount}}else{if(aP.aborted){a2.abort()}}}function aR(a0,a9){var bc,ba,a6,a8,a3,a1,a2=+new Date,aZ=aP.times,a5=aP.aborted,a7=(aX+=a2-a9.times.timeStamp)/1000>aP.maxTime,bb=aW.push(a9.times.period),a4=function(be,bd){return be+aD(bd-bc,2)};if(a5||a9.hz==Infinity){a7=!(bb=aW.length=aV.length=0)}if(!a5){bc=i(aW);a1=k(aW,a4,0)/(bb-1)||0;a8=F(a1);a3=a8/F(bb);ba=a3*l(bb-1);a6=(ba/bc)*100||0;aj(aP.stats,{moe:ba,rme:a6,sem:a3,deviation:a8,mean:bc,size:bb,variance:a1});if(a7){a5=true;aP.running=false;aP.initCount=aU;aZ.elapsed=(a2-aZ.timeStamp)/1000}if(aP.hz!=Infinity){aZ.period=bc;aZ.cycle=bc*aP.count;aP.hz=1/bc}}if(aV.length<2&&!a7){aQ(1)}return !a5}aQ(aP.minSamples);G(aV,{name:"run",args:{async:aS},queued:true,onCycle:aR,onComplete:function(){aP.emit("complete")}})}function D(aY){aY||(aY={});var aS,aR,aU,aW,aT=aY.async,aQ=aY.benchmark,aV=aQ.count,aX=aY.deferred,aP=aQ.times;if(aQ.running){aQ.cycles++;aS=aX?aX.elapsed:d(aQ);aU=aQ.minTime;if(aQ.error){aQ.abort();aQ.emit("error")}}if(aQ.running){aP.cycle=aS;aW=aP.period=aS/aV;aQ.hz=1/aW;aQ.running=aS