@@ -0,0 +1,3919 @@
1+/*!
2+ * Benchmark.js v1.0.0 <http://benchmarkjs.com/>
3+ * Copyright 2010-2012 Mathias Bynens <http://mths.be/>
4+ * Based on JSLitmus.js, copyright Robert Kieffer <http://broofa.com/>
5+ * Modified by John-David Dalton <http://allyoucanleet.com/>
6+ * Available under MIT license <http://mths.be/mit>
7+ */
8+;(function(window, undefined) {
9+ 'use strict';
10+
11+ /** Used to assign each benchmark an incrimented id */
12+ var counter = 0;
13+
14+ /** Detect DOM document object */
15+ var doc = isHostType(window, 'document') && document;
16+
17+ /** Detect free variable `define` */
18+ var freeDefine = typeof define == 'function' &&
19+ typeof define.amd == 'object' && define.amd && define;
20+
21+ /** Detect free variable `exports` */
22+ var freeExports = typeof exports == 'object' && exports &&
23+ (typeof global == 'object' && global && global == global.global && (window = global), exports);
24+
25+ /** Detect free variable `require` */
26+ var freeRequire = typeof require == 'function' && require;
27+
28+ /** Used to crawl all properties regardless of enumerability */
29+ var getAllKeys = Object.getOwnPropertyNames;
30+
31+ /** Used to get property descriptors */
32+ var getDescriptor = Object.getOwnPropertyDescriptor;
33+
34+ /** Used in case an object doesn't have its own method */
35+ var hasOwnProperty = {}.hasOwnProperty;
36+
37+ /** Used to check if an object is extensible */
38+ var isExtensible = Object.isExtensible || function() { return true; };
39+
40+ /** Used to access Wade Simmons' Node microtime module */
41+ var microtimeObject = req('microtime');
42+
43+ /** Used to access the browser's high resolution timer */
44+ var perfObject = isHostType(window, 'performance') && performance;
45+
46+ /** Used to call the browser's high resolution timer */
47+ var perfName = perfObject && (
48+ perfObject.now && 'now' ||
49+ perfObject.webkitNow && 'webkitNow'
50+ );
51+
52+ /** Used to access Node's high resolution timer */
53+ var processObject = isHostType(window, 'process') && process;
54+
55+ /** Used to check if an own property is enumerable */
56+ var propertyIsEnumerable = {}.propertyIsEnumerable;
57+
58+ /** Used to set property descriptors */
59+ var setDescriptor = Object.defineProperty;
60+
61+ /** Used to resolve a value's internal [[Class]] */
62+ var toString = {}.toString;
63+
64+ /** Used to prevent a `removeChild` memory leak in IE < 9 */
65+ var trash = doc && doc.createElement('div');
66+
67+ /** Used to integrity check compiled tests */
68+ var uid = 'uid' + (+new Date);
69+
70+ /** Used to avoid infinite recursion when methods call each other */
71+ var calledBy = {};
72+
73+ /** Used to avoid hz of Infinity */
74+ var divisors = {
75+ '1': 4096,
76+ '2': 512,
77+ '3': 64,
78+ '4': 8,
79+ '5': 0
80+ };
81+
82+ /**
83+ * T-Distribution two-tailed critical values for 95% confidence
84+ * http://www.itl.nist.gov/div898/handbook/eda/section3/eda3672.htm
85+ */
86+ var tTable = {
87+ '1': 12.706,'2': 4.303, '3': 3.182, '4': 2.776, '5': 2.571, '6': 2.447,
88+ '7': 2.365, '8': 2.306, '9': 2.262, '10': 2.228, '11': 2.201, '12': 2.179,
89+ '13': 2.16, '14': 2.145, '15': 2.131, '16': 2.12, '17': 2.11, '18': 2.101,
90+ '19': 2.093, '20': 2.086, '21': 2.08, '22': 2.074, '23': 2.069, '24': 2.064,
91+ '25': 2.06, '26': 2.056, '27': 2.052, '28': 2.048, '29': 2.045, '30': 2.042,
92+ 'infinity': 1.96
93+ };
94+
95+ /**
96+ * Critical Mann-Whitney U-values for 95% confidence
97+ * http://www.saburchill.com/IBbiology/stats/003.html
98+ */
99+ var uTable = {
100+ '5': [0, 1, 2],
101+ '6': [1, 2, 3, 5],
102+ '7': [1, 3, 5, 6, 8],
103+ '8': [2, 4, 6, 8, 10, 13],
104+ '9': [2, 4, 7, 10, 12, 15, 17],
105+ '10': [3, 5, 8, 11, 14, 17, 20, 23],
106+ '11': [3, 6, 9, 13, 16, 19, 23, 26, 30],
107+ '12': [4, 7, 11, 14, 18, 22, 26, 29, 33, 37],
108+ '13': [4, 8, 12, 16, 20, 24, 28, 33, 37, 41, 45],
109+ '14': [5, 9, 13, 17, 22, 26, 31, 36, 40, 45, 50, 55],
110+ '15': [5, 10, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59, 64],
111+ '16': [6, 11, 15, 21, 26, 31, 37, 42, 47, 53, 59, 64, 70, 75],
112+ '17': [6, 11, 17, 22, 28, 34, 39, 45, 51, 57, 63, 67, 75, 81, 87],
113+ '18': [7, 12, 18, 24, 30, 36, 42, 48, 55, 61, 67, 74, 80, 86, 93, 99],
114+ '19': [7, 13, 19, 25, 32, 38, 45, 52, 58, 65, 72, 78, 85, 92, 99, 106, 113],
115+ '20': [8, 14, 20, 27, 34, 41, 48, 55, 62, 69, 76, 83, 90, 98, 105, 112, 119, 127],
116+ '21': [8, 15, 22, 29, 36, 43, 50, 58, 65, 73, 80, 88, 96, 103, 111, 119, 126, 134, 142],
117+ '22': [9, 16, 23, 30, 38, 45, 53, 61, 69, 77, 85, 93, 101, 109, 117, 125, 133, 141, 150, 158],
118+ '23': [9, 17, 24, 32, 40, 48, 56, 64, 73, 81, 89, 98, 106, 115, 123, 132, 140, 149, 157, 166, 175],
119+ '24': [10, 17, 25, 33, 42, 50, 59, 67, 76, 85, 94, 102, 111, 120, 129, 138, 147, 156, 165, 174, 183, 192],
120+ '25': [10, 18, 27, 35, 44, 53, 62, 71, 80, 89, 98, 107, 117, 126, 135, 145, 154, 163, 173, 182, 192, 201, 211],
121+ '26': [11, 19, 28, 37, 46, 55, 64, 74, 83, 93, 102, 112, 122, 132, 141, 151, 161, 171, 181, 191, 200, 210, 220, 230],
122+ '27': [11, 20, 29, 38, 48, 57, 67, 77, 87, 97, 107, 118, 125, 138, 147, 158, 168, 178, 188, 199, 209, 219, 230, 240, 250],
123+ '28': [12, 21, 30, 40, 50, 60, 70, 80, 90, 101, 111, 122, 132, 143, 154, 164, 175, 186, 196, 207, 218, 228, 239, 250, 261, 272],
124+ '29': [13, 22, 32, 42, 52, 62, 73, 83, 94, 105, 116, 127, 138, 149, 160, 171, 182, 193, 204, 215, 226, 238, 249, 260, 271, 282, 294],
125+ '30': [13, 23, 33, 43, 54, 65, 76, 87, 98, 109, 120, 131, 143, 154, 166, 177, 189, 200, 212, 223, 235, 247, 258, 270, 282, 293, 305, 317]
126+ };
127+
128+ /**
129+ * An object used to flag environments/features.
130+ *
131+ * @static
132+ * @memberOf Benchmark
133+ * @type Object
134+ */
135+ var support = {};
136+
137+ (function() {
138+
139+ /**
140+ * Detect Adobe AIR.
141+ *
142+ * @memberOf Benchmark.support
143+ * @type Boolean
144+ */
145+ support.air = isClassOf(window.runtime, 'ScriptBridgingProxyObject');
146+
147+ /**
148+ * Detect if `arguments` objects have the correct internal [[Class]] value.
149+ *
150+ * @memberOf Benchmark.support
151+ * @type Boolean
152+ */
153+ support.argumentsClass = isClassOf(arguments, 'Arguments');
154+
155+ /**
156+ * Detect if in a browser environment.
157+ *
158+ * @memberOf Benchmark.support
159+ * @type Boolean
160+ */
161+ support.browser = doc && isHostType(window, 'navigator');
162+
163+ /**
164+ * Detect if strings support accessing characters by index.
165+ *
166+ * @memberOf Benchmark.support
167+ * @type Boolean
168+ */
169+ support.charByIndex =
170+ // IE 8 supports indexes on string literals but not string objects
171+ ('x'[0] + Object('x')[0]) == 'xx';
172+
173+ /**
174+ * Detect if strings have indexes as own properties.
175+ *
176+ * @memberOf Benchmark.support
177+ * @type Boolean
178+ */
179+ support.charByOwnIndex =
180+ // Narwhal, Rhino, RingoJS, IE 8, and Opera < 10.52 support indexes on
181+ // strings but don't detect them as own properties
182+ support.charByIndex && hasKey('x', '0');
183+
184+ /**
185+ * Detect if Java is enabled/exposed.
186+ *
187+ * @memberOf Benchmark.support
188+ * @type Boolean
189+ */
190+ support.java = isClassOf(window.java, 'JavaPackage');
191+
192+ /**
193+ * Detect if the Timers API exists.
194+ *
195+ * @memberOf Benchmark.support
196+ * @type Boolean
197+ */
198+ support.timeout = isHostType(window, 'setTimeout') && isHostType(window, 'clearTimeout');
199+
200+ /**
201+ * Detect if functions support decompilation.
202+ *
203+ * @name decompilation
204+ * @memberOf Benchmark.support
205+ * @type Boolean
206+ */
207+ try {
208+ // Safari 2.x removes commas in object literals
209+ // from Function#toString results
210+ // http://webk.it/11609
211+ // Firefox 3.6 and Opera 9.25 strip grouping
212+ // parentheses from Function#toString results
213+ // http://bugzil.la/559438
214+ support.decompilation = Function(
215+ 'return (' + (function(x) { return { 'x': '' + (1 + x) + '', 'y': 0 }; }) + ')'
216+ )()(0).x === '1';
217+ } catch(e) {
218+ support.decompilation = false;
219+ }
220+
221+ /**
222+ * Detect ES5+ property descriptor API.
223+ *
224+ * @name descriptors
225+ * @memberOf Benchmark.support
226+ * @type Boolean
227+ */
228+ try {
229+ var o = {};
230+ support.descriptors = (setDescriptor(o, o, o), 'value' in getDescriptor(o, o));
231+ } catch(e) {
232+ support.descriptors = false;
233+ }
234+
235+ /**
236+ * Detect ES5+ Object.getOwnPropertyNames().
237+ *
238+ * @name getAllKeys
239+ * @memberOf Benchmark.support
240+ * @type Boolean
241+ */
242+ try {
243+ support.getAllKeys = /\bvalueOf\b/.test(getAllKeys(Object.prototype));
244+ } catch(e) {
245+ support.getAllKeys = false;
246+ }
247+
248+ /**
249+ * Detect if own properties are iterated before inherited properties (all but IE < 9).
250+ *
251+ * @name iteratesOwnLast
252+ * @memberOf Benchmark.support
253+ * @type Boolean
254+ */
255+ support.iteratesOwnFirst = (function() {
256+ var props = [];
257+ function ctor() { this.x = 1; }
258+ ctor.prototype = { 'y': 1 };
259+ for (var prop in new ctor) { props.push(prop); }
260+ return props[0] == 'x';
261+ }());
262+
263+ /**
264+ * Detect if a node's [[Class]] is resolvable (all but IE < 9)
265+ * and that the JS engine errors when attempting to coerce an object to a
266+ * string without a `toString` property value of `typeof` "function".
267+ *
268+ * @name nodeClass
269+ * @memberOf Benchmark.support
270+ * @type Boolean
271+ */
272+ try {
273+ support.nodeClass = ({ 'toString': 0 } + '', toString.call(doc || 0) != '[object Object]');
274+ } catch(e) {
275+ support.nodeClass = true;
276+ }
277+ }());
278+
279+ /**
280+ * Timer object used by `clock()` and `Deferred#resolve`.
281+ *
282+ * @private
283+ * @type Object
284+ */
285+ var timer = {
286+
287+ /**
288+ * The timer namespace object or constructor.
289+ *
290+ * @private
291+ * @memberOf timer
292+ * @type Function|Object
293+ */
294+ 'ns': Date,
295+
296+ /**
297+ * Starts the deferred timer.
298+ *
299+ * @private
300+ * @memberOf timer
301+ * @param {Object} deferred The deferred instance.
302+ */
303+ 'start': null, // lazy defined in `clock()`
304+
305+ /**
306+ * Stops the deferred timer.
307+ *
308+ * @private
309+ * @memberOf timer
310+ * @param {Object} deferred The deferred instance.
311+ */
312+ 'stop': null // lazy defined in `clock()`
313+ };
314+
315+ /** Shortcut for inverse results */
316+ var noArgumentsClass = !support.argumentsClass,
317+ noCharByIndex = !support.charByIndex,
318+ noCharByOwnIndex = !support.charByOwnIndex;
319+
320+ /** Math shortcuts */
321+ var abs = Math.abs,
322+ floor = Math.floor,
323+ max = Math.max,
324+ min = Math.min,
325+ pow = Math.pow,
326+ sqrt = Math.sqrt;
327+
328+ /*--------------------------------------------------------------------------*/
329+
330+ /**
331+ * The Benchmark constructor.
332+ *
333+ * @constructor
334+ * @param {String} name A name to identify the benchmark.
335+ * @param {Function|String} fn The test to benchmark.
336+ * @param {Object} [options={}] Options object.
337+ * @example
338+ *
339+ * // basic usage (the `new` operator is optional)
340+ * var bench = new Benchmark(fn);
341+ *
342+ * // or using a name first
343+ * var bench = new Benchmark('foo', fn);
344+ *
345+ * // or with options
346+ * var bench = new Benchmark('foo', fn, {
347+ *
348+ * // displayed by Benchmark#toString if `name` is not available
349+ * 'id': 'xyz',
350+ *
351+ * // called when the benchmark starts running
352+ * 'onStart': onStart,
353+ *
354+ * // called after each run cycle
355+ * 'onCycle': onCycle,
356+ *
357+ * // called when aborted
358+ * 'onAbort': onAbort,
359+ *
360+ * // called when a test errors
361+ * 'onError': onError,
362+ *
363+ * // called when reset
364+ * 'onReset': onReset,
365+ *
366+ * // called when the benchmark completes running
367+ * 'onComplete': onComplete,
368+ *
369+ * // compiled/called before the test loop
370+ * 'setup': setup,
371+ *
372+ * // compiled/called after the test loop
373+ * 'teardown': teardown
374+ * });
375+ *
376+ * // or name and options
377+ * var bench = new Benchmark('foo', {
378+ *
379+ * // a flag to indicate the benchmark is deferred
380+ * 'defer': true,
381+ *
382+ * // benchmark test function
383+ * 'fn': function(deferred) {
384+ * // call resolve() when the deferred test is finished
385+ * deferred.resolve();
386+ * }
387+ * });
388+ *
389+ * // or options only
390+ * var bench = new Benchmark({
391+ *
392+ * // benchmark name
393+ * 'name': 'foo',
394+ *
395+ * // benchmark test as a string
396+ * 'fn': '[1,2,3,4].sort()'
397+ * });
398+ *
399+ * // a test's `this` binding is set to the benchmark instance
400+ * var bench = new Benchmark('foo', function() {
401+ * 'My name is '.concat(this.name); // My name is foo
402+ * });
403+ */
404+ function Benchmark(name, fn, options) {
405+ var me = this;
406+
407+ // allow instance creation without the `new` operator
408+ if (me == null || me.constructor != Benchmark) {
409+ return new Benchmark(name, fn, options);
410+ }
411+ // juggle arguments
412+ if (isClassOf(name, 'Object')) {
413+ // 1 argument (options)
414+ options = name;
415+ }
416+ else if (isClassOf(name, 'Function')) {
417+ // 2 arguments (fn, options)
418+ options = fn;
419+ fn = name;
420+ }
421+ else if (isClassOf(fn, 'Object')) {
422+ // 2 arguments (name, options)
423+ options = fn;
424+ fn = null;
425+ me.name = name;
426+ }
427+ else {
428+ // 3 arguments (name, fn [, options])
429+ me.name = name;
430+ }
431+ setOptions(me, options);
432+ me.id || (me.id = ++counter);
433+ me.fn == null && (me.fn = fn);
434+ me.stats = deepClone(me.stats);
435+ me.times = deepClone(me.times);
436+ }
437+
438+ /**
439+ * The Deferred constructor.
440+ *
441+ * @constructor
442+ * @memberOf Benchmark
443+ * @param {Object} clone The cloned benchmark instance.
444+ */
445+ function Deferred(clone) {
446+ var me = this;
447+ if (me == null || me.constructor != Deferred) {
448+ return new Deferred(clone);
449+ }
450+ me.benchmark = clone;
451+ clock(me);
452+ }
453+
454+ /**
455+ * The Event constructor.
456+ *
457+ * @constructor
458+ * @memberOf Benchmark
459+ * @param {String|Object} type The event type.
460+ */
461+ function Event(type) {
462+ var me = this;
463+ return (me == null || me.constructor != Event)
464+ ? new Event(type)
465+ : (type instanceof Event)
466+ ? type
467+ : extend(me, { 'timeStamp': +new Date }, typeof type == 'string' ? { 'type': type } : type);
468+ }
469+
470+ /**
471+ * The Suite constructor.
472+ *
473+ * @constructor
474+ * @memberOf Benchmark
475+ * @param {String} name A name to identify the suite.
476+ * @param {Object} [options={}] Options object.
477+ * @example
478+ *
479+ * // basic usage (the `new` operator is optional)
480+ * var suite = new Benchmark.Suite;
481+ *
482+ * // or using a name first
483+ * var suite = new Benchmark.Suite('foo');
484+ *
485+ * // or with options
486+ * var suite = new Benchmark.Suite('foo', {
487+ *
488+ * // called when the suite starts running
489+ * 'onStart': onStart,
490+ *
491+ * // called between running benchmarks
492+ * 'onCycle': onCycle,
493+ *
494+ * // called when aborted
495+ * 'onAbort': onAbort,
496+ *
497+ * // called when a test errors
498+ * 'onError': onError,
499+ *
500+ * // called when reset
501+ * 'onReset': onReset,
502+ *
503+ * // called when the suite completes running
504+ * 'onComplete': onComplete
505+ * });
506+ */
507+ function Suite(name, options) {
508+ var me = this;
509+
510+ // allow instance creation without the `new` operator
511+ if (me == null || me.constructor != Suite) {
512+ return new Suite(name, options);
513+ }
514+ // juggle arguments
515+ if (isClassOf(name, 'Object')) {
516+ // 1 argument (options)
517+ options = name;
518+ } else {
519+ // 2 arguments (name [, options])
520+ me.name = name;
521+ }
522+ setOptions(me, options);
523+ }
524+
525+ /*--------------------------------------------------------------------------*/
526+
527+ /**
528+ * Note: Some array methods have been implemented in plain JavaScript to avoid
529+ * bugs in IE, Opera, Rhino, and Mobile Safari.
530+ *
531+ * IE compatibility mode and IE < 9 have buggy Array `shift()` and `splice()`
532+ * functions that fail to remove the last element, `object[0]`, of
533+ * array-like-objects even though the `length` property is set to `0`.
534+ * The `shift()` method is buggy in IE 8 compatibility mode, while `splice()`
535+ * is buggy regardless of mode in IE < 9 and buggy in compatibility mode in IE 9.
536+ *
537+ * In Opera < 9.50 and some older/beta Mobile Safari versions using `unshift()`
538+ * generically to augment the `arguments` object will pave the value at index 0
539+ * without incrimenting the other values's indexes.
540+ * https://github.com/documentcloud/underscore/issues/9
541+ *
542+ * Rhino and environments it powers, like Narwhal and RingoJS, may have
543+ * buggy Array `concat()`, `reverse()`, `shift()`, `slice()`, `splice()` and
544+ * `unshift()` functions that make sparse arrays non-sparse by assigning the
545+ * undefined indexes a value of undefined.
546+ * https://github.com/mozilla/rhino/commit/702abfed3f8ca043b2636efd31c14ba7552603dd
547+ */
548+
549+ /**
550+ * Creates an array containing the elements of the host array followed by the
551+ * elements of each argument in order.
552+ *
553+ * @memberOf Benchmark.Suite
554+ * @returns {Array} The new array.
555+ */
556+ function concat() {
557+ var value,
558+ j = -1,
559+ length = arguments.length,
560+ result = slice.call(this),
561+ index = result.length;
562+
563+ while (++j < length) {
564+ value = arguments[j];
565+ if (isClassOf(value, 'Array')) {
566+ for (var k = 0, l = value.length; k < l; k++, index++) {
567+ if (k in value) {
568+ result[index] = value[k];
569+ }
570+ }
571+ } else {
572+ result[index++] = value;
573+ }
574+ }
575+ return result;
576+ }
577+
578+ /**
579+ * Utility function used by `shift()`, `splice()`, and `unshift()`.
580+ *
581+ * @private
582+ * @param {Number} start The index to start inserting elements.
583+ * @param {Number} deleteCount The number of elements to delete from the insert point.
584+ * @param {Array} elements The elements to insert.
585+ * @returns {Array} An array of deleted elements.
586+ */
587+ function insert(start, deleteCount, elements) {
588+ // `result` should have its length set to the `deleteCount`
589+ // see https://bugs.ecmascript.org/show_bug.cgi?id=332
590+ var deleteEnd = start + deleteCount,
591+ elementCount = elements ? elements.length : 0,
592+ index = start - 1,
593+ length = start + elementCount,
594+ object = this,
595+ result = Array(deleteCount),
596+ tail = slice.call(object, deleteEnd);
597+
598+ // delete elements from the array
599+ while (++index < deleteEnd) {
600+ if (index in object) {
601+ result[index - start] = object[index];
602+ delete object[index];
603+ }
604+ }
605+ // insert elements
606+ index = start - 1;
607+ while (++index < length) {
608+ object[index] = elements[index - start];
609+ }
610+ // append tail elements
611+ start = index--;
612+ length = max(0, (object.length >>> 0) - deleteCount + elementCount);
613+ while (++index < length) {
614+ if ((index - start) in tail) {
615+ object[index] = tail[index - start];
616+ } else if (index in object) {
617+ delete object[index];
618+ }
619+ }
620+ // delete excess elements
621+ deleteCount = deleteCount > elementCount ? deleteCount - elementCount : 0;
622+ while (deleteCount--) {
623+ index = length + deleteCount;
624+ if (index in object) {
625+ delete object[index];
626+ }
627+ }
628+ object.length = length;
629+ return result;
630+ }
631+
632+ /**
633+ * Rearrange the host array's elements in reverse order.
634+ *
635+ * @memberOf Benchmark.Suite
636+ * @returns {Array} The reversed array.
637+ */
638+ function reverse() {
639+ var upperIndex,
640+ value,
641+ index = -1,
642+ object = Object(this),
643+ length = object.length >>> 0,
644+ middle = floor(length / 2);
645+
646+ if (length > 1) {
647+ while (++index < middle) {
648+ upperIndex = length - index - 1;
649+ value = upperIndex in object ? object[upperIndex] : uid;
650+ if (index in object) {
651+ object[upperIndex] = object[index];
652+ } else {
653+ delete object[upperIndex];
654+ }
655+ if (value != uid) {
656+ object[index] = value;
657+ } else {
658+ delete object[index];
659+ }
660+ }
661+ }
662+ return object;
663+ }
664+
665+ /**
666+ * Removes the first element of the host array and returns it.
667+ *
668+ * @memberOf Benchmark.Suite
669+ * @returns {Mixed} The first element of the array.
670+ */
671+ function shift() {
672+ return insert.call(this, 0, 1)[0];
673+ }
674+
675+ /**
676+ * Creates an array of the host array's elements from the start index up to,
677+ * but not including, the end index.
678+ *
679+ * @memberOf Benchmark.Suite
680+ * @param {Number} start The starting index.
681+ * @param {Number} end The end index.
682+ * @returns {Array} The new array.
683+ */
684+ function slice(start, end) {
685+ var index = -1,
686+ object = Object(this),
687+ length = object.length >>> 0,
688+ result = [];
689+
690+ start = toInteger(start);
691+ start = start < 0 ? max(length + start, 0) : min(start, length);
692+ start--;
693+ end = end == null ? length : toInteger(end);
694+ end = end < 0 ? max(length + end, 0) : min(end, length);
695+
696+ while ((++index, ++start) < end) {
697+ if (start in object) {
698+ result[index] = object[start];
699+ }
700+ }
701+ return result;
702+ }
703+
704+ /**
705+ * Allows removing a range of elements and/or inserting elements into the
706+ * host array.
707+ *
708+ * @memberOf Benchmark.Suite
709+ * @param {Number} start The start index.
710+ * @param {Number} deleteCount The number of elements to delete.
711+ * @param {Mixed} [val1, val2, ...] values to insert at the `start` index.
712+ * @returns {Array} An array of removed elements.
713+ */
714+ function splice(start, deleteCount) {
715+ var object = Object(this),
716+ length = object.length >>> 0;
717+
718+ start = toInteger(start);
719+ start = start < 0 ? max(length + start, 0) : min(start, length);
720+
721+ // support the de-facto SpiderMonkey extension
722+ // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice#Parameters
723+ // https://bugs.ecmascript.org/show_bug.cgi?id=429
724+ deleteCount = arguments.length == 1
725+ ? length - start
726+ : min(max(toInteger(deleteCount), 0), length - start);
727+
728+ return insert.call(object, start, deleteCount, slice.call(arguments, 2));
729+ }
730+
731+ /**
732+ * Converts the specified `value` to an integer.
733+ *
734+ * @private
735+ * @param {Mixed} value The value to convert.
736+ * @returns {Number} The resulting integer.
737+ */
738+ function toInteger(value) {
739+ value = +value;
740+ return value === 0 || !isFinite(value) ? value || 0 : value - (value % 1);
741+ }
742+
743+ /**
744+ * Appends arguments to the host array.
745+ *
746+ * @memberOf Benchmark.Suite
747+ * @returns {Number} The new length.
748+ */
749+ function unshift() {
750+ var object = Object(this);
751+ insert.call(object, 0, 0, arguments);
752+ return object.length;
753+ }
754+
755+ /*--------------------------------------------------------------------------*/
756+
757+ /**
758+ * A generic `Function#bind` like method.
759+ *
760+ * @private
761+ * @param {Function} fn The function to be bound to `thisArg`.
762+ * @param {Mixed} thisArg The `this` binding for the given function.
763+ * @returns {Function} The bound function.
764+ */
765+ function bind(fn, thisArg) {
766+ return function() { fn.apply(thisArg, arguments); };
767+ }
768+
769+ /**
770+ * Creates a function from the given arguments string and body.
771+ *
772+ * @private
773+ * @param {String} args The comma separated function arguments.
774+ * @param {String} body The function body.
775+ * @returns {Function} The new function.
776+ */
777+ function createFunction() {
778+ // lazy define
779+ createFunction = function(args, body) {
780+ var result,
781+ anchor = freeDefine ? define.amd : Benchmark,
782+ prop = uid + 'createFunction';
783+
784+ runScript((freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '=function(' + args + '){' + body + '}');
785+ result = anchor[prop];
786+ delete anchor[prop];
787+ return result;
788+ };
789+ // fix JaegerMonkey bug
790+ // http://bugzil.la/639720
791+ createFunction = support.browser && (createFunction('', 'return"' + uid + '"') || noop)() == uid ? createFunction : Function;
792+ return createFunction.apply(null, arguments);
793+ }
794+
795+ /**
796+ * Delay the execution of a function based on the benchmark's `delay` property.
797+ *
798+ * @private
799+ * @param {Object} bench The benchmark instance.
800+ * @param {Object} fn The function to execute.
801+ */
802+ function delay(bench, fn) {
803+ bench._timerId = setTimeout(fn, bench.delay * 1e3);
804+ }
805+
806+ /**
807+ * Destroys the given element.
808+ *
809+ * @private
810+ * @param {Element} element The element to destroy.
811+ */
812+ function destroyElement(element) {
813+ trash.appendChild(element);
814+ trash.innerHTML = '';
815+ }
816+
817+ /**
818+ * Iterates over an object's properties, executing the `callback` for each.
819+ * Callbacks may terminate the loop by explicitly returning `false`.
820+ *
821+ * @private
822+ * @param {Object} object The object to iterate over.
823+ * @param {Function} callback The function executed per own property.
824+ * @param {Object} options The options object.
825+ * @returns {Object} Returns the object iterated over.
826+ */
827+ function forProps() {
828+ var forShadowed,
829+ skipSeen,
830+ forArgs = true,
831+ shadowed = ['constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf'];
832+
833+ (function(enumFlag, key) {
834+ // must use a non-native constructor to catch the Safari 2 issue
835+ function Klass() { this.valueOf = 0; };
836+ Klass.prototype.valueOf = 0;
837+ // check various for-in bugs
838+ for (key in new Klass) {
839+ enumFlag += key == 'valueOf' ? 1 : 0;
840+ }
841+ // check if `arguments` objects have non-enumerable indexes
842+ for (key in arguments) {
843+ key == '0' && (forArgs = false);
844+ }
845+ // Safari 2 iterates over shadowed properties twice
846+ // http://replay.waybackmachine.org/20090428222941/http://tobielangel.com/2007/1/29/for-in-loop-broken-in-safari/
847+ skipSeen = enumFlag == 2;
848+ // IE < 9 incorrectly makes an object's properties non-enumerable if they have
849+ // the same name as other non-enumerable properties in its prototype chain.
850+ forShadowed = !enumFlag;
851+ }(0));
852+
853+ // lazy define
854+ forProps = function(object, callback, options) {
855+ options || (options = {});
856+
857+ var result = object;
858+ object = Object(object);
859+
860+ var ctor,
861+ key,
862+ keys,
863+ skipCtor,
864+ done = !result,
865+ which = options.which,
866+ allFlag = which == 'all',
867+ index = -1,
868+ iteratee = object,
869+ length = object.length,
870+ ownFlag = allFlag || which == 'own',
871+ seen = {},
872+ skipProto = isClassOf(object, 'Function'),
873+ thisArg = options.bind;
874+
875+ if (thisArg !== undefined) {
876+ callback = bind(callback, thisArg);
877+ }
878+ // iterate all properties
879+ if (allFlag && support.getAllKeys) {
880+ for (index = 0, keys = getAllKeys(object), length = keys.length; index < length; index++) {
881+ key = keys[index];
882+ if (callback(object[key], key, object) === false) {
883+ break;
884+ }
885+ }
886+ }
887+ // else iterate only enumerable properties
888+ else {
889+ for (key in object) {
890+ // Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1
891+ // (if the prototype or a property on the prototype has been set)
892+ // incorrectly set a function's `prototype` property [[Enumerable]] value
893+ // to `true`. Because of this we standardize on skipping the `prototype`
894+ // property of functions regardless of their [[Enumerable]] value.
895+ if ((done =
896+ !(skipProto && key == 'prototype') &&
897+ !(skipSeen && (hasKey(seen, key) || !(seen[key] = true))) &&
898+ (!ownFlag || ownFlag && hasKey(object, key)) &&
899+ callback(object[key], key, object) === false)) {
900+ break;
901+ }
902+ }
903+ // in IE < 9 strings don't support accessing characters by index
904+ if (!done && (forArgs && isArguments(object) ||
905+ ((noCharByIndex || noCharByOwnIndex) && isClassOf(object, 'String') &&
906+ (iteratee = noCharByIndex ? object.split('') : object)))) {
907+ while (++index < length) {
908+ if ((done =
909+ callback(iteratee[index], String(index), object) === false)) {
910+ break;
911+ }
912+ }
913+ }
914+ if (!done && forShadowed) {
915+ // Because IE < 9 can't set the `[[Enumerable]]` attribute of an existing
916+ // property and the `constructor` property of a prototype defaults to
917+ // non-enumerable, we manually skip the `constructor` property when we
918+ // think we are iterating over a `prototype` object.
919+ ctor = object.constructor;
920+ skipCtor = ctor && ctor.prototype && ctor.prototype.constructor === ctor;
921+ for (index = 0; index < 7; index++) {
922+ key = shadowed[index];
923+ if (!(skipCtor && key == 'constructor') &&
924+ hasKey(object, key) &&
925+ callback(object[key], key, object) === false) {
926+ break;
927+ }
928+ }
929+ }
930+ }
931+ return result;
932+ };
933+ return forProps.apply(null, arguments);
934+ }
935+
936+ /**
937+ * Gets the name of the first argument from a function's source.
938+ *
939+ * @private
940+ * @param {Function} fn The function.
941+ * @returns {String} The argument name.
942+ */
943+ function getFirstArgument(fn) {
944+ return (!hasKey(fn, 'toString') &&
945+ (/^[\s(]*function[^(]*\(([^\s,)]+)/.exec(fn) || 0)[1]) || '';
946+ }
947+
948+ /**
949+ * Computes the arithmetic mean of a sample.
950+ *
951+ * @private
952+ * @param {Array} sample The sample.
953+ * @returns {Number} The mean.
954+ */
955+ function getMean(sample) {
956+ return reduce(sample, function(sum, x) {
957+ return sum + x;
958+ }) / sample.length || 0;
959+ }
960+
961+ /**
962+ * Gets the source code of a function.
963+ *
964+ * @private
965+ * @param {Function} fn The function.
966+ * @param {String} altSource A string used when a function's source code is unretrievable.
967+ * @returns {String} The function's source code.
968+ */
969+ function getSource(fn, altSource) {
970+ var result = altSource;
971+ if (isStringable(fn)) {
972+ result = String(fn);
973+ } else if (support.decompilation) {
974+ // escape the `{` for Firefox 1
975+ result = (/^[^{]+\{([\s\S]*)}\s*$/.exec(fn) || 0)[1];
976+ }
977+ // trim string
978+ result = (result || '').replace(/^\s+|\s+$/g, '');
979+
980+ // detect strings containing only the "use strict" directive
981+ return /^(?:\/\*+[\w|\W]*?\*\/|\/\/.*?[\n\r\u2028\u2029]|\s)*(["'])use strict\1;?$/.test(result)
982+ ? ''
983+ : result;
984+ }
985+
986+ /**
987+ * Checks if a value is an `arguments` object.
988+ *
989+ * @private
990+ * @param {Mixed} value The value to check.
991+ * @returns {Boolean} Returns `true` if the value is an `arguments` object, else `false`.
992+ */
993+ function isArguments() {
994+ // lazy define
995+ isArguments = function(value) {
996+ return toString.call(value) == '[object Arguments]';
997+ };
998+ if (noArgumentsClass) {
999+ isArguments = function(value) {
1000+ return hasKey(value, 'callee') &&
1001+ !(propertyIsEnumerable && propertyIsEnumerable.call(value, 'callee'));
1002+ };
1003+ }
1004+ return isArguments(arguments[0]);
1005+ }
1006+
1007+ /**
1008+ * Checks if an object is of the specified class.
1009+ *
1010+ * @private
1011+ * @param {Mixed} value The value to check.
1012+ * @param {String} name The name of the class.
1013+ * @returns {Boolean} Returns `true` if the value is of the specified class, else `false`.
1014+ */
1015+ function isClassOf(value, name) {
1016+ return value != null && toString.call(value) == '[object ' + name + ']';
1017+ }
1018+
1019+ /**
1020+ * Host objects can return type values that are different from their actual
1021+ * data type. The objects we are concerned with usually return non-primitive
1022+ * types of object, function, or unknown.
1023+ *
1024+ * @private
1025+ * @param {Mixed} object The owner of the property.
1026+ * @param {String} property The property to check.
1027+ * @returns {Boolean} Returns `true` if the property value is a non-primitive, else `false`.
1028+ */
1029+ function isHostType(object, property) {
1030+ var type = object != null ? typeof object[property] : 'number';
1031+ return !/^(?:boolean|number|string|undefined)$/.test(type) &&
1032+ (type == 'object' ? !!object[property] : true);
1033+ }
1034+
1035+ /**
1036+ * Checks if a given `value` is an object created by the `Object` constructor
1037+ * assuming objects created by the `Object` constructor have no inherited
1038+ * enumerable properties and that there are no `Object.prototype` extensions.
1039+ *
1040+ * @private
1041+ * @param {Mixed} value The value to check.
1042+ * @returns {Boolean} Returns `true` if the `value` is a plain `Object` object, else `false`.
1043+ */
1044+ function isPlainObject(value) {
1045+ // avoid non-objects and false positives for `arguments` objects in IE < 9
1046+ var result = false;
1047+ if (!(value && typeof value == 'object') || isArguments(value)) {
1048+ return result;
1049+ }
1050+ // IE < 9 presents DOM nodes as `Object` objects except they have `toString`
1051+ // methods that are `typeof` "string" and still can coerce nodes to strings.
1052+ // Also check that the constructor is `Object` (i.e. `Object instanceof Object`)
1053+ var ctor = value.constructor;
1054+ if ((support.nodeClass || !(typeof value.toString != 'function' && typeof (value + '') == 'string')) &&
1055+ (!isClassOf(ctor, 'Function') || ctor instanceof ctor)) {
1056+ // In most environments an object's own properties are iterated before
1057+ // its inherited properties. If the last iterated property is an object's
1058+ // own property then there are no inherited enumerable properties.
1059+ if (support.iteratesOwnFirst) {
1060+ forProps(value, function(subValue, subKey) {
1061+ result = subKey;
1062+ });
1063+ return result === false || hasKey(value, result);
1064+ }
1065+ // IE < 9 iterates inherited properties before own properties. If the first
1066+ // iterated property is an object's own property then there are no inherited
1067+ // enumerable properties.
1068+ forProps(value, function(subValue, subKey) {
1069+ result = !hasKey(value, subKey);
1070+ return false;
1071+ });
1072+ return result === false;
1073+ }
1074+ return result;
1075+ }
1076+
1077+ /**
1078+ * Checks if a value can be safely coerced to a string.
1079+ *
1080+ * @private
1081+ * @param {Mixed} value The value to check.
1082+ * @returns {Boolean} Returns `true` if the value can be coerced, else `false`.
1083+ */
1084+ function isStringable(value) {
1085+ return hasKey(value, 'toString') || isClassOf(value, 'String');
1086+ }
1087+
1088+ /**
1089+ * Wraps a function and passes `this` to the original function as the
1090+ * first argument.
1091+ *
1092+ * @private
1093+ * @param {Function} fn The function to be wrapped.
1094+ * @returns {Function} The new function.
1095+ */
1096+ function methodize(fn) {
1097+ return function() {
1098+ var args = [this];
1099+ args.push.apply(args, arguments);
1100+ return fn.apply(null, args);
1101+ };
1102+ }
1103+
1104+ /**
1105+ * A no-operation function.
1106+ *
1107+ * @private
1108+ */
1109+ function noop() {
1110+ // no operation performed
1111+ }
1112+
1113+ /**
1114+ * A wrapper around require() to suppress `module missing` errors.
1115+ *
1116+ * @private
1117+ * @param {String} id The module id.
1118+ * @returns {Mixed} The exported module or `null`.
1119+ */
1120+ function req(id) {
1121+ try {
1122+ var result = freeExports && freeRequire(id);
1123+ } catch(e) { }
1124+ return result || null;
1125+ }
1126+
1127+ /**
1128+ * Runs a snippet of JavaScript via script injection.
1129+ *
1130+ * @private
1131+ * @param {String} code The code to run.
1132+ */
1133+ function runScript(code) {
1134+ var anchor = freeDefine ? define.amd : Benchmark,
1135+ script = doc.createElement('script'),
1136+ sibling = doc.getElementsByTagName('script')[0],
1137+ parent = sibling.parentNode,
1138+ prop = uid + 'runScript',
1139+ prefix = '(' + (freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '||function(){})();';
1140+
1141+ // Firefox 2.0.0.2 cannot use script injection as intended because it executes
1142+ // asynchronously, but that's OK because script injection is only used to avoid
1143+ // the previously commented JaegerMonkey bug.
1144+ try {
1145+ // remove the inserted script *before* running the code to avoid differences
1146+ // in the expected script element count/order of the document.
1147+ script.appendChild(doc.createTextNode(prefix + code));
1148+ anchor[prop] = function() { destroyElement(script); };
1149+ } catch(e) {
1150+ parent = parent.cloneNode(false);
1151+ sibling = null;
1152+ script.text = code;
1153+ }
1154+ parent.insertBefore(script, sibling);
1155+ delete anchor[prop];
1156+ }
1157+
1158+ /**
1159+ * A helper function for setting options/event handlers.
1160+ *
1161+ * @private
1162+ * @param {Object} bench The benchmark instance.
1163+ * @param {Object} [options={}] Options object.
1164+ */
1165+ function setOptions(bench, options) {
1166+ options = extend({}, bench.constructor.options, options);
1167+ bench.options = forOwn(options, function(value, key) {
1168+ if (value != null) {
1169+ // add event listeners
1170+ if (/^on[A-Z]/.test(key)) {
1171+ forEach(key.split(' '), function(key) {
1172+ bench.on(key.slice(2).toLowerCase(), value);
1173+ });
1174+ } else if (!hasKey(bench, key)) {
1175+ bench[key] = deepClone(value);
1176+ }
1177+ }
1178+ });
1179+ }
1180+
1181+ /*--------------------------------------------------------------------------*/
1182+
1183+ /**
1184+ * Handles cycling/completing the deferred benchmark.
1185+ *
1186+ * @memberOf Benchmark.Deferred
1187+ */
1188+ function resolve() {
1189+ var me = this,
1190+ clone = me.benchmark,
1191+ bench = clone._original;
1192+
1193+ if (bench.aborted) {
1194+ // cycle() -> clone cycle/complete event -> compute()'s invoked bench.run() cycle/complete
1195+ me.teardown();
1196+ clone.running = false;
1197+ cycle(me);
1198+ }
1199+ else if (++me.cycles < clone.count) {
1200+ // continue the test loop
1201+ if (support.timeout) {
1202+ // use setTimeout to avoid a call stack overflow if called recursively
1203+ setTimeout(function() { clone.compiled.call(me, timer); }, 0);
1204+ } else {
1205+ clone.compiled.call(me, timer);
1206+ }
1207+ }
1208+ else {
1209+ timer.stop(me);
1210+ me.teardown();
1211+ delay(clone, function() { cycle(me); });
1212+ }
1213+ }
1214+
1215+ /*--------------------------------------------------------------------------*/
1216+
1217+ /**
1218+ * A deep clone utility.
1219+ *
1220+ * @static
1221+ * @memberOf Benchmark
1222+ * @param {Mixed} value The value to clone.
1223+ * @returns {Mixed} The cloned value.
1224+ */
1225+ function deepClone(value) {
1226+ var accessor,
1227+ circular,
1228+ clone,
1229+ ctor,
1230+ descriptor,
1231+ extensible,
1232+ key,
1233+ length,
1234+ markerKey,
1235+ parent,
1236+ result,
1237+ source,
1238+ subIndex,
1239+ data = { 'value': value },
1240+ index = 0,
1241+ marked = [],
1242+ queue = { 'length': 0 },
1243+ unmarked = [];
1244+
1245+ /**
1246+ * An easily detectable decorator for cloned values.
1247+ */
1248+ function Marker(object) {
1249+ this.raw = object;
1250+ }
1251+
1252+ /**
1253+ * The callback used by `forProps()`.
1254+ */
1255+ function forPropsCallback(subValue, subKey) {
1256+ // exit early to avoid cloning the marker
1257+ if (subValue && subValue.constructor == Marker) {
1258+ return;
1259+ }
1260+ // add objects to the queue
1261+ if (subValue === Object(subValue)) {
1262+ queue[queue.length++] = { 'key': subKey, 'parent': clone, 'source': value };
1263+ }
1264+ // assign non-objects
1265+ else {
1266+ try {
1267+ // will throw an error in strict mode if the property is read-only
1268+ clone[subKey] = subValue;
1269+ } catch(e) { }
1270+ }
1271+ }
1272+
1273+ /**
1274+ * Gets an available marker key for the given object.
1275+ */
1276+ function getMarkerKey(object) {
1277+ // avoid collisions with existing keys
1278+ var result = uid;
1279+ while (object[result] && object[result].constructor != Marker) {
1280+ result += 1;
1281+ }
1282+ return result;
1283+ }
1284+
1285+ do {
1286+ key = data.key;
1287+ parent = data.parent;
1288+ source = data.source;
1289+ clone = value = source ? source[key] : data.value;
1290+ accessor = circular = descriptor = false;
1291+
1292+ // create a basic clone to filter out functions, DOM elements, and
1293+ // other non `Object` objects
1294+ if (value === Object(value)) {
1295+ // use custom deep clone function if available
1296+ if (isClassOf(value.deepClone, 'Function')) {
1297+ clone = value.deepClone();
1298+ } else {
1299+ ctor = value.constructor;
1300+ switch (toString.call(value)) {
1301+ case '[object Array]':
1302+ clone = new ctor(value.length);
1303+ break;
1304+
1305+ case '[object Boolean]':
1306+ clone = new ctor(value == true);
1307+ break;
1308+
1309+ case '[object Date]':
1310+ clone = new ctor(+value);
1311+ break;
1312+
1313+ case '[object Object]':
1314+ isPlainObject(value) && (clone = {});
1315+ break;
1316+
1317+ case '[object Number]':
1318+ case '[object String]':
1319+ clone = new ctor(value);
1320+ break;
1321+
1322+ case '[object RegExp]':
1323+ clone = ctor(value.source,
1324+ (value.global ? 'g' : '') +
1325+ (value.ignoreCase ? 'i' : '') +
1326+ (value.multiline ? 'm' : ''));
1327+ }
1328+ }
1329+ // continue clone if `value` doesn't have an accessor descriptor
1330+ // http://es5.github.com/#x8.10.1
1331+ if (clone && clone != value &&
1332+ !(descriptor = source && support.descriptors && getDescriptor(source, key),
1333+ accessor = descriptor && (descriptor.get || descriptor.set))) {
1334+ // use an existing clone (circular reference)
1335+ if ((extensible = isExtensible(value))) {
1336+ markerKey = getMarkerKey(value);
1337+ if (value[markerKey]) {
1338+ circular = clone = value[markerKey].raw;
1339+ }
1340+ } else {
1341+ // for frozen/sealed objects
1342+ for (subIndex = 0, length = unmarked.length; subIndex < length; subIndex++) {
1343+ data = unmarked[subIndex];
1344+ if (data.object === value) {
1345+ circular = clone = data.clone;
1346+ break;
1347+ }
1348+ }
1349+ }
1350+ if (!circular) {
1351+ // mark object to allow quickly detecting circular references and tie it to its clone
1352+ if (extensible) {
1353+ value[markerKey] = new Marker(clone);
1354+ marked.push({ 'key': markerKey, 'object': value });
1355+ } else {
1356+ // for frozen/sealed objects
1357+ unmarked.push({ 'clone': clone, 'object': value });
1358+ }
1359+ // iterate over object properties
1360+ forProps(value, forPropsCallback, { 'which': 'all' });
1361+ }
1362+ }
1363+ }
1364+ if (parent) {
1365+ // for custom property descriptors
1366+ if (accessor || (descriptor && !(descriptor.configurable && descriptor.enumerable && descriptor.writable))) {
1367+ if ('value' in descriptor) {
1368+ descriptor.value = clone;
1369+ }
1370+ setDescriptor(parent, key, descriptor);
1371+ }
1372+ // for default property descriptors
1373+ else {
1374+ parent[key] = clone;
1375+ }
1376+ } else {
1377+ result = clone;
1378+ }
1379+ } while ((data = queue[index++]));
1380+
1381+ // remove markers
1382+ for (index = 0, length = marked.length; index < length; index++) {
1383+ data = marked[index];
1384+ delete data.object[data.key];
1385+ }
1386+ return result;
1387+ }
1388+
1389+ /**
1390+ * An iteration utility for arrays and objects.
1391+ * Callbacks may terminate the loop by explicitly returning `false`.
1392+ *
1393+ * @static
1394+ * @memberOf Benchmark
1395+ * @param {Array|Object} object The object to iterate over.
1396+ * @param {Function} callback The function called per iteration.
1397+ * @param {Mixed} thisArg The `this` binding for the callback.
1398+ * @returns {Array|Object} Returns the object iterated over.
1399+ */
1400+ function each(object, callback, thisArg) {
1401+ var result = object;
1402+ object = Object(object);
1403+
1404+ var fn = callback,
1405+ index = -1,
1406+ length = object.length,
1407+ isSnapshot = !!(object.snapshotItem && (length = object.snapshotLength)),
1408+ isSplittable = (noCharByIndex || noCharByOwnIndex) && isClassOf(object, 'String'),
1409+ isConvertable = isSnapshot || isSplittable || 'item' in object,
1410+ origObject = object;
1411+
1412+ // in Opera < 10.5 `hasKey(object, 'length')` returns `false` for NodeLists
1413+ if (length === length >>> 0) {
1414+ if (isConvertable) {
1415+ // the third argument of the callback is the original non-array object
1416+ callback = function(value, index) {
1417+ return fn.call(this, value, index, origObject);
1418+ };
1419+ // in IE < 9 strings don't support accessing characters by index
1420+ if (isSplittable) {
1421+ object = object.split('');
1422+ } else {
1423+ object = [];
1424+ while (++index < length) {
1425+ // in Safari 2 `index in object` is always `false` for NodeLists
1426+ object[index] = isSnapshot ? result.snapshotItem(index) : result[index];
1427+ }
1428+ }
1429+ }
1430+ forEach(object, callback, thisArg);
1431+ } else {
1432+ forOwn(object, callback, thisArg);
1433+ }
1434+ return result;
1435+ }
1436+
1437+ /**
1438+ * Copies enumerable properties from the source(s) object to the destination object.
1439+ *
1440+ * @static
1441+ * @memberOf Benchmark
1442+ * @param {Object} destination The destination object.
1443+ * @param {Object} [source={}] The source object.
1444+ * @returns {Object} The destination object.
1445+ */
1446+ function extend(destination, source) {
1447+ // Chrome < 14 incorrectly sets `destination` to `undefined` when we `delete arguments[0]`
1448+ // http://code.google.com/p/v8/issues/detail?id=839
1449+ var result = destination;
1450+ delete arguments[0];
1451+
1452+ forEach(arguments, function(source) {
1453+ forProps(source, function(value, key) {
1454+ result[key] = value;
1455+ });
1456+ });
1457+ return result;
1458+ }
1459+
1460+ /**
1461+ * A generic `Array#filter` like method.
1462+ *
1463+ * @static
1464+ * @memberOf Benchmark
1465+ * @param {Array} array The array to iterate over.
1466+ * @param {Function|String} callback The function/alias called per iteration.
1467+ * @param {Mixed} thisArg The `this` binding for the callback.
1468+ * @returns {Array} A new array of values that passed callback filter.
1469+ * @example
1470+ *
1471+ * // get odd numbers
1472+ * Benchmark.filter([1, 2, 3, 4, 5], function(n) {
1473+ * return n % 2;
1474+ * }); // -> [1, 3, 5];
1475+ *
1476+ * // get fastest benchmarks
1477+ * Benchmark.filter(benches, 'fastest');
1478+ *
1479+ * // get slowest benchmarks
1480+ * Benchmark.filter(benches, 'slowest');
1481+ *
1482+ * // get benchmarks that completed without erroring
1483+ * Benchmark.filter(benches, 'successful');
1484+ */
1485+ function filter(array, callback, thisArg) {
1486+ var result;
1487+
1488+ if (callback == 'successful') {
1489+ // callback to exclude those that are errored, unrun, or have hz of Infinity
1490+ callback = function(bench) { return bench.cycles && isFinite(bench.hz); };
1491+ }
1492+ else if (callback == 'fastest' || callback == 'slowest') {
1493+ // get successful, sort by period + margin of error, and filter fastest/slowest
1494+ result = filter(array, 'successful').sort(function(a, b) {
1495+ a = a.stats; b = b.stats;
1496+ return (a.mean + a.moe > b.mean + b.moe ? 1 : -1) * (callback == 'fastest' ? 1 : -1);
1497+ });
1498+ result = filter(result, function(bench) {
1499+ return result[0].compare(bench) == 0;
1500+ });
1501+ }
1502+ return result || reduce(array, function(result, value, index) {
1503+ return callback.call(thisArg, value, index, array) ? (result.push(value), result) : result;
1504+ }, []);
1505+ }
1506+
1507+ /**
1508+ * A generic `Array#forEach` like method.
1509+ * Callbacks may terminate the loop by explicitly returning `false`.
1510+ *
1511+ * @static
1512+ * @memberOf Benchmark
1513+ * @param {Array} array The array to iterate over.
1514+ * @param {Function} callback The function called per iteration.
1515+ * @param {Mixed} thisArg The `this` binding for the callback.
1516+ * @returns {Array} Returns the array iterated over.
1517+ */
1518+ function forEach(array, callback, thisArg) {
1519+ var index = -1,
1520+ length = (array = Object(array)).length >>> 0;
1521+
1522+ if (thisArg !== undefined) {
1523+ callback = bind(callback, thisArg);
1524+ }
1525+ while (++index < length) {
1526+ if (index in array &&
1527+ callback(array[index], index, array) === false) {
1528+ break;
1529+ }
1530+ }
1531+ return array;
1532+ }
1533+
1534+ /**
1535+ * Iterates over an object's own properties, executing the `callback` for each.
1536+ * Callbacks may terminate the loop by explicitly returning `false`.
1537+ *
1538+ * @static
1539+ * @memberOf Benchmark
1540+ * @param {Object} object The object to iterate over.
1541+ * @param {Function} callback The function executed per own property.
1542+ * @param {Mixed} thisArg The `this` binding for the callback.
1543+ * @returns {Object} Returns the object iterated over.
1544+ */
1545+ function forOwn(object, callback, thisArg) {
1546+ return forProps(object, callback, { 'bind': thisArg, 'which': 'own' });
1547+ }
1548+
1549+ /**
1550+ * Converts a number to a more readable comma-separated string representation.
1551+ *
1552+ * @static
1553+ * @memberOf Benchmark
1554+ * @param {Number} number The number to convert.
1555+ * @returns {String} The more readable string representation.
1556+ */
1557+ function formatNumber(number) {
1558+ number = String(number).split('.');
1559+ return number[0].replace(/(?=(?:\d{3})+$)(?!\b)/g, ',') +
1560+ (number[1] ? '.' + number[1] : '');
1561+ }
1562+
1563+ /**
1564+ * Checks if an object has the specified key as a direct property.
1565+ *
1566+ * @static
1567+ * @memberOf Benchmark
1568+ * @param {Object} object The object to check.
1569+ * @param {String} key The key to check for.
1570+ * @returns {Boolean} Returns `true` if key is a direct property, else `false`.
1571+ */
1572+ function hasKey() {
1573+ // lazy define for worst case fallback (not as accurate)
1574+ hasKey = function(object, key) {
1575+ var parent = object != null && (object.constructor || Object).prototype;
1576+ return !!parent && key in Object(object) && !(key in parent && object[key] === parent[key]);
1577+ };
1578+ // for modern browsers
1579+ if (isClassOf(hasOwnProperty, 'Function')) {
1580+ hasKey = function(object, key) {
1581+ return object != null && hasOwnProperty.call(object, key);
1582+ };
1583+ }
1584+ // for Safari 2
1585+ else if ({}.__proto__ == Object.prototype) {
1586+ hasKey = function(object, key) {
1587+ var result = false;
1588+ if (object != null) {
1589+ object = Object(object);
1590+ object.__proto__ = [object.__proto__, object.__proto__ = null, result = key in object][0];
1591+ }
1592+ return result;
1593+ };
1594+ }
1595+ return hasKey.apply(this, arguments);
1596+ }
1597+
1598+ /**
1599+ * A generic `Array#indexOf` like method.
1600+ *
1601+ * @static
1602+ * @memberOf Benchmark
1603+ * @param {Array} array The array to iterate over.
1604+ * @param {Mixed} value The value to search for.
1605+ * @param {Number} [fromIndex=0] The index to start searching from.
1606+ * @returns {Number} The index of the matched value or `-1`.
1607+ */
1608+ function indexOf(array, value, fromIndex) {
1609+ var index = toInteger(fromIndex),
1610+ length = (array = Object(array)).length >>> 0;
1611+
1612+ index = (index < 0 ? max(0, length + index) : index) - 1;
1613+ while (++index < length) {
1614+ if (index in array && value === array[index]) {
1615+ return index;
1616+ }
1617+ }
1618+ return -1;
1619+ }
1620+
1621+ /**
1622+ * Modify a string by replacing named tokens with matching object property values.
1623+ *
1624+ * @static
1625+ * @memberOf Benchmark
1626+ * @param {String} string The string to modify.
1627+ * @param {Object} object The template object.
1628+ * @returns {String} The modified string.
1629+ */
1630+ function interpolate(string, object) {
1631+ forOwn(object, function(value, key) {
1632+ // escape regexp special characters in `key`
1633+ string = string.replace(RegExp('#\\{' + key.replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1') + '\\}', 'g'), value);
1634+ });
1635+ return string;
1636+ }
1637+
1638+ /**
1639+ * Invokes a method on all items in an array.
1640+ *
1641+ * @static
1642+ * @memberOf Benchmark
1643+ * @param {Array} benches Array of benchmarks to iterate over.
1644+ * @param {String|Object} name The name of the method to invoke OR options object.
1645+ * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
1646+ * @returns {Array} A new array of values returned from each method invoked.
1647+ * @example
1648+ *
1649+ * // invoke `reset` on all benchmarks
1650+ * Benchmark.invoke(benches, 'reset');
1651+ *
1652+ * // invoke `emit` with arguments
1653+ * Benchmark.invoke(benches, 'emit', 'complete', listener);
1654+ *
1655+ * // invoke `run(true)`, treat benchmarks as a queue, and register invoke callbacks
1656+ * Benchmark.invoke(benches, {
1657+ *
1658+ * // invoke the `run` method
1659+ * 'name': 'run',
1660+ *
1661+ * // pass a single argument
1662+ * 'args': true,
1663+ *
1664+ * // treat as queue, removing benchmarks from front of `benches` until empty
1665+ * 'queued': true,
1666+ *
1667+ * // called before any benchmarks have been invoked.
1668+ * 'onStart': onStart,
1669+ *
1670+ * // called between invoking benchmarks
1671+ * 'onCycle': onCycle,
1672+ *
1673+ * // called after all benchmarks have been invoked.
1674+ * 'onComplete': onComplete
1675+ * });
1676+ */
1677+ function invoke(benches, name) {
1678+ var args,
1679+ bench,
1680+ queued,
1681+ index = -1,
1682+ eventProps = { 'currentTarget': benches },
1683+ options = { 'onStart': noop, 'onCycle': noop, 'onComplete': noop },
1684+ result = map(benches, function(bench) { return bench; });
1685+
1686+ /**
1687+ * Invokes the method of the current object and if synchronous, fetches the next.
1688+ */
1689+ function execute() {
1690+ var listeners,
1691+ async = isAsync(bench);
1692+
1693+ if (async) {
1694+ // use `getNext` as the first listener
1695+ bench.on('complete', getNext);
1696+ listeners = bench.events.complete;
1697+ listeners.splice(0, 0, listeners.pop());
1698+ }
1699+ // execute method
1700+ result[index] = isClassOf(bench && bench[name], 'Function') ? bench[name].apply(bench, args) : undefined;
1701+ // if synchronous return true until finished
1702+ return !async && getNext();
1703+ }
1704+
1705+ /**
1706+ * Fetches the next bench or executes `onComplete` callback.
1707+ */
1708+ function getNext(event) {
1709+ var cycleEvent,
1710+ last = bench,
1711+ async = isAsync(last);
1712+
1713+ if (async) {
1714+ last.off('complete', getNext);
1715+ last.emit('complete');
1716+ }
1717+ // emit "cycle" event
1718+ eventProps.type = 'cycle';
1719+ eventProps.target = last;
1720+ cycleEvent = Event(eventProps);
1721+ options.onCycle.call(benches, cycleEvent);
1722+
1723+ // choose next benchmark if not exiting early
1724+ if (!cycleEvent.aborted && raiseIndex() !== false) {
1725+ bench = queued ? benches[0] : result[index];
1726+ if (isAsync(bench)) {
1727+ delay(bench, execute);
1728+ }
1729+ else if (async) {
1730+ // resume execution if previously asynchronous but now synchronous
1731+ while (execute()) { }
1732+ }
1733+ else {
1734+ // continue synchronous execution
1735+ return true;
1736+ }
1737+ } else {
1738+ // emit "complete" event
1739+ eventProps.type = 'complete';
1740+ options.onComplete.call(benches, Event(eventProps));
1741+ }
1742+ // When used as a listener `event.aborted = true` will cancel the rest of
1743+ // the "complete" listeners because they were already called above and when
1744+ // used as part of `getNext` the `return false` will exit the execution while-loop.
1745+ if (event) {
1746+ event.aborted = true;
1747+ } else {
1748+ return false;
1749+ }
1750+ }
1751+
1752+ /**
1753+ * Checks if invoking `Benchmark#run` with asynchronous cycles.
1754+ */
1755+ function isAsync(object) {
1756+ // avoid using `instanceof` here because of IE memory leak issues with host objects
1757+ var async = args[0] && args[0].async;
1758+ return Object(object).constructor == Benchmark && name == 'run' &&
1759+ ((async == null ? object.options.async : async) && support.timeout || object.defer);
1760+ }
1761+
1762+ /**
1763+ * Raises `index` to the next defined index or returns `false`.
1764+ */
1765+ function raiseIndex() {
1766+ var length = result.length;
1767+ if (queued) {
1768+ // if queued remove the previous bench and subsequent skipped non-entries
1769+ do {
1770+ ++index > 0 && shift.call(benches);
1771+ } while ((length = benches.length) && !('0' in benches));
1772+ }
1773+ else {
1774+ while (++index < length && !(index in result)) { }
1775+ }
1776+ // if we reached the last index then return `false`
1777+ return (queued ? length : index < length) ? index : (index = false);
1778+ }
1779+
1780+ // juggle arguments
1781+ if (isClassOf(name, 'String')) {
1782+ // 2 arguments (array, name)
1783+ args = slice.call(arguments, 2);
1784+ } else {
1785+ // 2 arguments (array, options)
1786+ options = extend(options, name);
1787+ name = options.name;
1788+ args = isClassOf(args = 'args' in options ? options.args : [], 'Array') ? args : [args];
1789+ queued = options.queued;
1790+ }
1791+
1792+ // start iterating over the array
1793+ if (raiseIndex() !== false) {
1794+ // emit "start" event
1795+ bench = result[index];
1796+ eventProps.type = 'start';
1797+ eventProps.target = bench;
1798+ options.onStart.call(benches, Event(eventProps));
1799+
1800+ // end early if the suite was aborted in an "onStart" listener
1801+ if (benches.aborted && benches.constructor == Suite && name == 'run') {
1802+ // emit "cycle" event
1803+ eventProps.type = 'cycle';
1804+ options.onCycle.call(benches, Event(eventProps));
1805+ // emit "complete" event
1806+ eventProps.type = 'complete';
1807+ options.onComplete.call(benches, Event(eventProps));
1808+ }
1809+ // else start
1810+ else {
1811+ if (isAsync(bench)) {
1812+ delay(bench, execute);
1813+ } else {
1814+ while (execute()) { }
1815+ }
1816+ }
1817+ }
1818+ return result;
1819+ }
1820+
1821+ /**
1822+ * Creates a string of joined array values or object key-value pairs.
1823+ *
1824+ * @static
1825+ * @memberOf Benchmark
1826+ * @param {Array|Object} object The object to operate on.
1827+ * @param {String} [separator1=','] The separator used between key-value pairs.
1828+ * @param {String} [separator2=': '] The separator used between keys and values.
1829+ * @returns {String} The joined result.
1830+ */
1831+ function join(object, separator1, separator2) {
1832+ var result = [],
1833+ length = (object = Object(object)).length,
1834+ arrayLike = length === length >>> 0;
1835+
1836+ separator2 || (separator2 = ': ');
1837+ each(object, function(value, key) {
1838+ result.push(arrayLike ? value : key + separator2 + value);
1839+ });
1840+ return result.join(separator1 || ',');
1841+ }
1842+
1843+ /**
1844+ * A generic `Array#map` like method.
1845+ *
1846+ * @static
1847+ * @memberOf Benchmark
1848+ * @param {Array} array The array to iterate over.
1849+ * @param {Function} callback The function called per iteration.
1850+ * @param {Mixed} thisArg The `this` binding for the callback.
1851+ * @returns {Array} A new array of values returned by the callback.
1852+ */
1853+ function map(array, callback, thisArg) {
1854+ return reduce(array, function(result, value, index) {
1855+ result[index] = callback.call(thisArg, value, index, array);
1856+ return result;
1857+ }, Array(Object(array).length >>> 0));
1858+ }
1859+
1860+ /**
1861+ * Retrieves the value of a specified property from all items in an array.
1862+ *
1863+ * @static
1864+ * @memberOf Benchmark
1865+ * @param {Array} array The array to iterate over.
1866+ * @param {String} property The property to pluck.
1867+ * @returns {Array} A new array of property values.
1868+ */
1869+ function pluck(array, property) {
1870+ return map(array, function(object) {
1871+ return object == null ? undefined : object[property];
1872+ });
1873+ }
1874+
1875+ /**
1876+ * A generic `Array#reduce` like method.
1877+ *
1878+ * @static
1879+ * @memberOf Benchmark
1880+ * @param {Array} array The array to iterate over.
1881+ * @param {Function} callback The function called per iteration.
1882+ * @param {Mixed} accumulator Initial value of the accumulator.
1883+ * @returns {Mixed} The accumulator.
1884+ */
1885+ function reduce(array, callback, accumulator) {
1886+ var noaccum = arguments.length < 3;
1887+ forEach(array, function(value, index) {
1888+ accumulator = noaccum ? (noaccum = false, value) : callback(accumulator, value, index, array);
1889+ });
1890+ return accumulator;
1891+ }
1892+
1893+ /*--------------------------------------------------------------------------*/
1894+
1895+ /**
1896+ * Aborts all benchmarks in the suite.
1897+ *
1898+ * @name abort
1899+ * @memberOf Benchmark.Suite
1900+ * @returns {Object} The suite instance.
1901+ */
1902+ function abortSuite() {
1903+ var event,
1904+ me = this,
1905+ resetting = calledBy.resetSuite;
1906+
1907+ if (me.running) {
1908+ event = Event('abort');
1909+ me.emit(event);
1910+ if (!event.cancelled || resetting) {
1911+ // avoid infinite recursion
1912+ calledBy.abortSuite = true;
1913+ me.reset();
1914+ delete calledBy.abortSuite;
1915+
1916+ if (!resetting) {
1917+ me.aborted = true;
1918+ invoke(me, 'abort');
1919+ }
1920+ }
1921+ }
1922+ return me;
1923+ }
1924+
1925+ /**
1926+ * Adds a test to the benchmark suite.
1927+ *
1928+ * @memberOf Benchmark.Suite
1929+ * @param {String} name A name to identify the benchmark.
1930+ * @param {Function|String} fn The test to benchmark.
1931+ * @param {Object} [options={}] Options object.
1932+ * @returns {Object} The benchmark instance.
1933+ * @example
1934+ *
1935+ * // basic usage
1936+ * suite.add(fn);
1937+ *
1938+ * // or using a name first
1939+ * suite.add('foo', fn);
1940+ *
1941+ * // or with options
1942+ * suite.add('foo', fn, {
1943+ * 'onCycle': onCycle,
1944+ * 'onComplete': onComplete
1945+ * });
1946+ *
1947+ * // or name and options
1948+ * suite.add('foo', {
1949+ * 'fn': fn,
1950+ * 'onCycle': onCycle,
1951+ * 'onComplete': onComplete
1952+ * });
1953+ *
1954+ * // or options only
1955+ * suite.add({
1956+ * 'name': 'foo',
1957+ * 'fn': fn,
1958+ * 'onCycle': onCycle,
1959+ * 'onComplete': onComplete
1960+ * });
1961+ */
1962+ function add(name, fn, options) {
1963+ var me = this,
1964+ bench = Benchmark(name, fn, options),
1965+ event = Event({ 'type': 'add', 'target': bench });
1966+
1967+ if (me.emit(event), !event.cancelled) {
1968+ me.push(bench);
1969+ }
1970+ return me;
1971+ }
1972+
1973+ /**
1974+ * Creates a new suite with cloned benchmarks.
1975+ *
1976+ * @name clone
1977+ * @memberOf Benchmark.Suite
1978+ * @param {Object} options Options object to overwrite cloned options.
1979+ * @returns {Object} The new suite instance.
1980+ */
1981+ function cloneSuite(options) {
1982+ var me = this,
1983+ result = new me.constructor(extend({}, me.options, options));
1984+
1985+ // copy own properties
1986+ forOwn(me, function(value, key) {
1987+ if (!hasKey(result, key)) {
1988+ result[key] = value && isClassOf(value.clone, 'Function')
1989+ ? value.clone()
1990+ : deepClone(value);
1991+ }
1992+ });
1993+ return result;
1994+ }
1995+
1996+ /**
1997+ * An `Array#filter` like method.
1998+ *
1999+ * @name filter
2000+ * @memberOf Benchmark.Suite
2001+ * @param {Function|String} callback The function/alias called per iteration.
2002+ * @returns {Object} A new suite of benchmarks that passed callback filter.
2003+ */
2004+ function filterSuite(callback) {
2005+ var me = this,
2006+ result = new me.constructor;
2007+
2008+ result.push.apply(result, filter(me, callback));
2009+ return result;
2010+ }
2011+
2012+ /**
2013+ * Resets all benchmarks in the suite.
2014+ *
2015+ * @name reset
2016+ * @memberOf Benchmark.Suite
2017+ * @returns {Object} The suite instance.
2018+ */
2019+ function resetSuite() {
2020+ var event,
2021+ me = this,
2022+ aborting = calledBy.abortSuite;
2023+
2024+ if (me.running && !aborting) {
2025+ // no worries, `resetSuite()` is called within `abortSuite()`
2026+ calledBy.resetSuite = true;
2027+ me.abort();
2028+ delete calledBy.resetSuite;
2029+ }
2030+ // reset if the state has changed
2031+ else if ((me.aborted || me.running) &&
2032+ (me.emit(event = Event('reset')), !event.cancelled)) {
2033+ me.running = false;
2034+ if (!aborting) {
2035+ invoke(me, 'reset');
2036+ }
2037+ }
2038+ return me;
2039+ }
2040+
2041+ /**
2042+ * Runs the suite.
2043+ *
2044+ * @name run
2045+ * @memberOf Benchmark.Suite
2046+ * @param {Object} [options={}] Options object.
2047+ * @returns {Object} The suite instance.
2048+ * @example
2049+ *
2050+ * // basic usage
2051+ * suite.run();
2052+ *
2053+ * // or with options
2054+ * suite.run({ 'async': true, 'queued': true });
2055+ */
2056+ function runSuite(options) {
2057+ var me = this;
2058+
2059+ me.reset();
2060+ me.running = true;
2061+ options || (options = {});
2062+
2063+ invoke(me, {
2064+ 'name': 'run',
2065+ 'args': options,
2066+ 'queued': options.queued,
2067+ 'onStart': function(event) {
2068+ me.emit(event);
2069+ },
2070+ 'onCycle': function(event) {
2071+ var bench = event.target;
2072+ if (bench.error) {
2073+ me.emit({ 'type': 'error', 'target': bench });
2074+ }
2075+ me.emit(event);
2076+ event.aborted = me.aborted;
2077+ },
2078+ 'onComplete': function(event) {
2079+ me.running = false;
2080+ me.emit(event);
2081+ }
2082+ });
2083+ return me;
2084+ }
2085+
2086+ /*--------------------------------------------------------------------------*/
2087+
2088+ /**
2089+ * Executes all registered listeners of the specified event type.
2090+ *
2091+ * @memberOf Benchmark, Benchmark.Suite
2092+ * @param {String|Object} type The event type or object.
2093+ * @returns {Mixed} Returns the return value of the last listener executed.
2094+ */
2095+ function emit(type) {
2096+ var listeners,
2097+ me = this,
2098+ event = Event(type),
2099+ events = me.events,
2100+ args = (arguments[0] = event, arguments);
2101+
2102+ event.currentTarget || (event.currentTarget = me);
2103+ event.target || (event.target = me);
2104+ delete event.result;
2105+
2106+ if (events && (listeners = hasKey(events, event.type) && events[event.type])) {
2107+ forEach(listeners.slice(), function(listener) {
2108+ if ((event.result = listener.apply(me, args)) === false) {
2109+ event.cancelled = true;
2110+ }
2111+ return !event.aborted;
2112+ });
2113+ }
2114+ return event.result;
2115+ }
2116+
2117+ /**
2118+ * Returns an array of event listeners for a given type that can be manipulated
2119+ * to add or remove listeners.
2120+ *
2121+ * @memberOf Benchmark, Benchmark.Suite
2122+ * @param {String} type The event type.
2123+ * @returns {Array} The listeners array.
2124+ */
2125+ function listeners(type) {
2126+ var me = this,
2127+ events = me.events || (me.events = {});
2128+
2129+ return hasKey(events, type) ? events[type] : (events[type] = []);
2130+ }
2131+
2132+ /**
2133+ * Unregisters a listener for the specified event type(s),
2134+ * or unregisters all listeners for the specified event type(s),
2135+ * or unregisters all listeners for all event types.
2136+ *
2137+ * @memberOf Benchmark, Benchmark.Suite
2138+ * @param {String} [type] The event type.
2139+ * @param {Function} [listener] The function to unregister.
2140+ * @returns {Object} The benchmark instance.
2141+ * @example
2142+ *
2143+ * // unregister a listener for an event type
2144+ * bench.off('cycle', listener);
2145+ *
2146+ * // unregister a listener for multiple event types
2147+ * bench.off('start cycle', listener);
2148+ *
2149+ * // unregister all listeners for an event type
2150+ * bench.off('cycle');
2151+ *
2152+ * // unregister all listeners for multiple event types
2153+ * bench.off('start cycle complete');
2154+ *
2155+ * // unregister all listeners for all event types
2156+ * bench.off();
2157+ */
2158+ function off(type, listener) {
2159+ var me = this,
2160+ events = me.events;
2161+
2162+ events && each(type ? type.split(' ') : events, function(listeners, type) {
2163+ var index;
2164+ if (typeof listeners == 'string') {
2165+ type = listeners;
2166+ listeners = hasKey(events, type) && events[type];
2167+ }
2168+ if (listeners) {
2169+ if (listener) {
2170+ index = indexOf(listeners, listener);
2171+ if (index > -1) {
2172+ listeners.splice(index, 1);
2173+ }
2174+ } else {
2175+ listeners.length = 0;
2176+ }
2177+ }
2178+ });
2179+ return me;
2180+ }
2181+
2182+ /**
2183+ * Registers a listener for the specified event type(s).
2184+ *
2185+ * @memberOf Benchmark, Benchmark.Suite
2186+ * @param {String} type The event type.
2187+ * @param {Function} listener The function to register.
2188+ * @returns {Object} The benchmark instance.
2189+ * @example
2190+ *
2191+ * // register a listener for an event type
2192+ * bench.on('cycle', listener);
2193+ *
2194+ * // register a listener for multiple event types
2195+ * bench.on('start cycle', listener);
2196+ */
2197+ function on(type, listener) {
2198+ var me = this,
2199+ events = me.events || (me.events = {});
2200+
2201+ forEach(type.split(' '), function(type) {
2202+ (hasKey(events, type)
2203+ ? events[type]
2204+ : (events[type] = [])
2205+ ).push(listener);
2206+ });
2207+ return me;
2208+ }
2209+
2210+ /*--------------------------------------------------------------------------*/
2211+
2212+ /**
2213+ * Aborts the benchmark without recording times.
2214+ *
2215+ * @memberOf Benchmark
2216+ * @returns {Object} The benchmark instance.
2217+ */
2218+ function abort() {
2219+ var event,
2220+ me = this,
2221+ resetting = calledBy.reset;
2222+
2223+ if (me.running) {
2224+ event = Event('abort');
2225+ me.emit(event);
2226+ if (!event.cancelled || resetting) {
2227+ // avoid infinite recursion
2228+ calledBy.abort = true;
2229+ me.reset();
2230+ delete calledBy.abort;
2231+
2232+ if (support.timeout) {
2233+ clearTimeout(me._timerId);
2234+ delete me._timerId;
2235+ }
2236+ if (!resetting) {
2237+ me.aborted = true;
2238+ me.running = false;
2239+ }
2240+ }
2241+ }
2242+ return me;
2243+ }
2244+
2245+ /**
2246+ * Creates a new benchmark using the same test and options.
2247+ *
2248+ * @memberOf Benchmark
2249+ * @param {Object} options Options object to overwrite cloned options.
2250+ * @returns {Object} The new benchmark instance.
2251+ * @example
2252+ *
2253+ * var bizarro = bench.clone({
2254+ * 'name': 'doppelganger'
2255+ * });
2256+ */
2257+ function clone(options) {
2258+ var me = this,
2259+ result = new me.constructor(extend({}, me, options));
2260+
2261+ // correct the `options` object
2262+ result.options = extend({}, me.options, options);
2263+
2264+ // copy own custom properties
2265+ forOwn(me, function(value, key) {
2266+ if (!hasKey(result, key)) {
2267+ result[key] = deepClone(value);
2268+ }
2269+ });
2270+ return result;
2271+ }
2272+
2273+ /**
2274+ * Determines if a benchmark is faster than another.
2275+ *
2276+ * @memberOf Benchmark
2277+ * @param {Object} other The benchmark to compare.
2278+ * @returns {Number} Returns `-1` if slower, `1` if faster, and `0` if indeterminate.
2279+ */
2280+ function compare(other) {
2281+ var critical,
2282+ zStat,
2283+ me = this,
2284+ sample1 = me.stats.sample,
2285+ sample2 = other.stats.sample,
2286+ size1 = sample1.length,
2287+ size2 = sample2.length,
2288+ maxSize = max(size1, size2),
2289+ minSize = min(size1, size2),
2290+ u1 = getU(sample1, sample2),
2291+ u2 = getU(sample2, sample1),
2292+ u = min(u1, u2);
2293+
2294+ function getScore(xA, sampleB) {
2295+ return reduce(sampleB, function(total, xB) {
2296+ return total + (xB > xA ? 0 : xB < xA ? 1 : 0.5);
2297+ }, 0);
2298+ }
2299+
2300+ function getU(sampleA, sampleB) {
2301+ return reduce(sampleA, function(total, xA) {
2302+ return total + getScore(xA, sampleB);
2303+ }, 0);
2304+ }
2305+
2306+ function getZ(u) {
2307+ return (u - ((size1 * size2) / 2)) / sqrt((size1 * size2 * (size1 + size2 + 1)) / 12);
2308+ }
2309+
2310+ // exit early if comparing the same benchmark
2311+ if (me == other) {
2312+ return 0;
2313+ }
2314+ // reject the null hyphothesis the two samples come from the
2315+ // same population (i.e. have the same median) if...
2316+ if (size1 + size2 > 30) {
2317+ // ...the z-stat is greater than 1.96 or less than -1.96
2318+ // http://www.statisticslectures.com/topics/mannwhitneyu/
2319+ zStat = getZ(u);
2320+ return abs(zStat) > 1.96 ? (zStat > 0 ? -1 : 1) : 0;
2321+ }
2322+ // ...the U value is less than or equal the critical U value
2323+ // http://www.geoib.com/mann-whitney-u-test.html
2324+ critical = maxSize < 5 || minSize < 3 ? 0 : uTable[maxSize][minSize - 3];
2325+ return u <= critical ? (u == u1 ? 1 : -1) : 0;
2326+ }
2327+
2328+ /**
2329+ * Reset properties and abort if running.
2330+ *
2331+ * @memberOf Benchmark
2332+ * @returns {Object} The benchmark instance.
2333+ */
2334+ function reset() {
2335+ var data,
2336+ event,
2337+ me = this,
2338+ index = 0,
2339+ changes = { 'length': 0 },
2340+ queue = { 'length': 0 };
2341+
2342+ if (me.running && !calledBy.abort) {
2343+ // no worries, `reset()` is called within `abort()`
2344+ calledBy.reset = true;
2345+ me.abort();
2346+ delete calledBy.reset;
2347+ }
2348+ else {
2349+ // a non-recursive solution to check if properties have changed
2350+ // http://www.jslab.dk/articles/non.recursive.preorder.traversal.part4
2351+ data = { 'destination': me, 'source': extend({}, me.constructor.prototype, me.options) };
2352+ do {
2353+ forOwn(data.source, function(value, key) {
2354+ var changed,
2355+ destination = data.destination,
2356+ currValue = destination[key];
2357+
2358+ if (value && typeof value == 'object') {
2359+ if (isClassOf(value, 'Array')) {
2360+ // check if an array value has changed to a non-array value
2361+ if (!isClassOf(currValue, 'Array')) {
2362+ changed = currValue = [];
2363+ }
2364+ // or has changed its length
2365+ if (currValue.length != value.length) {
2366+ changed = currValue = currValue.slice(0, value.length);
2367+ currValue.length = value.length;
2368+ }
2369+ }
2370+ // check if an object has changed to a non-object value
2371+ else if (!currValue || typeof currValue != 'object') {
2372+ changed = currValue = {};
2373+ }
2374+ // register a changed object
2375+ if (changed) {
2376+ changes[changes.length++] = { 'destination': destination, 'key': key, 'value': currValue };
2377+ }
2378+ queue[queue.length++] = { 'destination': currValue, 'source': value };
2379+ }
2380+ // register a changed primitive
2381+ else if (value !== currValue && !(value == null || isClassOf(value, 'Function'))) {
2382+ changes[changes.length++] = { 'destination': destination, 'key': key, 'value': value };
2383+ }
2384+ });
2385+ }
2386+ while ((data = queue[index++]));
2387+
2388+ // if changed emit the `reset` event and if it isn't cancelled reset the benchmark
2389+ if (changes.length && (me.emit(event = Event('reset')), !event.cancelled)) {
2390+ forEach(changes, function(data) {
2391+ data.destination[data.key] = data.value;
2392+ });
2393+ }
2394+ }
2395+ return me;
2396+ }
2397+
2398+ /**
2399+ * Displays relevant benchmark information when coerced to a string.
2400+ *
2401+ * @name toString
2402+ * @memberOf Benchmark
2403+ * @returns {String} A string representation of the benchmark instance.
2404+ */
2405+ function toStringBench() {
2406+ var me = this,
2407+ error = me.error,
2408+ hz = me.hz,
2409+ id = me.id,
2410+ stats = me.stats,
2411+ size = stats.sample.length,
2412+ pm = support.java ? '+/-' : '\xb1',
2413+ result = me.name || (isNaN(id) ? id : '<Test #' + id + '>');
2414+
2415+ if (error) {
2416+ result += ': ' + join(error);
2417+ } else {
2418+ result += ' x ' + formatNumber(hz.toFixed(hz < 100 ? 2 : 0)) + ' ops/sec ' + pm +
2419+ stats.rme.toFixed(2) + '% (' + size + ' run' + (size == 1 ? '' : 's') + ' sampled)';
2420+ }
2421+ return result;
2422+ }
2423+
2424+ /*--------------------------------------------------------------------------*/
2425+
2426+ /**
2427+ * Clocks the time taken to execute a test per cycle (secs).
2428+ *
2429+ * @private
2430+ * @param {Object} bench The benchmark instance.
2431+ * @returns {Number} The time taken.
2432+ */
2433+ function clock() {
2434+ var applet,
2435+ options = Benchmark.options,
2436+ template = { 'begin': 's$=new n$', 'end': 'r$=(new n$-s$)/1e3', 'uid': uid },
2437+ timers = [{ 'ns': timer.ns, 'res': max(0.0015, getRes('ms')), 'unit': 'ms' }];
2438+
2439+ // lazy define for hi-res timers
2440+ clock = function(clone) {
2441+ var deferred;
2442+ if (clone instanceof Deferred) {
2443+ deferred = clone;
2444+ clone = deferred.benchmark;
2445+ }
2446+
2447+ var bench = clone._original,
2448+ fn = bench.fn,
2449+ fnArg = deferred ? getFirstArgument(fn) || 'deferred' : '',
2450+ stringable = isStringable(fn);
2451+
2452+ var source = {
2453+ 'setup': getSource(bench.setup, preprocess('m$.setup()')),
2454+ 'fn': getSource(fn, preprocess('m$.fn(' + fnArg + ')')),
2455+ 'fnArg': fnArg,
2456+ 'teardown': getSource(bench.teardown, preprocess('m$.teardown()'))
2457+ };
2458+
2459+ var count = bench.count = clone.count,
2460+ decompilable = support.decompilation || stringable,
2461+ id = bench.id,
2462+ isEmpty = !(source.fn || stringable),
2463+ name = bench.name || (typeof id == 'number' ? '<Test #' + id + '>' : id),
2464+ ns = timer.ns,
2465+ result = 0;
2466+
2467+ // init `minTime` if needed
2468+ clone.minTime = bench.minTime || (bench.minTime = bench.options.minTime = options.minTime);
2469+
2470+ // repair nanosecond timer
2471+ // (some Chrome builds erase the `ns` variable after millions of executions)
2472+ if (applet) {
2473+ try {
2474+ ns.nanoTime();
2475+ } catch(e) {
2476+ // use non-element to avoid issues with libs that augment them
2477+ ns = timer.ns = new applet.Packages.nano;
2478+ }
2479+ }
2480+
2481+ // Compile in setup/teardown functions and the test loop.
2482+ // Create a new compiled test, instead of using the cached `bench.compiled`,
2483+ // to avoid potential engine optimizations enabled over the life of the test.
2484+ var compiled = bench.compiled = createFunction(preprocess('t$'), interpolate(
2485+ preprocess(deferred
2486+ ? 'var d$=this,#{fnArg}=d$,m$=d$.benchmark._original,f$=m$.fn,su$=m$.setup,td$=m$.teardown;' +
2487+ // when `deferred.cycles` is `0` then...
2488+ 'if(!d$.cycles){' +
2489+ // set `deferred.fn`
2490+ 'd$.fn=function(){var #{fnArg}=d$;if(typeof f$=="function"){try{#{fn}\n}catch(e$){f$(d$)}}else{#{fn}\n}};' +
2491+ // set `deferred.teardown`
2492+ 'd$.teardown=function(){d$.cycles=0;if(typeof td$=="function"){try{#{teardown}\n}catch(e$){td$()}}else{#{teardown}\n}};' +
2493+ // execute the benchmark's `setup`
2494+ 'if(typeof su$=="function"){try{#{setup}\n}catch(e$){su$()}}else{#{setup}\n};' +
2495+ // start timer
2496+ 't$.start(d$);' +
2497+ // execute `deferred.fn` and return a dummy object
2498+ '}d$.fn();return{}'
2499+
2500+ : 'var r$,s$,m$=this,f$=m$.fn,i$=m$.count,n$=t$.ns;#{setup}\n#{begin};' +
2501+ 'while(i$--){#{fn}\n}#{end};#{teardown}\nreturn{elapsed:r$,uid:"#{uid}"}'),
2502+ source
2503+ ));
2504+
2505+ try {
2506+ if (isEmpty) {
2507+ // Firefox may remove dead code from Function#toString results
2508+ // http://bugzil.la/536085
2509+ throw new Error('The test "' + name + '" is empty. This may be the result of dead code removal.');
2510+ }
2511+ else if (!deferred) {
2512+ // pretest to determine if compiled code is exits early, usually by a
2513+ // rogue `return` statement, by checking for a return object with the uid
2514+ bench.count = 1;
2515+ compiled = (compiled.call(bench, timer) || {}).uid == uid && compiled;
2516+ bench.count = count;
2517+ }
2518+ } catch(e) {
2519+ compiled = null;
2520+ clone.error = e || new Error(String(e));
2521+ bench.count = count;
2522+ }
2523+ // fallback when a test exits early or errors during pretest
2524+ if (decompilable && !compiled && !deferred && !isEmpty) {
2525+ compiled = createFunction(preprocess('t$'), interpolate(
2526+ preprocess(
2527+ (clone.error && !stringable
2528+ ? 'var r$,s$,m$=this,f$=m$.fn,i$=m$.count'
2529+ : 'function f$(){#{fn}\n}var r$,s$,m$=this,i$=m$.count'
2530+ ) +
2531+ ',n$=t$.ns;#{setup}\n#{begin};m$.f$=f$;while(i$--){m$.f$()}#{end};' +
2532+ 'delete m$.f$;#{teardown}\nreturn{elapsed:r$}'
2533+ ),
2534+ source
2535+ ));
2536+
2537+ try {
2538+ // pretest one more time to check for errors
2539+ bench.count = 1;
2540+ compiled.call(bench, timer);
2541+ bench.compiled = compiled;
2542+ bench.count = count;
2543+ delete clone.error;
2544+ }
2545+ catch(e) {
2546+ bench.count = count;
2547+ if (clone.error) {
2548+ compiled = null;
2549+ } else {
2550+ bench.compiled = compiled;
2551+ clone.error = e || new Error(String(e));
2552+ }
2553+ }
2554+ }
2555+ // assign `compiled` to `clone` before calling in case a deferred benchmark
2556+ // immediately calls `deferred.resolve()`
2557+ clone.compiled = compiled;
2558+ // if no errors run the full test loop
2559+ if (!clone.error) {
2560+ result = compiled.call(deferred || bench, timer).elapsed;
2561+ }
2562+ return result;
2563+ };
2564+
2565+ /*------------------------------------------------------------------------*/
2566+
2567+ /**
2568+ * Gets the current timer's minimum resolution (secs).
2569+ */
2570+ function getRes(unit) {
2571+ var measured,
2572+ begin,
2573+ count = 30,
2574+ divisor = 1e3,
2575+ ns = timer.ns,
2576+ sample = [];
2577+
2578+ // get average smallest measurable time
2579+ while (count--) {
2580+ if (unit == 'us') {
2581+ divisor = 1e6;
2582+ if (ns.stop) {
2583+ ns.start();
2584+ while (!(measured = ns.microseconds())) { }
2585+ } else if (ns[perfName]) {
2586+ divisor = 1e3;
2587+ measured = Function('n', 'var r,s=n.' + perfName + '();while(!(r=n.' + perfName + '()-s)){};return r')(ns);
2588+ } else {
2589+ begin = ns();
2590+ while (!(measured = ns() - begin)) { }
2591+ }
2592+ }
2593+ else if (unit == 'ns') {
2594+ divisor = 1e9;
2595+ if (ns.nanoTime) {
2596+ begin = ns.nanoTime();
2597+ while (!(measured = ns.nanoTime() - begin)) { }
2598+ } else {
2599+ begin = (begin = ns())[0] + (begin[1] / divisor);
2600+ while (!(measured = ((measured = ns())[0] + (measured[1] / divisor)) - begin)) { }
2601+ divisor = 1;
2602+ }
2603+ }
2604+ else {
2605+ begin = new ns;
2606+ while (!(measured = new ns - begin)) { }
2607+ }
2608+ // check for broken timers (nanoTime may have issues)
2609+ // http://alivebutsleepy.srnet.cz/unreliable-system-nanotime/
2610+ if (measured > 0) {
2611+ sample.push(measured);
2612+ } else {
2613+ sample.push(Infinity);
2614+ break;
2615+ }
2616+ }
2617+ // convert to seconds
2618+ return getMean(sample) / divisor;
2619+ }
2620+
2621+ /**
2622+ * Replaces all occurrences of `$` with a unique number and
2623+ * template tokens with content.
2624+ */
2625+ function preprocess(code) {
2626+ return interpolate(code, template).replace(/\$/g, /\d+/.exec(uid));
2627+ }
2628+
2629+ /*------------------------------------------------------------------------*/
2630+
2631+ // detect nanosecond support from a Java applet
2632+ each(doc && doc.applets || [], function(element) {
2633+ return !(timer.ns = applet = 'nanoTime' in element && element);
2634+ });
2635+
2636+ // check type in case Safari returns an object instead of a number
2637+ try {
2638+ if (typeof timer.ns.nanoTime() == 'number') {
2639+ timers.push({ 'ns': timer.ns, 'res': getRes('ns'), 'unit': 'ns' });
2640+ }
2641+ } catch(e) { }
2642+
2643+ // detect Chrome's microsecond timer:
2644+ // enable benchmarking via the --enable-benchmarking command
2645+ // line switch in at least Chrome 7 to use chrome.Interval
2646+ try {
2647+ if ((timer.ns = new (window.chrome || window.chromium).Interval)) {
2648+ timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });
2649+ }
2650+ } catch(e) { }
2651+
2652+ // detect `performance.now` microsecond resolution timer
2653+ if ((timer.ns = perfName && perfObject)) {
2654+ timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });
2655+ }
2656+
2657+ // detect Node's nanosecond resolution timer available in Node >= 0.8
2658+ if (processObject && typeof (timer.ns = processObject.hrtime) == 'function') {
2659+ timers.push({ 'ns': timer.ns, 'res': getRes('ns'), 'unit': 'ns' });
2660+ }
2661+
2662+ // detect Wade Simmons' Node microtime module
2663+ if (microtimeObject && typeof (timer.ns = microtimeObject.now) == 'function') {
2664+ timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });
2665+ }
2666+
2667+ // pick timer with highest resolution
2668+ timer = reduce(timers, function(timer, other) {
2669+ return other.res < timer.res ? other : timer;
2670+ });
2671+
2672+ // remove unused applet
2673+ if (timer.unit != 'ns' && applet) {
2674+ applet = destroyElement(applet);
2675+ }
2676+ // error if there are no working timers
2677+ if (timer.res == Infinity) {
2678+ throw new Error('Benchmark.js was unable to find a working timer.');
2679+ }
2680+ // use API of chosen timer
2681+ if (timer.unit == 'ns') {
2682+ if (timer.ns.nanoTime) {
2683+ extend(template, {
2684+ 'begin': 's$=n$.nanoTime()',
2685+ 'end': 'r$=(n$.nanoTime()-s$)/1e9'
2686+ });
2687+ } else {
2688+ extend(template, {
2689+ 'begin': 's$=n$()',
2690+ 'end': 'r$=n$(s$);r$=r$[0]+(r$[1]/1e9)'
2691+ });
2692+ }
2693+ }
2694+ else if (timer.unit == 'us') {
2695+ if (timer.ns.stop) {
2696+ extend(template, {
2697+ 'begin': 's$=n$.start()',
2698+ 'end': 'r$=n$.microseconds()/1e6'
2699+ });
2700+ } else if (perfName) {
2701+ extend(template, {
2702+ 'begin': 's$=n$.' + perfName + '()',
2703+ 'end': 'r$=(n$.' + perfName + '()-s$)/1e3'
2704+ });
2705+ } else {
2706+ extend(template, {
2707+ 'begin': 's$=n$()',
2708+ 'end': 'r$=(n$()-s$)/1e6'
2709+ });
2710+ }
2711+ }
2712+
2713+ // define `timer` methods
2714+ timer.start = createFunction(preprocess('o$'),
2715+ preprocess('var n$=this.ns,#{begin};o$.elapsed=0;o$.timeStamp=s$'));
2716+
2717+ timer.stop = createFunction(preprocess('o$'),
2718+ preprocess('var n$=this.ns,s$=o$.timeStamp,#{end};o$.elapsed=r$'));
2719+
2720+ // resolve time span required to achieve a percent uncertainty of at most 1%
2721+ // http://spiff.rit.edu/classes/phys273/uncert/uncert.html
2722+ options.minTime || (options.minTime = max(timer.res / 2 / 0.01, 0.05));
2723+ return clock.apply(null, arguments);
2724+ }
2725+
2726+ /*--------------------------------------------------------------------------*/
2727+
2728+ /**
2729+ * Computes stats on benchmark results.
2730+ *
2731+ * @private
2732+ * @param {Object} bench The benchmark instance.
2733+ * @param {Object} options The options object.
2734+ */
2735+ function compute(bench, options) {
2736+ options || (options = {});
2737+
2738+ var async = options.async,
2739+ elapsed = 0,
2740+ initCount = bench.initCount,
2741+ minSamples = bench.minSamples,
2742+ queue = [],
2743+ sample = bench.stats.sample;
2744+
2745+ /**
2746+ * Adds a clone to the queue.
2747+ */
2748+ function enqueue() {
2749+ queue.push(bench.clone({
2750+ '_original': bench,
2751+ 'events': {
2752+ 'abort': [update],
2753+ 'cycle': [update],
2754+ 'error': [update],
2755+ 'start': [update]
2756+ }
2757+ }));
2758+ }
2759+
2760+ /**
2761+ * Updates the clone/original benchmarks to keep their data in sync.
2762+ */
2763+ function update(event) {
2764+ var clone = this,
2765+ type = event.type;
2766+
2767+ if (bench.running) {
2768+ if (type == 'start') {
2769+ // Note: `clone.minTime` prop is inited in `clock()`
2770+ clone.count = bench.initCount;
2771+ }
2772+ else {
2773+ if (type == 'error') {
2774+ bench.error = clone.error;
2775+ }
2776+ if (type == 'abort') {
2777+ bench.abort();
2778+ bench.emit('cycle');
2779+ } else {
2780+ event.currentTarget = event.target = bench;
2781+ bench.emit(event);
2782+ }
2783+ }
2784+ } else if (bench.aborted) {
2785+ // clear abort listeners to avoid triggering bench's abort/cycle again
2786+ clone.events.abort.length = 0;
2787+ clone.abort();
2788+ }
2789+ }
2790+
2791+ /**
2792+ * Determines if more clones should be queued or if cycling should stop.
2793+ */
2794+ function evaluate(event) {
2795+ var critical,
2796+ df,
2797+ mean,
2798+ moe,
2799+ rme,
2800+ sd,
2801+ sem,
2802+ variance,
2803+ clone = event.target,
2804+ done = bench.aborted,
2805+ now = +new Date,
2806+ size = sample.push(clone.times.period),
2807+ maxedOut = size >= minSamples && (elapsed += now - clone.times.timeStamp) / 1e3 > bench.maxTime,
2808+ times = bench.times,
2809+ varOf = function(sum, x) { return sum + pow(x - mean, 2); };
2810+
2811+ // exit early for aborted or unclockable tests
2812+ if (done || clone.hz == Infinity) {
2813+ maxedOut = !(size = sample.length = queue.length = 0);
2814+ }
2815+
2816+ if (!done) {
2817+ // sample mean (estimate of the population mean)
2818+ mean = getMean(sample);
2819+ // sample variance (estimate of the population variance)
2820+ variance = reduce(sample, varOf, 0) / (size - 1) || 0;
2821+ // sample standard deviation (estimate of the population standard deviation)
2822+ sd = sqrt(variance);
2823+ // standard error of the mean (a.k.a. the standard deviation of the sampling distribution of the sample mean)
2824+ sem = sd / sqrt(size);
2825+ // degrees of freedom
2826+ df = size - 1;
2827+ // critical value
2828+ critical = tTable[Math.round(df) || 1] || tTable.infinity;
2829+ // margin of error
2830+ moe = sem * critical;
2831+ // relative margin of error
2832+ rme = (moe / mean) * 100 || 0;
2833+
2834+ extend(bench.stats, {
2835+ 'deviation': sd,
2836+ 'mean': mean,
2837+ 'moe': moe,
2838+ 'rme': rme,
2839+ 'sem': sem,
2840+ 'variance': variance
2841+ });
2842+
2843+ // Abort the cycle loop when the minimum sample size has been collected
2844+ // and the elapsed time exceeds the maximum time allowed per benchmark.
2845+ // We don't count cycle delays toward the max time because delays may be
2846+ // increased by browsers that clamp timeouts for inactive tabs.
2847+ // https://developer.mozilla.org/en/window.setTimeout#Inactive_tabs
2848+ if (maxedOut) {
2849+ // reset the `initCount` in case the benchmark is rerun
2850+ bench.initCount = initCount;
2851+ bench.running = false;
2852+ done = true;
2853+ times.elapsed = (now - times.timeStamp) / 1e3;
2854+ }
2855+ if (bench.hz != Infinity) {
2856+ bench.hz = 1 / mean;
2857+ times.cycle = mean * bench.count;
2858+ times.period = mean;
2859+ }
2860+ }
2861+ // if time permits, increase sample size to reduce the margin of error
2862+ if (queue.length < 2 && !maxedOut) {
2863+ enqueue();
2864+ }
2865+ // abort the invoke cycle when done
2866+ event.aborted = done;
2867+ }
2868+
2869+ // init queue and begin
2870+ enqueue();
2871+ invoke(queue, {
2872+ 'name': 'run',
2873+ 'args': { 'async': async },
2874+ 'queued': true,
2875+ 'onCycle': evaluate,
2876+ 'onComplete': function() { bench.emit('complete'); }
2877+ });
2878+ }
2879+
2880+ /*--------------------------------------------------------------------------*/
2881+
2882+ /**
2883+ * Cycles a benchmark until a run `count` can be established.
2884+ *
2885+ * @private
2886+ * @param {Object} clone The cloned benchmark instance.
2887+ * @param {Object} options The options object.
2888+ */
2889+ function cycle(clone, options) {
2890+ options || (options = {});
2891+
2892+ var deferred;
2893+ if (clone instanceof Deferred) {
2894+ deferred = clone;
2895+ clone = clone.benchmark;
2896+ }
2897+
2898+ var clocked,
2899+ cycles,
2900+ divisor,
2901+ event,
2902+ minTime,
2903+ period,
2904+ async = options.async,
2905+ bench = clone._original,
2906+ count = clone.count,
2907+ times = clone.times;
2908+
2909+ // continue, if not aborted between cycles
2910+ if (clone.running) {
2911+ // `minTime` is set to `Benchmark.options.minTime` in `clock()`
2912+ cycles = ++clone.cycles;
2913+ clocked = deferred ? deferred.elapsed : clock(clone);
2914+ minTime = clone.minTime;
2915+
2916+ if (cycles > bench.cycles) {
2917+ bench.cycles = cycles;
2918+ }
2919+ if (clone.error) {
2920+ event = Event('error');
2921+ event.message = clone.error;
2922+ clone.emit(event);
2923+ if (!event.cancelled) {
2924+ clone.abort();
2925+ }
2926+ }
2927+ }
2928+
2929+ // continue, if not errored
2930+ if (clone.running) {
2931+ // time taken to complete last test cycle
2932+ bench.times.cycle = times.cycle = clocked;
2933+ // seconds per operation
2934+ period = bench.times.period = times.period = clocked / count;
2935+ // ops per second
2936+ bench.hz = clone.hz = 1 / period;
2937+ // avoid working our way up to this next time
2938+ bench.initCount = clone.initCount = count;
2939+ // do we need to do another cycle?
2940+ clone.running = clocked < minTime;
2941+
2942+ if (clone.running) {
2943+ // tests may clock at `0` when `initCount` is a small number,
2944+ // to avoid that we set its count to something a bit higher
2945+ if (!clocked && (divisor = divisors[clone.cycles]) != null) {
2946+ count = floor(4e6 / divisor);
2947+ }
2948+ // calculate how many more iterations it will take to achive the `minTime`
2949+ if (count <= clone.count) {
2950+ count += Math.ceil((minTime - clocked) / period);
2951+ }
2952+ clone.running = count != Infinity;
2953+ }
2954+ }
2955+ // should we exit early?
2956+ event = Event('cycle');
2957+ clone.emit(event);
2958+ if (event.aborted) {
2959+ clone.abort();
2960+ }
2961+ // figure out what to do next
2962+ if (clone.running) {
2963+ // start a new cycle
2964+ clone.count = count;
2965+ if (deferred) {
2966+ clone.compiled.call(deferred, timer);
2967+ } else if (async) {
2968+ delay(clone, function() { cycle(clone, options); });
2969+ } else {
2970+ cycle(clone);
2971+ }
2972+ }
2973+ else {
2974+ // fix TraceMonkey bug associated with clock fallbacks
2975+ // http://bugzil.la/509069
2976+ if (support.browser) {
2977+ runScript(uid + '=1;delete ' + uid);
2978+ }
2979+ // done
2980+ clone.emit('complete');
2981+ }
2982+ }
2983+
2984+ /*--------------------------------------------------------------------------*/
2985+
2986+ /**
2987+ * Runs the benchmark.
2988+ *
2989+ * @memberOf Benchmark
2990+ * @param {Object} [options={}] Options object.
2991+ * @returns {Object} The benchmark instance.
2992+ * @example
2993+ *
2994+ * // basic usage
2995+ * bench.run();
2996+ *
2997+ * // or with options
2998+ * bench.run({ 'async': true });
2999+ */
3000+ function run(options) {
3001+ var me = this,
3002+ event = Event('start');
3003+
3004+ // set `running` to `false` so `reset()` won't call `abort()`
3005+ me.running = false;
3006+ me.reset();
3007+ me.running = true;
3008+
3009+ me.count = me.initCount;
3010+ me.times.timeStamp = +new Date;
3011+ me.emit(event);
3012+
3013+ if (!event.cancelled) {
3014+ options = { 'async': ((options = options && options.async) == null ? me.async : options) && support.timeout };
3015+
3016+ // for clones created within `compute()`
3017+ if (me._original) {
3018+ if (me.defer) {
3019+ Deferred(me);
3020+ } else {
3021+ cycle(me, options);
3022+ }
3023+ }
3024+ // for original benchmarks
3025+ else {
3026+ compute(me, options);
3027+ }
3028+ }
3029+ return me;
3030+ }
3031+
3032+ /*--------------------------------------------------------------------------*/
3033+
3034+ // Firefox 1 erroneously defines variable and argument names of functions on
3035+ // the function itself as non-configurable properties with `undefined` values.
3036+ // The bugginess continues as the `Benchmark` constructor has an argument
3037+ // named `options` and Firefox 1 will not assign a value to `Benchmark.options`,
3038+ // making it non-writable in the process, unless it is the first property
3039+ // assigned by for-in loop of `extend()`.
3040+ extend(Benchmark, {
3041+
3042+ /**
3043+ * The default options copied by benchmark instances.
3044+ *
3045+ * @static
3046+ * @memberOf Benchmark
3047+ * @type Object
3048+ */
3049+ 'options': {
3050+
3051+ /**
3052+ * A flag to indicate that benchmark cycles will execute asynchronously
3053+ * by default.
3054+ *
3055+ * @memberOf Benchmark.options
3056+ * @type Boolean
3057+ */
3058+ 'async': false,
3059+
3060+ /**
3061+ * A flag to indicate that the benchmark clock is deferred.
3062+ *
3063+ * @memberOf Benchmark.options
3064+ * @type Boolean
3065+ */
3066+ 'defer': false,
3067+
3068+ /**
3069+ * The delay between test cycles (secs).
3070+ * @memberOf Benchmark.options
3071+ * @type Number
3072+ */
3073+ 'delay': 0.005,
3074+
3075+ /**
3076+ * Displayed by Benchmark#toString when a `name` is not available
3077+ * (auto-generated if absent).
3078+ *
3079+ * @memberOf Benchmark.options
3080+ * @type String
3081+ */
3082+ 'id': undefined,
3083+
3084+ /**
3085+ * The default number of times to execute a test on a benchmark's first cycle.
3086+ *
3087+ * @memberOf Benchmark.options
3088+ * @type Number
3089+ */
3090+ 'initCount': 1,
3091+
3092+ /**
3093+ * The maximum time a benchmark is allowed to run before finishing (secs).
3094+ *
3095+ * Note: Cycle delays aren't counted toward the maximum time.
3096+ *
3097+ * @memberOf Benchmark.options
3098+ * @type Number
3099+ */
3100+ 'maxTime': 5,
3101+
3102+ /**
3103+ * The minimum sample size required to perform statistical analysis.
3104+ *
3105+ * @memberOf Benchmark.options
3106+ * @type Number
3107+ */
3108+ 'minSamples': 5,
3109+
3110+ /**
3111+ * The time needed to reduce the percent uncertainty of measurement to 1% (secs).
3112+ *
3113+ * @memberOf Benchmark.options
3114+ * @type Number
3115+ */
3116+ 'minTime': 0,
3117+
3118+ /**
3119+ * The name of the benchmark.
3120+ *
3121+ * @memberOf Benchmark.options
3122+ * @type String
3123+ */
3124+ 'name': undefined,
3125+
3126+ /**
3127+ * An event listener called when the benchmark is aborted.
3128+ *
3129+ * @memberOf Benchmark.options
3130+ * @type Function
3131+ */
3132+ 'onAbort': undefined,
3133+
3134+ /**
3135+ * An event listener called when the benchmark completes running.
3136+ *
3137+ * @memberOf Benchmark.options
3138+ * @type Function
3139+ */
3140+ 'onComplete': undefined,
3141+
3142+ /**
3143+ * An event listener called after each run cycle.
3144+ *
3145+ * @memberOf Benchmark.options
3146+ * @type Function
3147+ */
3148+ 'onCycle': undefined,
3149+
3150+ /**
3151+ * An event listener called when a test errors.
3152+ *
3153+ * @memberOf Benchmark.options
3154+ * @type Function
3155+ */
3156+ 'onError': undefined,
3157+
3158+ /**
3159+ * An event listener called when the benchmark is reset.
3160+ *
3161+ * @memberOf Benchmark.options
3162+ * @type Function
3163+ */
3164+ 'onReset': undefined,
3165+
3166+ /**
3167+ * An event listener called when the benchmark starts running.
3168+ *
3169+ * @memberOf Benchmark.options
3170+ * @type Function
3171+ */
3172+ 'onStart': undefined
3173+ },
3174+
3175+ /**
3176+ * Platform object with properties describing things like browser name,
3177+ * version, and operating system.
3178+ *
3179+ * @static
3180+ * @memberOf Benchmark
3181+ * @type Object
3182+ */
3183+ 'platform': req('platform') || window.platform || {
3184+
3185+ /**
3186+ * The platform description.
3187+ *
3188+ * @memberOf Benchmark.platform
3189+ * @type String
3190+ */
3191+ 'description': window.navigator && navigator.userAgent || null,
3192+
3193+ /**
3194+ * The name of the browser layout engine.
3195+ *
3196+ * @memberOf Benchmark.platform
3197+ * @type String|Null
3198+ */
3199+ 'layout': null,
3200+
3201+ /**
3202+ * The name of the product hosting the browser.
3203+ *
3204+ * @memberOf Benchmark.platform
3205+ * @type String|Null
3206+ */
3207+ 'product': null,
3208+
3209+ /**
3210+ * The name of the browser/environment.
3211+ *
3212+ * @memberOf Benchmark.platform
3213+ * @type String|Null
3214+ */
3215+ 'name': null,
3216+
3217+ /**
3218+ * The name of the product's manufacturer.
3219+ *
3220+ * @memberOf Benchmark.platform
3221+ * @type String|Null
3222+ */
3223+ 'manufacturer': null,
3224+
3225+ /**
3226+ * The name of the operating system.
3227+ *
3228+ * @memberOf Benchmark.platform
3229+ * @type String|Null
3230+ */
3231+ 'os': null,
3232+
3233+ /**
3234+ * The alpha/beta release indicator.
3235+ *
3236+ * @memberOf Benchmark.platform
3237+ * @type String|Null
3238+ */
3239+ 'prerelease': null,
3240+
3241+ /**
3242+ * The browser/environment version.
3243+ *
3244+ * @memberOf Benchmark.platform
3245+ * @type String|Null
3246+ */
3247+ 'version': null,
3248+
3249+ /**
3250+ * Return platform description when the platform object is coerced to a string.
3251+ *
3252+ * @memberOf Benchmark.platform
3253+ * @type Function
3254+ * @returns {String} The platform description.
3255+ */
3256+ 'toString': function() {
3257+ return this.description || '';
3258+ }
3259+ },
3260+
3261+ /**
3262+ * The semantic version number.
3263+ *
3264+ * @static
3265+ * @memberOf Benchmark
3266+ * @type String
3267+ */
3268+ 'version': '1.0.0',
3269+
3270+ // an object of environment/feature detection flags
3271+ 'support': support,
3272+
3273+ // clone objects
3274+ 'deepClone': deepClone,
3275+
3276+ // iteration utility
3277+ 'each': each,
3278+
3279+ // augment objects
3280+ 'extend': extend,
3281+
3282+ // generic Array#filter
3283+ 'filter': filter,
3284+
3285+ // generic Array#forEach
3286+ 'forEach': forEach,
3287+
3288+ // generic own property iteration utility
3289+ 'forOwn': forOwn,
3290+
3291+ // converts a number to a comma-separated string
3292+ 'formatNumber': formatNumber,
3293+
3294+ // generic Object#hasOwnProperty
3295+ // (trigger hasKey's lazy define before assigning it to Benchmark)
3296+ 'hasKey': (hasKey(Benchmark, ''), hasKey),
3297+
3298+ // generic Array#indexOf
3299+ 'indexOf': indexOf,
3300+
3301+ // template utility
3302+ 'interpolate': interpolate,
3303+
3304+ // invokes a method on each item in an array
3305+ 'invoke': invoke,
3306+
3307+ // generic Array#join for arrays and objects
3308+ 'join': join,
3309+
3310+ // generic Array#map
3311+ 'map': map,
3312+
3313+ // retrieves a property value from each item in an array
3314+ 'pluck': pluck,
3315+
3316+ // generic Array#reduce
3317+ 'reduce': reduce
3318+ });
3319+
3320+ /*--------------------------------------------------------------------------*/
3321+
3322+ extend(Benchmark.prototype, {
3323+
3324+ /**
3325+ * The number of times a test was executed.
3326+ *
3327+ * @memberOf Benchmark
3328+ * @type Number
3329+ */
3330+ 'count': 0,
3331+
3332+ /**
3333+ * The number of cycles performed while benchmarking.
3334+ *
3335+ * @memberOf Benchmark
3336+ * @type Number
3337+ */
3338+ 'cycles': 0,
3339+
3340+ /**
3341+ * The number of executions per second.
3342+ *
3343+ * @memberOf Benchmark
3344+ * @type Number
3345+ */
3346+ 'hz': 0,
3347+
3348+ /**
3349+ * The compiled test function.
3350+ *
3351+ * @memberOf Benchmark
3352+ * @type Function|String
3353+ */
3354+ 'compiled': undefined,
3355+
3356+ /**
3357+ * The error object if the test failed.
3358+ *
3359+ * @memberOf Benchmark
3360+ * @type Object
3361+ */
3362+ 'error': undefined,
3363+
3364+ /**
3365+ * The test to benchmark.
3366+ *
3367+ * @memberOf Benchmark
3368+ * @type Function|String
3369+ */
3370+ 'fn': undefined,
3371+
3372+ /**
3373+ * A flag to indicate if the benchmark is aborted.
3374+ *
3375+ * @memberOf Benchmark
3376+ * @type Boolean
3377+ */
3378+ 'aborted': false,
3379+
3380+ /**
3381+ * A flag to indicate if the benchmark is running.
3382+ *
3383+ * @memberOf Benchmark
3384+ * @type Boolean
3385+ */
3386+ 'running': false,
3387+
3388+ /**
3389+ * Compiled into the test and executed immediately **before** the test loop.
3390+ *
3391+ * @memberOf Benchmark
3392+ * @type Function|String
3393+ * @example
3394+ *
3395+ * // basic usage
3396+ * var bench = Benchmark({
3397+ * 'setup': function() {
3398+ * var c = this.count,
3399+ * element = document.getElementById('container');
3400+ * while (c--) {
3401+ * element.appendChild(document.createElement('div'));
3402+ * }
3403+ * },
3404+ * 'fn': function() {
3405+ * element.removeChild(element.lastChild);
3406+ * }
3407+ * });
3408+ *
3409+ * // compiles to something like:
3410+ * var c = this.count,
3411+ * element = document.getElementById('container');
3412+ * while (c--) {
3413+ * element.appendChild(document.createElement('div'));
3414+ * }
3415+ * var start = new Date;
3416+ * while (count--) {
3417+ * element.removeChild(element.lastChild);
3418+ * }
3419+ * var end = new Date - start;
3420+ *
3421+ * // or using strings
3422+ * var bench = Benchmark({
3423+ * 'setup': '\
3424+ * var a = 0;\n\
3425+ * (function() {\n\
3426+ * (function() {\n\
3427+ * (function() {',
3428+ * 'fn': 'a += 1;',
3429+ * 'teardown': '\
3430+ * }())\n\
3431+ * }())\n\
3432+ * }())'
3433+ * });
3434+ *
3435+ * // compiles to something like:
3436+ * var a = 0;
3437+ * (function() {
3438+ * (function() {
3439+ * (function() {
3440+ * var start = new Date;
3441+ * while (count--) {
3442+ * a += 1;
3443+ * }
3444+ * var end = new Date - start;
3445+ * }())
3446+ * }())
3447+ * }())
3448+ */
3449+ 'setup': noop,
3450+
3451+ /**
3452+ * Compiled into the test and executed immediately **after** the test loop.
3453+ *
3454+ * @memberOf Benchmark
3455+ * @type Function|String
3456+ */
3457+ 'teardown': noop,
3458+
3459+ /**
3460+ * An object of stats including mean, margin or error, and standard deviation.
3461+ *
3462+ * @memberOf Benchmark
3463+ * @type Object
3464+ */
3465+ 'stats': {
3466+
3467+ /**
3468+ * The margin of error.
3469+ *
3470+ * @memberOf Benchmark#stats
3471+ * @type Number
3472+ */
3473+ 'moe': 0,
3474+
3475+ /**
3476+ * The relative margin of error (expressed as a percentage of the mean).
3477+ *
3478+ * @memberOf Benchmark#stats
3479+ * @type Number
3480+ */
3481+ 'rme': 0,
3482+
3483+ /**
3484+ * The standard error of the mean.
3485+ *
3486+ * @memberOf Benchmark#stats
3487+ * @type Number
3488+ */
3489+ 'sem': 0,
3490+
3491+ /**
3492+ * The sample standard deviation.
3493+ *
3494+ * @memberOf Benchmark#stats
3495+ * @type Number
3496+ */
3497+ 'deviation': 0,
3498+
3499+ /**
3500+ * The sample arithmetic mean.
3501+ *
3502+ * @memberOf Benchmark#stats
3503+ * @type Number
3504+ */
3505+ 'mean': 0,
3506+
3507+ /**
3508+ * The array of sampled periods.
3509+ *
3510+ * @memberOf Benchmark#stats
3511+ * @type Array
3512+ */
3513+ 'sample': [],
3514+
3515+ /**
3516+ * The sample variance.
3517+ *
3518+ * @memberOf Benchmark#stats
3519+ * @type Number
3520+ */
3521+ 'variance': 0
3522+ },
3523+
3524+ /**
3525+ * An object of timing data including cycle, elapsed, period, start, and stop.
3526+ *
3527+ * @memberOf Benchmark
3528+ * @type Object
3529+ */
3530+ 'times': {
3531+
3532+ /**
3533+ * The time taken to complete the last cycle (secs).
3534+ *
3535+ * @memberOf Benchmark#times
3536+ * @type Number
3537+ */
3538+ 'cycle': 0,
3539+
3540+ /**
3541+ * The time taken to complete the benchmark (secs).
3542+ *
3543+ * @memberOf Benchmark#times
3544+ * @type Number
3545+ */
3546+ 'elapsed': 0,
3547+
3548+ /**
3549+ * The time taken to execute the test once (secs).
3550+ *
3551+ * @memberOf Benchmark#times
3552+ * @type Number
3553+ */
3554+ 'period': 0,
3555+
3556+ /**
3557+ * A timestamp of when the benchmark started (ms).
3558+ *
3559+ * @memberOf Benchmark#times
3560+ * @type Number
3561+ */
3562+ 'timeStamp': 0
3563+ },
3564+
3565+ // aborts benchmark (does not record times)
3566+ 'abort': abort,
3567+
3568+ // creates a new benchmark using the same test and options
3569+ 'clone': clone,
3570+
3571+ // compares benchmark's hertz with another
3572+ 'compare': compare,
3573+
3574+ // executes listeners
3575+ 'emit': emit,
3576+
3577+ // get listeners
3578+ 'listeners': listeners,
3579+
3580+ // unregister listeners
3581+ 'off': off,
3582+
3583+ // register listeners
3584+ 'on': on,
3585+
3586+ // reset benchmark properties
3587+ 'reset': reset,
3588+
3589+ // runs the benchmark
3590+ 'run': run,
3591+
3592+ // pretty print benchmark info
3593+ 'toString': toStringBench
3594+ });
3595+
3596+ /*--------------------------------------------------------------------------*/
3597+
3598+ extend(Deferred.prototype, {
3599+
3600+ /**
3601+ * The deferred benchmark instance.
3602+ *
3603+ * @memberOf Benchmark.Deferred
3604+ * @type Object
3605+ */
3606+ 'benchmark': null,
3607+
3608+ /**
3609+ * The number of deferred cycles performed while benchmarking.
3610+ *
3611+ * @memberOf Benchmark.Deferred
3612+ * @type Number
3613+ */
3614+ 'cycles': 0,
3615+
3616+ /**
3617+ * The time taken to complete the deferred benchmark (secs).
3618+ *
3619+ * @memberOf Benchmark.Deferred
3620+ * @type Number
3621+ */
3622+ 'elapsed': 0,
3623+
3624+ /**
3625+ * A timestamp of when the deferred benchmark started (ms).
3626+ *
3627+ * @memberOf Benchmark.Deferred
3628+ * @type Number
3629+ */
3630+ 'timeStamp': 0,
3631+
3632+ // cycles/completes the deferred benchmark
3633+ 'resolve': resolve
3634+ });
3635+
3636+ /*--------------------------------------------------------------------------*/
3637+
3638+ extend(Event.prototype, {
3639+
3640+ /**
3641+ * A flag to indicate if the emitters listener iteration is aborted.
3642+ *
3643+ * @memberOf Benchmark.Event
3644+ * @type Boolean
3645+ */
3646+ 'aborted': false,
3647+
3648+ /**
3649+ * A flag to indicate if the default action is cancelled.
3650+ *
3651+ * @memberOf Benchmark.Event
3652+ * @type Boolean
3653+ */
3654+ 'cancelled': false,
3655+
3656+ /**
3657+ * The object whose listeners are currently being processed.
3658+ *
3659+ * @memberOf Benchmark.Event
3660+ * @type Object
3661+ */
3662+ 'currentTarget': undefined,
3663+
3664+ /**
3665+ * The return value of the last executed listener.
3666+ *
3667+ * @memberOf Benchmark.Event
3668+ * @type Mixed
3669+ */
3670+ 'result': undefined,
3671+
3672+ /**
3673+ * The object to which the event was originally emitted.
3674+ *
3675+ * @memberOf Benchmark.Event
3676+ * @type Object
3677+ */
3678+ 'target': undefined,
3679+
3680+ /**
3681+ * A timestamp of when the event was created (ms).
3682+ *
3683+ * @memberOf Benchmark.Event
3684+ * @type Number
3685+ */
3686+ 'timeStamp': 0,
3687+
3688+ /**
3689+ * The event type.
3690+ *
3691+ * @memberOf Benchmark.Event
3692+ * @type String
3693+ */
3694+ 'type': ''
3695+ });
3696+
3697+ /*--------------------------------------------------------------------------*/
3698+
3699+ /**
3700+ * The default options copied by suite instances.
3701+ *
3702+ * @static
3703+ * @memberOf Benchmark.Suite
3704+ * @type Object
3705+ */
3706+ Suite.options = {
3707+
3708+ /**
3709+ * The name of the suite.
3710+ *
3711+ * @memberOf Benchmark.Suite.options
3712+ * @type String
3713+ */
3714+ 'name': undefined
3715+ };
3716+
3717+ /*--------------------------------------------------------------------------*/
3718+
3719+ extend(Suite.prototype, {
3720+
3721+ /**
3722+ * The number of benchmarks in the suite.
3723+ *
3724+ * @memberOf Benchmark.Suite
3725+ * @type Number
3726+ */
3727+ 'length': 0,
3728+
3729+ /**
3730+ * A flag to indicate if the suite is aborted.
3731+ *
3732+ * @memberOf Benchmark.Suite
3733+ * @type Boolean
3734+ */
3735+ 'aborted': false,
3736+
3737+ /**
3738+ * A flag to indicate if the suite is running.
3739+ *
3740+ * @memberOf Benchmark.Suite
3741+ * @type Boolean
3742+ */
3743+ 'running': false,
3744+
3745+ /**
3746+ * An `Array#forEach` like method.
3747+ * Callbacks may terminate the loop by explicitly returning `false`.
3748+ *
3749+ * @memberOf Benchmark.Suite
3750+ * @param {Function} callback The function called per iteration.
3751+ * @returns {Object} The suite iterated over.
3752+ */
3753+ 'forEach': methodize(forEach),
3754+
3755+ /**
3756+ * An `Array#indexOf` like method.
3757+ *
3758+ * @memberOf Benchmark.Suite
3759+ * @param {Mixed} value The value to search for.
3760+ * @returns {Number} The index of the matched value or `-1`.
3761+ */
3762+ 'indexOf': methodize(indexOf),
3763+
3764+ /**
3765+ * Invokes a method on all benchmarks in the suite.
3766+ *
3767+ * @memberOf Benchmark.Suite
3768+ * @param {String|Object} name The name of the method to invoke OR options object.
3769+ * @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
3770+ * @returns {Array} A new array of values returned from each method invoked.
3771+ */
3772+ 'invoke': methodize(invoke),
3773+
3774+ /**
3775+ * Converts the suite of benchmarks to a string.
3776+ *
3777+ * @memberOf Benchmark.Suite
3778+ * @param {String} [separator=','] A string to separate each element of the array.
3779+ * @returns {String} The string.
3780+ */
3781+ 'join': [].join,
3782+
3783+ /**
3784+ * An `Array#map` like method.
3785+ *
3786+ * @memberOf Benchmark.Suite
3787+ * @param {Function} callback The function called per iteration.
3788+ * @returns {Array} A new array of values returned by the callback.
3789+ */
3790+ 'map': methodize(map),
3791+
3792+ /**
3793+ * Retrieves the value of a specified property from all benchmarks in the suite.
3794+ *
3795+ * @memberOf Benchmark.Suite
3796+ * @param {String} property The property to pluck.
3797+ * @returns {Array} A new array of property values.
3798+ */
3799+ 'pluck': methodize(pluck),
3800+
3801+ /**
3802+ * Removes the last benchmark from the suite and returns it.
3803+ *
3804+ * @memberOf Benchmark.Suite
3805+ * @returns {Mixed} The removed benchmark.
3806+ */
3807+ 'pop': [].pop,
3808+
3809+ /**
3810+ * Appends benchmarks to the suite.
3811+ *
3812+ * @memberOf Benchmark.Suite
3813+ * @returns {Number} The suite's new length.
3814+ */
3815+ 'push': [].push,
3816+
3817+ /**
3818+ * Sorts the benchmarks of the suite.
3819+ *
3820+ * @memberOf Benchmark.Suite
3821+ * @param {Function} [compareFn=null] A function that defines the sort order.
3822+ * @returns {Object} The sorted suite.
3823+ */
3824+ 'sort': [].sort,
3825+
3826+ /**
3827+ * An `Array#reduce` like method.
3828+ *
3829+ * @memberOf Benchmark.Suite
3830+ * @param {Function} callback The function called per iteration.
3831+ * @param {Mixed} accumulator Initial value of the accumulator.
3832+ * @returns {Mixed} The accumulator.
3833+ */
3834+ 'reduce': methodize(reduce),
3835+
3836+ // aborts all benchmarks in the suite
3837+ 'abort': abortSuite,
3838+
3839+ // adds a benchmark to the suite
3840+ 'add': add,
3841+
3842+ // creates a new suite with cloned benchmarks
3843+ 'clone': cloneSuite,
3844+
3845+ // executes listeners of a specified type
3846+ 'emit': emit,
3847+
3848+ // creates a new suite of filtered benchmarks
3849+ 'filter': filterSuite,
3850+
3851+ // get listeners
3852+ 'listeners': listeners,
3853+
3854+ // unregister listeners
3855+ 'off': off,
3856+
3857+ // register listeners
3858+ 'on': on,
3859+
3860+ // resets all benchmarks in the suite
3861+ 'reset': resetSuite,
3862+
3863+ // runs all benchmarks in the suite
3864+ 'run': runSuite,
3865+
3866+ // array methods
3867+ 'concat': concat,
3868+
3869+ 'reverse': reverse,
3870+
3871+ 'shift': shift,
3872+
3873+ 'slice': slice,
3874+
3875+ 'splice': splice,
3876+
3877+ 'unshift': unshift
3878+ });
3879+
3880+ /*--------------------------------------------------------------------------*/
3881+
3882+ // expose Deferred, Event and Suite
3883+ extend(Benchmark, {
3884+ 'Deferred': Deferred,
3885+ 'Event': Event,
3886+ 'Suite': Suite
3887+ });
3888+
3889+ // expose Benchmark
3890+ // some AMD build optimizers, like r.js, check for specific condition patterns like the following:
3891+ if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
3892+ // define as an anonymous module so, through path mapping, it can be aliased
3893+ define(function() {
3894+ return Benchmark;
3895+ });
3896+ }
3897+ // check for `exports` after `define` in case a build optimizer adds an `exports` object
3898+ else if (freeExports) {
3899+ // in Node.js or RingoJS v0.8.0+
3900+ if (typeof module == 'object' && module && module.exports == freeExports) {
3901+ (module.exports = Benchmark).Benchmark = Benchmark;
3902+ }
3903+ // in Narwhal or RingoJS v0.7.0-
3904+ else {
3905+ freeExports.Benchmark = Benchmark;
3906+ }
3907+ }
3908+ // in a browser or Rhino
3909+ else {
3910+ // use square bracket notation so Closure Compiler won't munge `Benchmark`
3911+ // http://code.google.com/closure/compiler/docs/api-tutorial3.html#export
3912+ window['Benchmark'] = Benchmark;
3913+ }
3914+
3915+ // trigger clock's lazy define early to avoid a security error
3916+ if (support.air) {
3917+ clock({ '_original': { 'fn': noop, 'count': 1, 'options': {} } });
3918+ }
3919+}(this));