Skip to content

Instantly share code, notes, and snippets.

@lautis

lautis/benchmark.html

Created January 17, 2014 10:18
Show Gist options
  • Save lautis/8471189 to your computer and use it in GitHub Desktop.
Save lautis/8471189 to your computer and use it in GitHub Desktop.
Download ZIP
Flowdock-Text PR #6 benchmark
Raw
benchmark.html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8" />
<title></title>
<script src="flowdock-text.js" type="text/javascript" charset="utf-8"></script>
<script src="flowdock-text-old.js" type="text/javascript" charset="utf-8"></script>
<script src="benchmark.js"></script>
<script>
function run(suite) {
suite.on('cycle', function(event) {
console.log(String(event.target));
})
.on('complete', function() {
console.log('Fastest is ' + this.filter('fastest').pluck('name'));
}).run();
}
var samples = [];
var size = 1000;
var evilchars = "().#,";
var i = 0;
var text;
while (size > 0) {
text = "foo bar #hashtag http://www.google.com/lol";
for(i=0; i < size; i++ )
text += evilchars.charAt(Math.floor(Math.random() * evilchars.length));
samples.push(text);
size--;
}
var suite = new Benchmark.Suite;
// add tests
suite.add('FlowdockText (old)', function() {
var i;
for (i = samples.length - 1; i >= 0; i--) {
FlowdockOldText.extractUrls(samples[i])
FlowdockOldText.extractHashtags(samples[i])
}
})
.add('FlowdockText (pr)', function() {
var i;
for (i = samples.length; i >= 0; i--) {
FlowdockText.extractUrls(samples[i])
FlowdockText.extractHashtags(samples[i])
}
})
run(suite)
var longsuite = new Benchmark.Suite;
// add tests
longsuite.add('FlowdockText (old) 1000 evil chars)', function() {
FlowdockOldText.extractUrls(samples[0]);
FlowdockOldText.extractHashtags(samples[0]);
})
.add('FlowdockText (pr) 1000 evil chars', function() {
FlowdockText.extractUrls(samples[0])
FlowdockText.extractHashtags(samples[0])
})
run(longsuite)
var shortsuite = new Benchmark.Suite;
// add tests
shortsuite.add('FlowdockText (old) 100 evil chars)', function() {
FlowdockOldText.extractUrls(samples[900]);
FlowdockOldText.extractHashtags(samples[900]);
})
.add('FlowdockText (pr) 100 evil chars', function() {
FlowdockText.extractUrls(samples[900])
FlowdockText.extractHashtags(samples[900])
})
run(shortsuite)
var nicesuite = new Benchmark.Suite;
// add tests
nicesuite.add('FlowdockText (old) 0 evil chars)', function() {
FlowdockOldText.extractUrls(samples[999]);
FlowdockOldText.extractHashtags(samples[999]);
})
.add('FlowdockText (pr) 0 evil chars', function() {
FlowdockText.extractUrls(samples[999])
FlowdockText.extractHashtags(samples[999])
})
run(nicesuite)
</script>
</head>
</html>
Raw
benchmark.js
/*!
* Benchmark.js v1.0.0 <http://benchmarkjs.com/>
* Copyright 2010-2012 Mathias Bynens <http://mths.be/>
* Based on JSLitmus.js, copyright Robert Kieffer <http://broofa.com/>
* Modified by John-David Dalton <http://allyoucanleet.com/>
* Available under MIT license <http://mths.be/mit>
*/
;(function(window, undefined) {
'use strict';
/** Used to assign each benchmark an incrimented id */
var counter = 0;
/** Detect DOM document object */
var doc = isHostType(window, 'document') && document;
/** Detect free variable `define` */
var freeDefine = typeof define == 'function' &&
typeof define.amd == 'object' && define.amd && define;
/** Detect free variable `exports` */
var freeExports = typeof exports == 'object' && exports &&
(typeof global == 'object' && global && global == global.global && (window = global), exports);
/** Detect free variable `require` */
var freeRequire = typeof require == 'function' && require;
/** Used to crawl all properties regardless of enumerability */
var getAllKeys = Object.getOwnPropertyNames;
/** Used to get property descriptors */
var getDescriptor = Object.getOwnPropertyDescriptor;
/** Used in case an object doesn't have its own method */
var hasOwnProperty = {}.hasOwnProperty;
/** Used to check if an object is extensible */
var isExtensible = Object.isExtensible || function() { return true; };
/** Used to access Wade Simmons' Node microtime module */
var microtimeObject = req('microtime');
/** Used to access the browser's high resolution timer */
var perfObject = isHostType(window, 'performance') && performance;
/** Used to call the browser's high resolution timer */
var perfName = perfObject && (
perfObject.now && 'now' ||
perfObject.webkitNow && 'webkitNow'
);
/** Used to access Node's high resolution timer */
var processObject = isHostType(window, 'process') && process;
/** Used to check if an own property is enumerable */
var propertyIsEnumerable = {}.propertyIsEnumerable;
/** Used to set property descriptors */
var setDescriptor = Object.defineProperty;
/** Used to resolve a value's internal [[Class]] */
var toString = {}.toString;
/** Used to prevent a `removeChild` memory leak in IE < 9 */
var trash = doc && doc.createElement('div');
/** Used to integrity check compiled tests */
var uid = 'uid' + (+new Date);
/** Used to avoid infinite recursion when methods call each other */
var calledBy = {};
/** Used to avoid hz of Infinity */
var divisors = {
'1': 4096,
'2': 512,
'3': 64,
'4': 8,
'5': 0
};
/**
* T-Distribution two-tailed critical values for 95% confidence
* http://www.itl.nist.gov/div898/handbook/eda/section3/eda3672.htm
*/
var tTable = {
'1': 12.706,'2': 4.303, '3': 3.182, '4': 2.776, '5': 2.571, '6': 2.447,
'7': 2.365, '8': 2.306, '9': 2.262, '10': 2.228, '11': 2.201, '12': 2.179,
'13': 2.16, '14': 2.145, '15': 2.131, '16': 2.12, '17': 2.11, '18': 2.101,
'19': 2.093, '20': 2.086, '21': 2.08, '22': 2.074, '23': 2.069, '24': 2.064,
'25': 2.06, '26': 2.056, '27': 2.052, '28': 2.048, '29': 2.045, '30': 2.042,
'infinity': 1.96
};
/**
* Critical Mann-Whitney U-values for 95% confidence
* http://www.saburchill.com/IBbiology/stats/003.html
*/
var uTable = {
'5': [0, 1, 2],
'6': [1, 2, 3, 5],
'7': [1, 3, 5, 6, 8],
'8': [2, 4, 6, 8, 10, 13],
'9': [2, 4, 7, 10, 12, 15, 17],
'10': [3, 5, 8, 11, 14, 17, 20, 23],
'11': [3, 6, 9, 13, 16, 19, 23, 26, 30],
'12': [4, 7, 11, 14, 18, 22, 26, 29, 33, 37],
'13': [4, 8, 12, 16, 20, 24, 28, 33, 37, 41, 45],
'14': [5, 9, 13, 17, 22, 26, 31, 36, 40, 45, 50, 55],
'15': [5, 10, 14, 19, 24, 29, 34, 39, 44, 49, 54, 59, 64],
'16': [6, 11, 15, 21, 26, 31, 37, 42, 47, 53, 59, 64, 70, 75],
'17': [6, 11, 17, 22, 28, 34, 39, 45, 51, 57, 63, 67, 75, 81, 87],
'18': [7, 12, 18, 24, 30, 36, 42, 48, 55, 61, 67, 74, 80, 86, 93, 99],
'19': [7, 13, 19, 25, 32, 38, 45, 52, 58, 65, 72, 78, 85, 92, 99, 106, 113],
'20': [8, 14, 20, 27, 34, 41, 48, 55, 62, 69, 76, 83, 90, 98, 105, 112, 119, 127],
'21': [8, 15, 22, 29, 36, 43, 50, 58, 65, 73, 80, 88, 96, 103, 111, 119, 126, 134, 142],
'22': [9, 16, 23, 30, 38, 45, 53, 61, 69, 77, 85, 93, 101, 109, 117, 125, 133, 141, 150, 158],
'23': [9, 17, 24, 32, 40, 48, 56, 64, 73, 81, 89, 98, 106, 115, 123, 132, 140, 149, 157, 166, 175],
'24': [10, 17, 25, 33, 42, 50, 59, 67, 76, 85, 94, 102, 111, 120, 129, 138, 147, 156, 165, 174, 183, 192],
'25': [10, 18, 27, 35, 44, 53, 62, 71, 80, 89, 98, 107, 117, 126, 135, 145, 154, 163, 173, 182, 192, 201, 211],
'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],
'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],
'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],
'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],
'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]
};
/**
* An object used to flag environments/features.
*
* @static
* @memberOf Benchmark
* @type Object
*/
var support = {};
(function() {
/**
* Detect Adobe AIR.
*
* @memberOf Benchmark.support
* @type Boolean
*/
support.air = isClassOf(window.runtime, 'ScriptBridgingProxyObject');
/**
* Detect if `arguments` objects have the correct internal [[Class]] value.
*
* @memberOf Benchmark.support
* @type Boolean
*/
support.argumentsClass = isClassOf(arguments, 'Arguments');
/**
* Detect if in a browser environment.
*
* @memberOf Benchmark.support
* @type Boolean
*/
support.browser = doc && isHostType(window, 'navigator');
/**
* Detect if strings support accessing characters by index.
*
* @memberOf Benchmark.support
* @type Boolean
*/
support.charByIndex =
// IE 8 supports indexes on string literals but not string objects
('x'[0] + Object('x')[0]) == 'xx';
/**
* Detect if strings have indexes as own properties.
*
* @memberOf Benchmark.support
* @type Boolean
*/
support.charByOwnIndex =
// Narwhal, Rhino, RingoJS, IE 8, and Opera < 10.52 support indexes on
// strings but don't detect them as own properties
support.charByIndex && hasKey('x', '0');
/**
* Detect if Java is enabled/exposed.
*
* @memberOf Benchmark.support
* @type Boolean
*/
support.java = isClassOf(window.java, 'JavaPackage');
/**
* Detect if the Timers API exists.
*
* @memberOf Benchmark.support
* @type Boolean
*/
support.timeout = isHostType(window, 'setTimeout') && isHostType(window, 'clearTimeout');
/**
* Detect if functions support decompilation.
*
* @name decompilation
* @memberOf Benchmark.support
* @type Boolean
*/
try {
// Safari 2.x removes commas in object literals
// from Function#toString results
// http://webk.it/11609
// Firefox 3.6 and Opera 9.25 strip grouping
// parentheses from Function#toString results
// http://bugzil.la/559438
support.decompilation = Function(
'return (' + (function(x) { return { 'x': '' + (1 + x) + '', 'y': 0 }; }) + ')'
)()(0).x === '1';
} catch(e) {
support.decompilation = false;
}
/**
* Detect ES5+ property descriptor API.
*
* @name descriptors
* @memberOf Benchmark.support
* @type Boolean
*/
try {
var o = {};
support.descriptors = (setDescriptor(o, o, o), 'value' in getDescriptor(o, o));
} catch(e) {
support.descriptors = false;
}
/**
* Detect ES5+ Object.getOwnPropertyNames().
*
* @name getAllKeys
* @memberOf Benchmark.support
* @type Boolean
*/
try {
support.getAllKeys = /\bvalueOf\b/.test(getAllKeys(Object.prototype));
} catch(e) {
support.getAllKeys = false;
}
/**
* Detect if own properties are iterated before inherited properties (all but IE < 9).
*
* @name iteratesOwnLast
* @memberOf Benchmark.support
* @type Boolean
*/
support.iteratesOwnFirst = (function() {
var props = [];
function ctor() { this.x = 1; }
ctor.prototype = { 'y': 1 };
for (var prop in new ctor) { props.push(prop); }
return props[0] == 'x';
}());
/**
* Detect if a node's [[Class]] is resolvable (all but IE < 9)
* and that the JS engine errors when attempting to coerce an object to a
* string without a `toString` property value of `typeof` "function".
*
* @name nodeClass
* @memberOf Benchmark.support
* @type Boolean
*/
try {
support.nodeClass = ({ 'toString': 0 } + '', toString.call(doc || 0) != '[object Object]');
} catch(e) {
support.nodeClass = true;
}
}());
/**
* Timer object used by `clock()` and `Deferred#resolve`.
*
* @private
* @type Object
*/
var timer = {
/**
* The timer namespace object or constructor.
*
* @private
* @memberOf timer
* @type Function|Object
*/
'ns': Date,
/**
* Starts the deferred timer.
*
* @private
* @memberOf timer
* @param {Object} deferred The deferred instance.
*/
'start': null, // lazy defined in `clock()`
/**
* Stops the deferred timer.
*
* @private
* @memberOf timer
* @param {Object} deferred The deferred instance.
*/
'stop': null // lazy defined in `clock()`
};
/** Shortcut for inverse results */
var noArgumentsClass = !support.argumentsClass,
noCharByIndex = !support.charByIndex,
noCharByOwnIndex = !support.charByOwnIndex;
/** Math shortcuts */
var abs = Math.abs,
floor = Math.floor,
max = Math.max,
min = Math.min,
pow = Math.pow,
sqrt = Math.sqrt;
/*--------------------------------------------------------------------------*/
/**
* The Benchmark constructor.
*
* @constructor
* @param {String} name A name to identify the benchmark.
* @param {Function|String} fn The test to benchmark.
* @param {Object} [options={}] Options object.
* @example
*
* // basic usage (the `new` operator is optional)
* var bench = new Benchmark(fn);
*
* // or using a name first
* var bench = new Benchmark('foo', fn);
*
* // or with options
* var bench = new Benchmark('foo', fn, {
*
* // displayed by Benchmark#toString if `name` is not available
* 'id': 'xyz',
*
* // called when the benchmark starts running
* 'onStart': onStart,
*
* // called after each run cycle
* 'onCycle': onCycle,
*
* // called when aborted
* 'onAbort': onAbort,
*
* // called when a test errors
* 'onError': onError,
*
* // called when reset
* 'onReset': onReset,
*
* // called when the benchmark completes running
* 'onComplete': onComplete,
*
* // compiled/called before the test loop
* 'setup': setup,
*
* // compiled/called after the test loop
* 'teardown': teardown
* });
*
* // or name and options
* var bench = new Benchmark('foo', {
*
* // a flag to indicate the benchmark is deferred
* 'defer': true,
*
* // benchmark test function
* 'fn': function(deferred) {
* // call resolve() when the deferred test is finished
* deferred.resolve();
* }
* });
*
* // or options only
* var bench = new Benchmark({
*
* // benchmark name
* 'name': 'foo',
*
* // benchmark test as a string
* 'fn': '[1,2,3,4].sort()'
* });
*
* // a test's `this` binding is set to the benchmark instance
* var bench = new Benchmark('foo', function() {
* 'My name is '.concat(this.name); // My name is foo
* });
*/
function Benchmark(name, fn, options) {
var me = this;
// allow instance creation without the `new` operator
if (me == null || me.constructor != Benchmark) {
return new Benchmark(name, fn, options);
}
// juggle arguments
if (isClassOf(name, 'Object')) {
// 1 argument (options)
options = name;
}
else if (isClassOf(name, 'Function')) {
// 2 arguments (fn, options)
options = fn;
fn = name;
}
else if (isClassOf(fn, 'Object')) {
// 2 arguments (name, options)
options = fn;
fn = null;
me.name = name;
}
else {
// 3 arguments (name, fn [, options])
me.name = name;
}
setOptions(me, options);
me.id || (me.id = ++counter);
me.fn == null && (me.fn = fn);
me.stats = deepClone(me.stats);
me.times = deepClone(me.times);
}
/**
* The Deferred constructor.
*
* @constructor
* @memberOf Benchmark
* @param {Object} clone The cloned benchmark instance.
*/
function Deferred(clone) {
var me = this;
if (me == null || me.constructor != Deferred) {
return new Deferred(clone);
}
me.benchmark = clone;
clock(me);
}
/**
* The Event constructor.
*
* @constructor
* @memberOf Benchmark
* @param {String|Object} type The event type.
*/
function Event(type) {
var me = this;
return (me == null || me.constructor != Event)
? new Event(type)
: (type instanceof Event)
? type
: extend(me, { 'timeStamp': +new Date }, typeof type == 'string' ? { 'type': type } : type);
}
/**
* The Suite constructor.
*
* @constructor
* @memberOf Benchmark
* @param {String} name A name to identify the suite.
* @param {Object} [options={}] Options object.
* @example
*
* // basic usage (the `new` operator is optional)
* var suite = new Benchmark.Suite;
*
* // or using a name first
* var suite = new Benchmark.Suite('foo');
*
* // or with options
* var suite = new Benchmark.Suite('foo', {
*
* // called when the suite starts running
* 'onStart': onStart,
*
* // called between running benchmarks
* 'onCycle': onCycle,
*
* // called when aborted
* 'onAbort': onAbort,
*
* // called when a test errors
* 'onError': onError,
*
* // called when reset
* 'onReset': onReset,
*
* // called when the suite completes running
* 'onComplete': onComplete
* });
*/
function Suite(name, options) {
var me = this;
// allow instance creation without the `new` operator
if (me == null || me.constructor != Suite) {
return new Suite(name, options);
}
// juggle arguments
if (isClassOf(name, 'Object')) {
// 1 argument (options)
options = name;
} else {
// 2 arguments (name [, options])
me.name = name;
}
setOptions(me, options);
}
/*--------------------------------------------------------------------------*/
/**
* Note: Some array methods have been implemented in plain JavaScript to avoid
* bugs in IE, Opera, Rhino, and Mobile Safari.
*
* IE compatibility mode and IE < 9 have buggy Array `shift()` and `splice()`
* functions that fail to remove the last element, `object[0]`, of
* array-like-objects even though the `length` property is set to `0`.
* The `shift()` method is buggy in IE 8 compatibility mode, while `splice()`
* is buggy regardless of mode in IE < 9 and buggy in compatibility mode in IE 9.
*
* In Opera < 9.50 and some older/beta Mobile Safari versions using `unshift()`
* generically to augment the `arguments` object will pave the value at index 0
* without incrimenting the other values's indexes.
* https://github.com/documentcloud/underscore/issues/9
*
* Rhino and environments it powers, like Narwhal and RingoJS, may have
* buggy Array `concat()`, `reverse()`, `shift()`, `slice()`, `splice()` and
* `unshift()` functions that make sparse arrays non-sparse by assigning the
* undefined indexes a value of undefined.
* https://github.com/mozilla/rhino/commit/702abfed3f8ca043b2636efd31c14ba7552603dd
*/
/**
* Creates an array containing the elements of the host array followed by the
* elements of each argument in order.
*
* @memberOf Benchmark.Suite
* @returns {Array} The new array.
*/
function concat() {
var value,
j = -1,
length = arguments.length,
result = slice.call(this),
index = result.length;
while (++j < length) {
value = arguments[j];
if (isClassOf(value, 'Array')) {
for (var k = 0, l = value.length; k < l; k++, index++) {
if (k in value) {
result[index] = value[k];
}
}
} else {
result[index++] = value;
}
}
return result;
}
/**
* Utility function used by `shift()`, `splice()`, and `unshift()`.
*
* @private
* @param {Number} start The index to start inserting elements.
* @param {Number} deleteCount The number of elements to delete from the insert point.
* @param {Array} elements The elements to insert.
* @returns {Array} An array of deleted elements.
*/
function insert(start, deleteCount, elements) {
// `result` should have its length set to the `deleteCount`
// see https://bugs.ecmascript.org/show_bug.cgi?id=332
var deleteEnd = start + deleteCount,
elementCount = elements ? elements.length : 0,
index = start - 1,
length = start + elementCount,
object = this,
result = Array(deleteCount),
tail = slice.call(object, deleteEnd);
// delete elements from the array
while (++index < deleteEnd) {
if (index in object) {
result[index - start] = object[index];
delete object[index];
}
}
// insert elements
index = start - 1;
while (++index < length) {
object[index] = elements[index - start];
}
// append tail elements
start = index--;
length = max(0, (object.length >>> 0) - deleteCount + elementCount);
while (++index < length) {
if ((index - start) in tail) {
object[index] = tail[index - start];
} else if (index in object) {
delete object[index];
}
}
// delete excess elements
deleteCount = deleteCount > elementCount ? deleteCount - elementCount : 0;
while (deleteCount--) {
index = length + deleteCount;
if (index in object) {
delete object[index];
}
}
object.length = length;
return result;
}
/**
* Rearrange the host array's elements in reverse order.
*
* @memberOf Benchmark.Suite
* @returns {Array} The reversed array.
*/
function reverse() {
var upperIndex,
value,
index = -1,
object = Object(this),
length = object.length >>> 0,
middle = floor(length / 2);
if (length > 1) {
while (++index < middle) {
upperIndex = length - index - 1;
value = upperIndex in object ? object[upperIndex] : uid;
if (index in object) {
object[upperIndex] = object[index];
} else {
delete object[upperIndex];
}
if (value != uid) {
object[index] = value;
} else {
delete object[index];
}
}
}
return object;
}
/**
* Removes the first element of the host array and returns it.
*
* @memberOf Benchmark.Suite
* @returns {Mixed} The first element of the array.
*/
function shift() {
return insert.call(this, 0, 1)[0];
}
/**
* Creates an array of the host array's elements from the start index up to,
* but not including, the end index.
*
* @memberOf Benchmark.Suite
* @param {Number} start The starting index.
* @param {Number} end The end index.
* @returns {Array} The new array.
*/
function slice(start, end) {
var index = -1,
object = Object(this),
length = object.length >>> 0,
result = [];
start = toInteger(start);
start = start < 0 ? max(length + start, 0) : min(start, length);
start--;
end = end == null ? length : toInteger(end);
end = end < 0 ? max(length + end, 0) : min(end, length);
while ((++index, ++start) < end) {
if (start in object) {
result[index] = object[start];
}
}
return result;
}
/**
* Allows removing a range of elements and/or inserting elements into the
* host array.
*
* @memberOf Benchmark.Suite
* @param {Number} start The start index.
* @param {Number} deleteCount The number of elements to delete.
* @param {Mixed} [val1, val2, ...] values to insert at the `start` index.
* @returns {Array} An array of removed elements.
*/
function splice(start, deleteCount) {
var object = Object(this),
length = object.length >>> 0;
start = toInteger(start);
start = start < 0 ? max(length + start, 0) : min(start, length);
// support the de-facto SpiderMonkey extension
// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/splice#Parameters
// https://bugs.ecmascript.org/show_bug.cgi?id=429
deleteCount = arguments.length == 1
? length - start
: min(max(toInteger(deleteCount), 0), length - start);
return insert.call(object, start, deleteCount, slice.call(arguments, 2));
}
/**
* Converts the specified `value` to an integer.
*
* @private
* @param {Mixed} value The value to convert.
* @returns {Number} The resulting integer.
*/
function toInteger(value) {
value = +value;
return value === 0 || !isFinite(value) ? value || 0 : value - (value % 1);
}
/**
* Appends arguments to the host array.
*
* @memberOf Benchmark.Suite
* @returns {Number} The new length.
*/
function unshift() {
var object = Object(this);
insert.call(object, 0, 0, arguments);
return object.length;
}
/*--------------------------------------------------------------------------*/
/**
* A generic `Function#bind` like method.
*
* @private
* @param {Function} fn The function to be bound to `thisArg`.
* @param {Mixed} thisArg The `this` binding for the given function.
* @returns {Function} The bound function.
*/
function bind(fn, thisArg) {
return function() { fn.apply(thisArg, arguments); };
}
/**
* Creates a function from the given arguments string and body.
*
* @private
* @param {String} args The comma separated function arguments.
* @param {String} body The function body.
* @returns {Function} The new function.
*/
function createFunction() {
// lazy define
createFunction = function(args, body) {
var result,
anchor = freeDefine ? define.amd : Benchmark,
prop = uid + 'createFunction';
runScript((freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '=function(' + args + '){' + body + '}');
result = anchor[prop];
delete anchor[prop];
return result;
};
// fix JaegerMonkey bug
// http://bugzil.la/639720
createFunction = support.browser && (createFunction('', 'return"' + uid + '"') || noop)() == uid ? createFunction : Function;
return createFunction.apply(null, arguments);
}
/**
* Delay the execution of a function based on the benchmark's `delay` property.
*
* @private
* @param {Object} bench The benchmark instance.
* @param {Object} fn The function to execute.
*/
function delay(bench, fn) {
bench._timerId = setTimeout(fn, bench.delay * 1e3);
}
/**
* Destroys the given element.
*
* @private
* @param {Element} element The element to destroy.
*/
function destroyElement(element) {
trash.appendChild(element);
trash.innerHTML = '';
}
/**
* Iterates over an object's properties, executing the `callback` for each.
* Callbacks may terminate the loop by explicitly returning `false`.
*
* @private
* @param {Object} object The object to iterate over.
* @param {Function} callback The function executed per own property.
* @param {Object} options The options object.
* @returns {Object} Returns the object iterated over.
*/
function forProps() {
var forShadowed,
skipSeen,
forArgs = true,
shadowed = ['constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'toLocaleString', 'toString', 'valueOf'];
(function(enumFlag, key) {
// must use a non-native constructor to catch the Safari 2 issue
function Klass() { this.valueOf = 0; };
Klass.prototype.valueOf = 0;
// check various for-in bugs
for (key in new Klass) {
enumFlag += key == 'valueOf' ? 1 : 0;
}
// check if `arguments` objects have non-enumerable indexes
for (key in arguments) {
key == '0' && (forArgs = false);
}
// Safari 2 iterates over shadowed properties twice
// http://replay.waybackmachine.org/20090428222941/http://tobielangel.com/2007/1/29/for-in-loop-broken-in-safari/
skipSeen = enumFlag == 2;
// IE < 9 incorrectly makes an object's properties non-enumerable if they have
// the same name as other non-enumerable properties in its prototype chain.
forShadowed = !enumFlag;
}(0));
// lazy define
forProps = function(object, callback, options) {
options || (options = {});
var result = object;
object = Object(object);
var ctor,
key,
keys,
skipCtor,
done = !result,
which = options.which,
allFlag = which == 'all',
index = -1,
iteratee = object,
length = object.length,
ownFlag = allFlag || which == 'own',
seen = {},
skipProto = isClassOf(object, 'Function'),
thisArg = options.bind;
if (thisArg !== undefined) {
callback = bind(callback, thisArg);
}
// iterate all properties
if (allFlag && support.getAllKeys) {
for (index = 0, keys = getAllKeys(object), length = keys.length; index < length; index++) {
key = keys[index];
if (callback(object[key], key, object) === false) {
break;
}
}
}
// else iterate only enumerable properties
else {
for (key in object) {
// Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1
// (if the prototype or a property on the prototype has been set)
// incorrectly set a function's `prototype` property [[Enumerable]] value
// to `true`. Because of this we standardize on skipping the `prototype`
// property of functions regardless of their [[Enumerable]] value.
if ((done =
!(skipProto && key == 'prototype') &&
!(skipSeen && (hasKey(seen, key) || !(seen[key] = true))) &&
(!ownFlag || ownFlag && hasKey(object, key)) &&
callback(object[key], key, object) === false)) {
break;
}
}
// in IE < 9 strings don't support accessing characters by index
if (!done && (forArgs && isArguments(object) ||
((noCharByIndex || noCharByOwnIndex) && isClassOf(object, 'String') &&
(iteratee = noCharByIndex ? object.split('') : object)))) {
while (++index < length) {
if ((done =
callback(iteratee[index], String(index), object) === false)) {
break;
}
}
}
if (!done && forShadowed) {
// Because IE < 9 can't set the `[[Enumerable]]` attribute of an existing
// property and the `constructor` property of a prototype defaults to
// non-enumerable, we manually skip the `constructor` property when we
// think we are iterating over a `prototype` object.
ctor = object.constructor;
skipCtor = ctor && ctor.prototype && ctor.prototype.constructor === ctor;
for (index = 0; index < 7; index++) {
key = shadowed[index];
if (!(skipCtor && key == 'constructor') &&
hasKey(object, key) &&
callback(object[key], key, object) === false) {
break;
}
}
}
}
return result;
};
return forProps.apply(null, arguments);
}
/**
* Gets the name of the first argument from a function's source.
*
* @private
* @param {Function} fn The function.
* @returns {String} The argument name.
*/
function getFirstArgument(fn) {
return (!hasKey(fn, 'toString') &&
(/^[\s(]*function[^(]*\(([^\s,)]+)/.exec(fn) || 0)[1]) || '';
}
/**
* Computes the arithmetic mean of a sample.
*
* @private
* @param {Array} sample The sample.
* @returns {Number} The mean.
*/
function getMean(sample) {
return reduce(sample, function(sum, x) {
return sum + x;
}) / sample.length || 0;
}
/**
* Gets the source code of a function.
*
* @private
* @param {Function} fn The function.
* @param {String} altSource A string used when a function's source code is unretrievable.
* @returns {String} The function's source code.
*/
function getSource(fn, altSource) {
var result = altSource;
if (isStringable(fn)) {
result = String(fn);
} else if (support.decompilation) {
// escape the `{` for Firefox 1
result = (/^[^{]+\{([\s\S]*)}\s*$/.exec(fn) || 0)[1];
}
// trim string
result = (result || '').replace(/^\s+|\s+$/g, '');
// detect strings containing only the "use strict" directive
return /^(?:\/\*+[\w|\W]*?\*\/|\/\/.*?[\n\r\u2028\u2029]|\s)*(["'])use strict\1;?$/.test(result)
? ''
: result;
}
/**
* Checks if a value is an `arguments` object.
*
* @private
* @param {Mixed} value The value to check.
* @returns {Boolean} Returns `true` if the value is an `arguments` object, else `false`.
*/
function isArguments() {
// lazy define
isArguments = function(value) {
return toString.call(value) == '[object Arguments]';
};
if (noArgumentsClass) {
isArguments = function(value) {
return hasKey(value, 'callee') &&
!(propertyIsEnumerable && propertyIsEnumerable.call(value, 'callee'));
};
}
return isArguments(arguments[0]);
}
/**
* Checks if an object is of the specified class.
*
* @private
* @param {Mixed} value The value to check.
* @param {String} name The name of the class.
* @returns {Boolean} Returns `true` if the value is of the specified class, else `false`.
*/
function isClassOf(value, name) {
return value != null && toString.call(value) == '[object ' + name + ']';
}
/**
* Host objects can return type values that are different from their actual
* data type. The objects we are concerned with usually return non-primitive
* types of object, function, or unknown.
*
* @private
* @param {Mixed} object The owner of the property.
* @param {String} property The property to check.
* @returns {Boolean} Returns `true` if the property value is a non-primitive, else `false`.
*/
function isHostType(object, property) {
var type = object != null ? typeof object[property] : 'number';
return !/^(?:boolean|number|string|undefined)$/.test(type) &&
(type == 'object' ? !!object[property] : true);
}
/**
* Checks if a given `value` is an object created by the `Object` constructor
* assuming objects created by the `Object` constructor have no inherited
* enumerable properties and that there are no `Object.prototype` extensions.
*
* @private
* @param {Mixed} value The value to check.
* @returns {Boolean} Returns `true` if the `value` is a plain `Object` object, else `false`.
*/
function isPlainObject(value) {
// avoid non-objects and false positives for `arguments` objects in IE < 9
var result = false;
if (!(value && typeof value == 'object') || isArguments(value)) {
return result;
}
// IE < 9 presents DOM nodes as `Object` objects except they have `toString`
// methods that are `typeof` "string" and still can coerce nodes to strings.
// Also check that the constructor is `Object` (i.e. `Object instanceof Object`)
var ctor = value.constructor;
if ((support.nodeClass || !(typeof value.toString != 'function' && typeof (value + '') == 'string')) &&
(!isClassOf(ctor, 'Function') || ctor instanceof ctor)) {
// In most environments an object's own properties are iterated before
// its inherited properties. If the last iterated property is an object's
// own property then there are no inherited enumerable properties.
if (support.iteratesOwnFirst) {
forProps(value, function(subValue, subKey) {
result = subKey;
});
return result === false || hasKey(value, result);
}
// IE < 9 iterates inherited properties before own properties. If the first
// iterated property is an object's own property then there are no inherited
// enumerable properties.
forProps(value, function(subValue, subKey) {
result = !hasKey(value, subKey);
return false;
});
return result === false;
}
return result;
}
/**
* Checks if a value can be safely coerced to a string.
*
* @private
* @param {Mixed} value The value to check.
* @returns {Boolean} Returns `true` if the value can be coerced, else `false`.
*/
function isStringable(value) {
return hasKey(value, 'toString') || isClassOf(value, 'String');
}
/**
* Wraps a function and passes `this` to the original function as the
* first argument.
*
* @private
* @param {Function} fn The function to be wrapped.
* @returns {Function} The new function.
*/
function methodize(fn) {
return function() {
var args = [this];
args.push.apply(args, arguments);
return fn.apply(null, args);
};
}
/**
* A no-operation function.
*
* @private
*/
function noop() {
// no operation performed
}
/**
* A wrapper around require() to suppress `module missing` errors.
*
* @private
* @param {String} id The module id.
* @returns {Mixed} The exported module or `null`.
*/
function req(id) {
try {
var result = freeExports && freeRequire(id);
} catch(e) { }
return result || null;
}
/**
* Runs a snippet of JavaScript via script injection.
*
* @private
* @param {String} code The code to run.
*/
function runScript(code) {
var anchor = freeDefine ? define.amd : Benchmark,
script = doc.createElement('script'),
sibling = doc.getElementsByTagName('script')[0],
parent = sibling.parentNode,
prop = uid + 'runScript',
prefix = '(' + (freeDefine ? 'define.amd.' : 'Benchmark.') + prop + '||function(){})();';
// Firefox 2.0.0.2 cannot use script injection as intended because it executes
// asynchronously, but that's OK because script injection is only used to avoid
// the previously commented JaegerMonkey bug.
try {
// remove the inserted script *before* running the code to avoid differences
// in the expected script element count/order of the document.
script.appendChild(doc.createTextNode(prefix + code));
anchor[prop] = function() { destroyElement(script); };
} catch(e) {
parent = parent.cloneNode(false);
sibling = null;
script.text = code;
}
parent.insertBefore(script, sibling);
delete anchor[prop];
}
/**
* A helper function for setting options/event handlers.
*
* @private
* @param {Object} bench The benchmark instance.
* @param {Object} [options={}] Options object.
*/
function setOptions(bench, options) {
options = extend({}, bench.constructor.options, options);
bench.options = forOwn(options, function(value, key) {
if (value != null) {
// add event listeners
if (/^on[A-Z]/.test(key)) {
forEach(key.split(' '), function(key) {
bench.on(key.slice(2).toLowerCase(), value);
});
} else if (!hasKey(bench, key)) {
bench[key] = deepClone(value);
}
}
});
}
/*--------------------------------------------------------------------------*/
/**
* Handles cycling/completing the deferred benchmark.
*
* @memberOf Benchmark.Deferred
*/
function resolve() {
var me = this,
clone = me.benchmark,
bench = clone._original;
if (bench.aborted) {
// cycle() -> clone cycle/complete event -> compute()'s invoked bench.run() cycle/complete
me.teardown();
clone.running = false;
cycle(me);
}
else if (++me.cycles < clone.count) {
// continue the test loop
if (support.timeout) {
// use setTimeout to avoid a call stack overflow if called recursively
setTimeout(function() { clone.compiled.call(me, timer); }, 0);
} else {
clone.compiled.call(me, timer);
}
}
else {
timer.stop(me);
me.teardown();
delay(clone, function() { cycle(me); });
}
}
/*--------------------------------------------------------------------------*/
/**
* A deep clone utility.
*
* @static
* @memberOf Benchmark
* @param {Mixed} value The value to clone.
* @returns {Mixed} The cloned value.
*/
function deepClone(value) {
var accessor,
circular,
clone,
ctor,
descriptor,
extensible,
key,
length,
markerKey,
parent,
result,
source,
subIndex,
data = { 'value': value },
index = 0,
marked = [],
queue = { 'length': 0 },
unmarked = [];
/**
* An easily detectable decorator for cloned values.
*/
function Marker(object) {
this.raw = object;
}
/**
* The callback used by `forProps()`.
*/
function forPropsCallback(subValue, subKey) {
// exit early to avoid cloning the marker
if (subValue && subValue.constructor == Marker) {
return;
}
// add objects to the queue
if (subValue === Object(subValue)) {
queue[queue.length++] = { 'key': subKey, 'parent': clone, 'source': value };
}
// assign non-objects
else {
try {
// will throw an error in strict mode if the property is read-only
clone[subKey] = subValue;
} catch(e) { }
}
}
/**
* Gets an available marker key for the given object.
*/
function getMarkerKey(object) {
// avoid collisions with existing keys
var result = uid;
while (object[result] && object[result].constructor != Marker) {
result += 1;
}
return result;
}
do {
key = data.key;
parent = data.parent;
source = data.source;
clone = value = source ? source[key] : data.value;
accessor = circular = descriptor = false;
// create a basic clone to filter out functions, DOM elements, and
// other non `Object` objects
if (value === Object(value)) {
// use custom deep clone function if available
if (isClassOf(value.deepClone, 'Function')) {
clone = value.deepClone();
} else {
ctor = value.constructor;
switch (toString.call(value)) {
case '[object Array]':
clone = new ctor(value.length);
break;
case '[object Boolean]':
clone = new ctor(value == true);
break;
case '[object Date]':
clone = new ctor(+value);
break;
case '[object Object]':
isPlainObject(value) && (clone = {});
break;
case '[object Number]':
case '[object String]':
clone = new ctor(value);
break;
case '[object RegExp]':
clone = ctor(value.source,
(value.global ? 'g' : '') +
(value.ignoreCase ? 'i' : '') +
(value.multiline ? 'm' : ''));
}
}
// continue clone if `value` doesn't have an accessor descriptor
// http://es5.github.com/#x8.10.1
if (clone && clone != value &&
!(descriptor = source && support.descriptors && getDescriptor(source, key),
accessor = descriptor && (descriptor.get || descriptor.set))) {
// use an existing clone (circular reference)
if ((extensible = isExtensible(value))) {
markerKey = getMarkerKey(value);
if (value[markerKey]) {
circular = clone = value[markerKey].raw;
}
} else {
// for frozen/sealed objects
for (subIndex = 0, length = unmarked.length; subIndex < length; subIndex++) {
data = unmarked[subIndex];
if (data.object === value) {
circular = clone = data.clone;
break;
}
}
}
if (!circular) {
// mark object to allow quickly detecting circular references and tie it to its clone
if (extensible) {
value[markerKey] = new Marker(clone);
marked.push({ 'key': markerKey, 'object': value });
} else {
// for frozen/sealed objects
unmarked.push({ 'clone': clone, 'object': value });
}
// iterate over object properties
forProps(value, forPropsCallback, { 'which': 'all' });
}
}
}
if (parent) {
// for custom property descriptors
if (accessor || (descriptor && !(descriptor.configurable && descriptor.enumerable && descriptor.writable))) {
if ('value' in descriptor) {
descriptor.value = clone;
}
setDescriptor(parent, key, descriptor);
}
// for default property descriptors
else {
parent[key] = clone;
}
} else {
result = clone;
}
} while ((data = queue[index++]));
// remove markers
for (index = 0, length = marked.length; index < length; index++) {
data = marked[index];
delete data.object[data.key];
}
return result;
}
/**
* An iteration utility for arrays and objects.
* Callbacks may terminate the loop by explicitly returning `false`.
*
* @static
* @memberOf Benchmark
* @param {Array|Object} object The object to iterate over.
* @param {Function} callback The function called per iteration.
* @param {Mixed} thisArg The `this` binding for the callback.
* @returns {Array|Object} Returns the object iterated over.
*/
function each(object, callback, thisArg) {
var result = object;
object = Object(object);
var fn = callback,
index = -1,
length = object.length,
isSnapshot = !!(object.snapshotItem && (length = object.snapshotLength)),
isSplittable = (noCharByIndex || noCharByOwnIndex) && isClassOf(object, 'String'),
isConvertable = isSnapshot || isSplittable || 'item' in object,
origObject = object;
// in Opera < 10.5 `hasKey(object, 'length')` returns `false` for NodeLists
if (length === length >>> 0) {
if (isConvertable) {
// the third argument of the callback is the original non-array object
callback = function(value, index) {
return fn.call(this, value, index, origObject);
};
// in IE < 9 strings don't support accessing characters by index
if (isSplittable) {
object = object.split('');
} else {
object = [];
while (++index < length) {
// in Safari 2 `index in object` is always `false` for NodeLists
object[index] = isSnapshot ? result.snapshotItem(index) : result[index];
}
}
}
forEach(object, callback, thisArg);
} else {
forOwn(object, callback, thisArg);
}
return result;
}
/**
* Copies enumerable properties from the source(s) object to the destination object.
*
* @static
* @memberOf Benchmark
* @param {Object} destination The destination object.
* @param {Object} [source={}] The source object.
* @returns {Object} The destination object.
*/
function extend(destination, source) {
// Chrome < 14 incorrectly sets `destination` to `undefined` when we `delete arguments[0]`
// http://code.google.com/p/v8/issues/detail?id=839
var result = destination;
delete arguments[0];
forEach(arguments, function(source) {
forProps(source, function(value, key) {
result[key] = value;
});
});
return result;
}
/**
* A generic `Array#filter` like method.
*
* @static
* @memberOf Benchmark
* @param {Array} array The array to iterate over.
* @param {Function|String} callback The function/alias called per iteration.
* @param {Mixed} thisArg The `this` binding for the callback.
* @returns {Array} A new array of values that passed callback filter.
* @example
*
* // get odd numbers
* Benchmark.filter([1, 2, 3, 4, 5], function(n) {
* return n % 2;
* }); // -> [1, 3, 5];
*
* // get fastest benchmarks
* Benchmark.filter(benches, 'fastest');
*
* // get slowest benchmarks
* Benchmark.filter(benches, 'slowest');
*
* // get benchmarks that completed without erroring
* Benchmark.filter(benches, 'successful');
*/
function filter(array, callback, thisArg) {
var result;
if (callback == 'successful') {
// callback to exclude those that are errored, unrun, or have hz of Infinity
callback = function(bench) { return bench.cycles && isFinite(bench.hz); };
}
else if (callback == 'fastest' || callback == 'slowest') {
// get successful, sort by period + margin of error, and filter fastest/slowest
result = filter(array, 'successful').sort(function(a, b) {
a = a.stats; b = b.stats;
return (a.mean + a.moe > b.mean + b.moe ? 1 : -1) * (callback == 'fastest' ? 1 : -1);
});
result = filter(result, function(bench) {
return result[0].compare(bench) == 0;
});
}
return result || reduce(array, function(result, value, index) {
return callback.call(thisArg, value, index, array) ? (result.push(value), result) : result;
}, []);
}
/**
* A generic `Array#forEach` like method.
* Callbacks may terminate the loop by explicitly returning `false`.
*
* @static
* @memberOf Benchmark
* @param {Array} array The array to iterate over.
* @param {Function} callback The function called per iteration.
* @param {Mixed} thisArg The `this` binding for the callback.
* @returns {Array} Returns the array iterated over.
*/
function forEach(array, callback, thisArg) {
var index = -1,
length = (array = Object(array)).length >>> 0;
if (thisArg !== undefined) {
callback = bind(callback, thisArg);
}
while (++index < length) {
if (index in array &&
callback(array[index], index, array) === false) {
break;
}
}
return array;
}
/**
* Iterates over an object's own properties, executing the `callback` for each.
* Callbacks may terminate the loop by explicitly returning `false`.
*
* @static
* @memberOf Benchmark
* @param {Object} object The object to iterate over.
* @param {Function} callback The function executed per own property.
* @param {Mixed} thisArg The `this` binding for the callback.
* @returns {Object} Returns the object iterated over.
*/
function forOwn(object, callback, thisArg) {
return forProps(object, callback, { 'bind': thisArg, 'which': 'own' });
}
/**
* Converts a number to a more readable comma-separated string representation.
*
* @static
* @memberOf Benchmark
* @param {Number} number The number to convert.
* @returns {String} The more readable string representation.
*/
function formatNumber(number) {
number = String(number).split('.');
return number[0].replace(/(?=(?:\d{3})+$)(?!\b)/g, ',') +
(number[1] ? '.' + number[1] : '');
}
/**
* Checks if an object has the specified key as a direct property.
*
* @static
* @memberOf Benchmark
* @param {Object} object The object to check.
* @param {String} key The key to check for.
* @returns {Boolean} Returns `true` if key is a direct property, else `false`.
*/
function hasKey() {
// lazy define for worst case fallback (not as accurate)
hasKey = function(object, key) {
var parent = object != null && (object.constructor || Object).prototype;
return !!parent && key in Object(object) && !(key in parent && object[key] === parent[key]);
};
// for modern browsers
if (isClassOf(hasOwnProperty, 'Function')) {
hasKey = function(object, key) {
return object != null && hasOwnProperty.call(object, key);
};
}
// for Safari 2
else if ({}.__proto__ == Object.prototype) {
hasKey = function(object, key) {
var result = false;
if (object != null) {
object = Object(object);
object.__proto__ = [object.__proto__, object.__proto__ = null, result = key in object][0];
}
return result;
};
}
return hasKey.apply(this, arguments);
}
/**
* A generic `Array#indexOf` like method.
*
* @static
* @memberOf Benchmark
* @param {Array} array The array to iterate over.
* @param {Mixed} value The value to search for.
* @param {Number} [fromIndex=0] The index to start searching from.
* @returns {Number} The index of the matched value or `-1`.
*/
function indexOf(array, value, fromIndex) {
var index = toInteger(fromIndex),
length = (array = Object(array)).length >>> 0;
index = (index < 0 ? max(0, length + index) : index) - 1;
while (++index < length) {
if (index in array && value === array[index]) {
return index;
}
}
return -1;
}
/**
* Modify a string by replacing named tokens with matching object property values.
*
* @static
* @memberOf Benchmark
* @param {String} string The string to modify.
* @param {Object} object The template object.
* @returns {String} The modified string.
*/
function interpolate(string, object) {
forOwn(object, function(value, key) {
// escape regexp special characters in `key`
string = string.replace(RegExp('#\\{' + key.replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1') + '\\}', 'g'), value);
});
return string;
}
/**
* Invokes a method on all items in an array.
*
* @static
* @memberOf Benchmark
* @param {Array} benches Array of benchmarks to iterate over.
* @param {String|Object} name The name of the method to invoke OR options object.
* @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
* @returns {Array} A new array of values returned from each method invoked.
* @example
*
* // invoke `reset` on all benchmarks
* Benchmark.invoke(benches, 'reset');
*
* // invoke `emit` with arguments
* Benchmark.invoke(benches, 'emit', 'complete', listener);
*
* // invoke `run(true)`, treat benchmarks as a queue, and register invoke callbacks
* Benchmark.invoke(benches, {
*
* // invoke the `run` method
* 'name': 'run',
*
* // pass a single argument
* 'args': true,
*
* // treat as queue, removing benchmarks from front of `benches` until empty
* 'queued': true,
*
* // called before any benchmarks have been invoked.
* 'onStart': onStart,
*
* // called between invoking benchmarks
* 'onCycle': onCycle,
*
* // called after all benchmarks have been invoked.
* 'onComplete': onComplete
* });
*/
function invoke(benches, name) {
var args,
bench,
queued,
index = -1,
eventProps = { 'currentTarget': benches },
options = { 'onStart': noop, 'onCycle': noop, 'onComplete': noop },
result = map(benches, function(bench) { return bench; });
/**
* Invokes the method of the current object and if synchronous, fetches the next.
*/
function execute() {
var listeners,
async = isAsync(bench);
if (async) {
// use `getNext` as the first listener
bench.on('complete', getNext);
listeners = bench.events.complete;
listeners.splice(0, 0, listeners.pop());
}
// execute method
result[index] = isClassOf(bench && bench[name], 'Function') ? bench[name].apply(bench, args) : undefined;
// if synchronous return true until finished
return !async && getNext();
}
/**
* Fetches the next bench or executes `onComplete` callback.
*/
function getNext(event) {
var cycleEvent,
last = bench,
async = isAsync(last);
if (async) {
last.off('complete', getNext);
last.emit('complete');
}
// emit "cycle" event
eventProps.type = 'cycle';
eventProps.target = last;
cycleEvent = Event(eventProps);
options.onCycle.call(benches, cycleEvent);
// choose next benchmark if not exiting early
if (!cycleEvent.aborted && raiseIndex() !== false) {
bench = queued ? benches[0] : result[index];
if (isAsync(bench)) {
delay(bench, execute);
}
else if (async) {
// resume execution if previously asynchronous but now synchronous
while (execute()) { }
}
else {
// continue synchronous execution
return true;
}
} else {
// emit "complete" event
eventProps.type = 'complete';
options.onComplete.call(benches, Event(eventProps));
}
// When used as a listener `event.aborted = true` will cancel the rest of
// the "complete" listeners because they were already called above and when
// used as part of `getNext` the `return false` will exit the execution while-loop.
if (event) {
event.aborted = true;
} else {
return false;
}
}
/**
* Checks if invoking `Benchmark#run` with asynchronous cycles.
*/
function isAsync(object) {
// avoid using `instanceof` here because of IE memory leak issues with host objects
var async = args[0] && args[0].async;
return Object(object).constructor == Benchmark && name == 'run' &&
((async == null ? object.options.async : async) && support.timeout || object.defer);
}
/**
* Raises `index` to the next defined index or returns `false`.
*/
function raiseIndex() {
var length = result.length;
if (queued) {
// if queued remove the previous bench and subsequent skipped non-entries
do {
++index > 0 && shift.call(benches);
} while ((length = benches.length) && !('0' in benches));
}
else {
while (++index < length && !(index in result)) { }
}
// if we reached the last index then return `false`
return (queued ? length : index < length) ? index : (index = false);
}
// juggle arguments
if (isClassOf(name, 'String')) {
// 2 arguments (array, name)
args = slice.call(arguments, 2);
} else {
// 2 arguments (array, options)
options = extend(options, name);
name = options.name;
args = isClassOf(args = 'args' in options ? options.args : [], 'Array') ? args : [args];
queued = options.queued;
}
// start iterating over the array
if (raiseIndex() !== false) {
// emit "start" event
bench = result[index];
eventProps.type = 'start';
eventProps.target = bench;
options.onStart.call(benches, Event(eventProps));
// end early if the suite was aborted in an "onStart" listener
if (benches.aborted && benches.constructor == Suite && name == 'run') {
// emit "cycle" event
eventProps.type = 'cycle';
options.onCycle.call(benches, Event(eventProps));
// emit "complete" event
eventProps.type = 'complete';
options.onComplete.call(benches, Event(eventProps));
}
// else start
else {
if (isAsync(bench)) {
delay(bench, execute);
} else {
while (execute()) { }
}
}
}
return result;
}
/**
* Creates a string of joined array values or object key-value pairs.
*
* @static
* @memberOf Benchmark
* @param {Array|Object} object The object to operate on.
* @param {String} [separator1=','] The separator used between key-value pairs.
* @param {String} [separator2=': '] The separator used between keys and values.
* @returns {String} The joined result.
*/
function join(object, separator1, separator2) {
var result = [],
length = (object = Object(object)).length,
arrayLike = length === length >>> 0;
separator2 || (separator2 = ': ');
each(object, function(value, key) {
result.push(arrayLike ? value : key + separator2 + value);
});
return result.join(separator1 || ',');
}
/**
* A generic `Array#map` like method.
*
* @static
* @memberOf Benchmark
* @param {Array} array The array to iterate over.
* @param {Function} callback The function called per iteration.
* @param {Mixed} thisArg The `this` binding for the callback.
* @returns {Array} A new array of values returned by the callback.
*/
function map(array, callback, thisArg) {
return reduce(array, function(result, value, index) {
result[index] = callback.call(thisArg, value, index, array);
return result;
}, Array(Object(array).length >>> 0));
}
/**
* Retrieves the value of a specified property from all items in an array.
*
* @static
* @memberOf Benchmark
* @param {Array} array The array to iterate over.
* @param {String} property The property to pluck.
* @returns {Array} A new array of property values.
*/
function pluck(array, property) {
return map(array, function(object) {
return object == null ? undefined : object[property];
});
}
/**
* A generic `Array#reduce` like method.
*
* @static
* @memberOf Benchmark
* @param {Array} array The array to iterate over.
* @param {Function} callback The function called per iteration.
* @param {Mixed} accumulator Initial value of the accumulator.
* @returns {Mixed} The accumulator.
*/
function reduce(array, callback, accumulator) {
var noaccum = arguments.length < 3;
forEach(array, function(value, index) {
accumulator = noaccum ? (noaccum = false, value) : callback(accumulator, value, index, array);
});
return accumulator;
}
/*--------------------------------------------------------------------------*/
/**
* Aborts all benchmarks in the suite.
*
* @name abort
* @memberOf Benchmark.Suite
* @returns {Object} The suite instance.
*/
function abortSuite() {
var event,
me = this,
resetting = calledBy.resetSuite;
if (me.running) {
event = Event('abort');
me.emit(event);
if (!event.cancelled || resetting) {
// avoid infinite recursion
calledBy.abortSuite = true;
me.reset();
delete calledBy.abortSuite;
if (!resetting) {
me.aborted = true;
invoke(me, 'abort');
}
}
}
return me;
}
/**
* Adds a test to the benchmark suite.
*
* @memberOf Benchmark.Suite
* @param {String} name A name to identify the benchmark.
* @param {Function|String} fn The test to benchmark.
* @param {Object} [options={}] Options object.
* @returns {Object} The benchmark instance.
* @example
*
* // basic usage
* suite.add(fn);
*
* // or using a name first
* suite.add('foo', fn);
*
* // or with options
* suite.add('foo', fn, {
* 'onCycle': onCycle,
* 'onComplete': onComplete
* });
*
* // or name and options
* suite.add('foo', {
* 'fn': fn,
* 'onCycle': onCycle,
* 'onComplete': onComplete
* });
*
* // or options only
* suite.add({
* 'name': 'foo',
* 'fn': fn,
* 'onCycle': onCycle,
* 'onComplete': onComplete
* });
*/
function add(name, fn, options) {
var me = this,
bench = Benchmark(name, fn, options),
event = Event({ 'type': 'add', 'target': bench });
if (me.emit(event), !event.cancelled) {
me.push(bench);
}
return me;
}
/**
* Creates a new suite with cloned benchmarks.
*
* @name clone
* @memberOf Benchmark.Suite
* @param {Object} options Options object to overwrite cloned options.
* @returns {Object} The new suite instance.
*/
function cloneSuite(options) {
var me = this,
result = new me.constructor(extend({}, me.options, options));
// copy own properties
forOwn(me, function(value, key) {
if (!hasKey(result, key)) {
result[key] = value && isClassOf(value.clone, 'Function')
? value.clone()
: deepClone(value);
}
});
return result;
}
/**
* An `Array#filter` like method.
*
* @name filter
* @memberOf Benchmark.Suite
* @param {Function|String} callback The function/alias called per iteration.
* @returns {Object} A new suite of benchmarks that passed callback filter.
*/
function filterSuite(callback) {
var me = this,
result = new me.constructor;
result.push.apply(result, filter(me, callback));
return result;
}
/**
* Resets all benchmarks in the suite.
*
* @name reset
* @memberOf Benchmark.Suite
* @returns {Object} The suite instance.
*/
function resetSuite() {
var event,
me = this,
aborting = calledBy.abortSuite;
if (me.running && !aborting) {
// no worries, `resetSuite()` is called within `abortSuite()`
calledBy.resetSuite = true;
me.abort();
delete calledBy.resetSuite;
}
// reset if the state has changed
else if ((me.aborted || me.running) &&
(me.emit(event = Event('reset')), !event.cancelled)) {
me.running = false;
if (!aborting) {
invoke(me, 'reset');
}
}
return me;
}
/**
* Runs the suite.
*
* @name run
* @memberOf Benchmark.Suite
* @param {Object} [options={}] Options object.
* @returns {Object} The suite instance.
* @example
*
* // basic usage
* suite.run();
*
* // or with options
* suite.run({ 'async': true, 'queued': true });
*/
function runSuite(options) {
var me = this;
me.reset();
me.running = true;
options || (options = {});
invoke(me, {
'name': 'run',
'args': options,
'queued': options.queued,
'onStart': function(event) {
me.emit(event);
},
'onCycle': function(event) {
var bench = event.target;
if (bench.error) {
me.emit({ 'type': 'error', 'target': bench });
}
me.emit(event);
event.aborted = me.aborted;
},
'onComplete': function(event) {
me.running = false;
me.emit(event);
}
});
return me;
}
/*--------------------------------------------------------------------------*/
/**
* Executes all registered listeners of the specified event type.
*
* @memberOf Benchmark, Benchmark.Suite
* @param {String|Object} type The event type or object.
* @returns {Mixed} Returns the return value of the last listener executed.
*/
function emit(type) {
var listeners,
me = this,
event = Event(type),
events = me.events,
args = (arguments[0] = event, arguments);
event.currentTarget || (event.currentTarget = me);
event.target || (event.target = me);
delete event.result;
if (events && (listeners = hasKey(events, event.type) && events[event.type])) {
forEach(listeners.slice(), function(listener) {
if ((event.result = listener.apply(me, args)) === false) {
event.cancelled = true;
}
return !event.aborted;
});
}
return event.result;
}
/**
* Returns an array of event listeners for a given type that can be manipulated
* to add or remove listeners.
*
* @memberOf Benchmark, Benchmark.Suite
* @param {String} type The event type.
* @returns {Array} The listeners array.
*/
function listeners(type) {
var me = this,
events = me.events || (me.events = {});
return hasKey(events, type) ? events[type] : (events[type] = []);
}
/**
* Unregisters a listener for the specified event type(s),
* or unregisters all listeners for the specified event type(s),
* or unregisters all listeners for all event types.
*
* @memberOf Benchmark, Benchmark.Suite
* @param {String} [type] The event type.
* @param {Function} [listener] The function to unregister.
* @returns {Object} The benchmark instance.
* @example
*
* // unregister a listener for an event type
* bench.off('cycle', listener);
*
* // unregister a listener for multiple event types
* bench.off('start cycle', listener);
*
* // unregister all listeners for an event type
* bench.off('cycle');
*
* // unregister all listeners for multiple event types
* bench.off('start cycle complete');
*
* // unregister all listeners for all event types
* bench.off();
*/
function off(type, listener) {
var me = this,
events = me.events;
events && each(type ? type.split(' ') : events, function(listeners, type) {
var index;
if (typeof listeners == 'string') {
type = listeners;
listeners = hasKey(events, type) && events[type];
}
if (listeners) {
if (listener) {
index = indexOf(listeners, listener);
if (index > -1) {
listeners.splice(index, 1);
}
} else {
listeners.length = 0;
}
}
});
return me;
}
/**
* Registers a listener for the specified event type(s).
*
* @memberOf Benchmark, Benchmark.Suite
* @param {String} type The event type.
* @param {Function} listener The function to register.
* @returns {Object} The benchmark instance.
* @example
*
* // register a listener for an event type
* bench.on('cycle', listener);
*
* // register a listener for multiple event types
* bench.on('start cycle', listener);
*/
function on(type, listener) {
var me = this,
events = me.events || (me.events = {});
forEach(type.split(' '), function(type) {
(hasKey(events, type)
? events[type]
: (events[type] = [])
).push(listener);
});
return me;
}
/*--------------------------------------------------------------------------*/
/**
* Aborts the benchmark without recording times.
*
* @memberOf Benchmark
* @returns {Object} The benchmark instance.
*/
function abort() {
var event,
me = this,
resetting = calledBy.reset;
if (me.running) {
event = Event('abort');
me.emit(event);
if (!event.cancelled || resetting) {
// avoid infinite recursion
calledBy.abort = true;
me.reset();
delete calledBy.abort;
if (support.timeout) {
clearTimeout(me._timerId);
delete me._timerId;
}
if (!resetting) {
me.aborted = true;
me.running = false;
}
}
}
return me;
}
/**
* Creates a new benchmark using the same test and options.
*
* @memberOf Benchmark
* @param {Object} options Options object to overwrite cloned options.
* @returns {Object} The new benchmark instance.
* @example
*
* var bizarro = bench.clone({
* 'name': 'doppelganger'
* });
*/
function clone(options) {
var me = this,
result = new me.constructor(extend({}, me, options));
// correct the `options` object
result.options = extend({}, me.options, options);
// copy own custom properties
forOwn(me, function(value, key) {
if (!hasKey(result, key)) {
result[key] = deepClone(value);
}
});
return result;
}
/**
* Determines if a benchmark is faster than another.
*
* @memberOf Benchmark
* @param {Object} other The benchmark to compare.
* @returns {Number} Returns `-1` if slower, `1` if faster, and `0` if indeterminate.
*/
function compare(other) {
var critical,
zStat,
me = this,
sample1 = me.stats.sample,
sample2 = other.stats.sample,
size1 = sample1.length,
size2 = sample2.length,
maxSize = max(size1, size2),
minSize = min(size1, size2),
u1 = getU(sample1, sample2),
u2 = getU(sample2, sample1),
u = min(u1, u2);
function getScore(xA, sampleB) {
return reduce(sampleB, function(total, xB) {
return total + (xB > xA ? 0 : xB < xA ? 1 : 0.5);
}, 0);
}
function getU(sampleA, sampleB) {
return reduce(sampleA, function(total, xA) {
return total + getScore(xA, sampleB);
}, 0);
}
function getZ(u) {
return (u - ((size1 * size2) / 2)) / sqrt((size1 * size2 * (size1 + size2 + 1)) / 12);
}
// exit early if comparing the same benchmark
if (me == other) {
return 0;
}
// reject the null hyphothesis the two samples come from the
// same population (i.e. have the same median) if...
if (size1 + size2 > 30) {
// ...the z-stat is greater than 1.96 or less than -1.96
// http://www.statisticslectures.com/topics/mannwhitneyu/
zStat = getZ(u);
return abs(zStat) > 1.96 ? (zStat > 0 ? -1 : 1) : 0;
}
// ...the U value is less than or equal the critical U value
// http://www.geoib.com/mann-whitney-u-test.html
critical = maxSize < 5 || minSize < 3 ? 0 : uTable[maxSize][minSize - 3];
return u <= critical ? (u == u1 ? 1 : -1) : 0;
}
/**
* Reset properties and abort if running.
*
* @memberOf Benchmark
* @returns {Object} The benchmark instance.
*/
function reset() {
var data,
event,
me = this,
index = 0,
changes = { 'length': 0 },
queue = { 'length': 0 };
if (me.running && !calledBy.abort) {
// no worries, `reset()` is called within `abort()`
calledBy.reset = true;
me.abort();
delete calledBy.reset;
}
else {
// a non-recursive solution to check if properties have changed
// http://www.jslab.dk/articles/non.recursive.preorder.traversal.part4
data = { 'destination': me, 'source': extend({}, me.constructor.prototype, me.options) };
do {
forOwn(data.source, function(value, key) {
var changed,
destination = data.destination,
currValue = destination[key];
if (value && typeof value == 'object') {
if (isClassOf(value, 'Array')) {
// check if an array value has changed to a non-array value
if (!isClassOf(currValue, 'Array')) {
changed = currValue = [];
}
// or has changed its length
if (currValue.length != value.length) {
changed = currValue = currValue.slice(0, value.length);
currValue.length = value.length;
}
}
// check if an object has changed to a non-object value
else if (!currValue || typeof currValue != 'object') {
changed = currValue = {};
}
// register a changed object
if (changed) {
changes[changes.length++] = { 'destination': destination, 'key': key, 'value': currValue };
}
queue[queue.length++] = { 'destination': currValue, 'source': value };
}
// register a changed primitive
else if (value !== currValue && !(value == null || isClassOf(value, 'Function'))) {
changes[changes.length++] = { 'destination': destination, 'key': key, 'value': value };
}
});
}
while ((data = queue[index++]));
// if changed emit the `reset` event and if it isn't cancelled reset the benchmark
if (changes.length && (me.emit(event = Event('reset')), !event.cancelled)) {
forEach(changes, function(data) {
data.destination[data.key] = data.value;
});
}
}
return me;
}
/**
* Displays relevant benchmark information when coerced to a string.
*
* @name toString
* @memberOf Benchmark
* @returns {String} A string representation of the benchmark instance.
*/
function toStringBench() {
var me = this,
error = me.error,
hz = me.hz,
id = me.id,
stats = me.stats,
size = stats.sample.length,
pm = support.java ? '+/-' : '\xb1',
result = me.name || (isNaN(id) ? id : '<Test #' + id + '>');
if (error) {
result += ': ' + join(error);
} else {
result += ' x ' + formatNumber(hz.toFixed(hz < 100 ? 2 : 0)) + ' ops/sec ' + pm +
stats.rme.toFixed(2) + '% (' + size + ' run' + (size == 1 ? '' : 's') + ' sampled)';
}
return result;
}
/*--------------------------------------------------------------------------*/
/**
* Clocks the time taken to execute a test per cycle (secs).
*
* @private
* @param {Object} bench The benchmark instance.
* @returns {Number} The time taken.
*/
function clock() {
var applet,
options = Benchmark.options,
template = { 'begin': 's$=new n$', 'end': 'r$=(new n$-s$)/1e3', 'uid': uid },
timers = [{ 'ns': timer.ns, 'res': max(0.0015, getRes('ms')), 'unit': 'ms' }];
// lazy define for hi-res timers
clock = function(clone) {
var deferred;
if (clone instanceof Deferred) {
deferred = clone;
clone = deferred.benchmark;
}
var bench = clone._original,
fn = bench.fn,
fnArg = deferred ? getFirstArgument(fn) || 'deferred' : '',
stringable = isStringable(fn);
var source = {
'setup': getSource(bench.setup, preprocess('m$.setup()')),
'fn': getSource(fn, preprocess('m$.fn(' + fnArg + ')')),
'fnArg': fnArg,
'teardown': getSource(bench.teardown, preprocess('m$.teardown()'))
};
var count = bench.count = clone.count,
decompilable = support.decompilation || stringable,
id = bench.id,
isEmpty = !(source.fn || stringable),
name = bench.name || (typeof id == 'number' ? '<Test #' + id + '>' : id),
ns = timer.ns,
result = 0;
// init `minTime` if needed
clone.minTime = bench.minTime || (bench.minTime = bench.options.minTime = options.minTime);
// repair nanosecond timer
// (some Chrome builds erase the `ns` variable after millions of executions)
if (applet) {
try {
ns.nanoTime();
} catch(e) {
// use non-element to avoid issues with libs that augment them
ns = timer.ns = new applet.Packages.nano;
}
}
// Compile in setup/teardown functions and the test loop.
// Create a new compiled test, instead of using the cached `bench.compiled`,
// to avoid potential engine optimizations enabled over the life of the test.
var compiled = bench.compiled = createFunction(preprocess('t$'), interpolate(
preprocess(deferred
? 'var d$=this,#{fnArg}=d$,m$=d$.benchmark._original,f$=m$.fn,su$=m$.setup,td$=m$.teardown;' +
// when `deferred.cycles` is `0` then...
'if(!d$.cycles){' +
// set `deferred.fn`
'd$.fn=function(){var #{fnArg}=d$;if(typeof f$=="function"){try{#{fn}\n}catch(e$){f$(d$)}}else{#{fn}\n}};' +
// set `deferred.teardown`
'd$.teardown=function(){d$.cycles=0;if(typeof td$=="function"){try{#{teardown}\n}catch(e$){td$()}}else{#{teardown}\n}};' +
// execute the benchmark's `setup`
'if(typeof su$=="function"){try{#{setup}\n}catch(e$){su$()}}else{#{setup}\n};' +
// start timer
't$.start(d$);' +
// execute `deferred.fn` and return a dummy object
'}d$.fn();return{}'
: 'var r$,s$,m$=this,f$=m$.fn,i$=m$.count,n$=t$.ns;#{setup}\n#{begin};' +
'while(i$--){#{fn}\n}#{end};#{teardown}\nreturn{elapsed:r$,uid:"#{uid}"}'),
source
));
try {
if (isEmpty) {
// Firefox may remove dead code from Function#toString results
// http://bugzil.la/536085
throw new Error('The test "' + name + '" is empty. This may be the result of dead code removal.');
}
else if (!deferred) {
// pretest to determine if compiled code is exits early, usually by a
// rogue `return` statement, by checking for a return object with the uid
bench.count = 1;
compiled = (compiled.call(bench, timer) || {}).uid == uid && compiled;
bench.count = count;
}
} catch(e) {
compiled = null;
clone.error = e || new Error(String(e));
bench.count = count;
}
// fallback when a test exits early or errors during pretest
if (decompilable && !compiled && !deferred && !isEmpty) {
compiled = createFunction(preprocess('t$'), interpolate(
preprocess(
(clone.error && !stringable
? 'var r$,s$,m$=this,f$=m$.fn,i$=m$.count'
: 'function f$(){#{fn}\n}var r$,s$,m$=this,i$=m$.count'
) +
',n$=t$.ns;#{setup}\n#{begin};m$.f$=f$;while(i$--){m$.f$()}#{end};' +
'delete m$.f$;#{teardown}\nreturn{elapsed:r$}'
),
source
));
try {
// pretest one more time to check for errors
bench.count = 1;
compiled.call(bench, timer);
bench.compiled = compiled;
bench.count = count;
delete clone.error;
}
catch(e) {
bench.count = count;
if (clone.error) {
compiled = null;
} else {
bench.compiled = compiled;
clone.error = e || new Error(String(e));
}
}
}
// assign `compiled` to `clone` before calling in case a deferred benchmark
// immediately calls `deferred.resolve()`
clone.compiled = compiled;
// if no errors run the full test loop
if (!clone.error) {
result = compiled.call(deferred || bench, timer).elapsed;
}
return result;
};
/*------------------------------------------------------------------------*/
/**
* Gets the current timer's minimum resolution (secs).
*/
function getRes(unit) {
var measured,
begin,
count = 30,
divisor = 1e3,
ns = timer.ns,
sample = [];
// get average smallest measurable time
while (count--) {
if (unit == 'us') {
divisor = 1e6;
if (ns.stop) {
ns.start();
while (!(measured = ns.microseconds())) { }
} else if (ns[perfName]) {
divisor = 1e3;
measured = Function('n', 'var r,s=n.' + perfName + '();while(!(r=n.' + perfName + '()-s)){};return r')(ns);
} else {
begin = ns();
while (!(measured = ns() - begin)) { }
}
}
else if (unit == 'ns') {
divisor = 1e9;
if (ns.nanoTime) {
begin = ns.nanoTime();
while (!(measured = ns.nanoTime() - begin)) { }
} else {
begin = (begin = ns())[0] + (begin[1] / divisor);
while (!(measured = ((measured = ns())[0] + (measured[1] / divisor)) - begin)) { }
divisor = 1;
}
}
else {
begin = new ns;
while (!(measured = new ns - begin)) { }
}
// check for broken timers (nanoTime may have issues)
// http://alivebutsleepy.srnet.cz/unreliable-system-nanotime/
if (measured > 0) {
sample.push(measured);
} else {
sample.push(Infinity);
break;
}
}
// convert to seconds
return getMean(sample) / divisor;
}
/**
* Replaces all occurrences of `$` with a unique number and
* template tokens with content.
*/
function preprocess(code) {
return interpolate(code, template).replace(/\$/g, /\d+/.exec(uid));
}
/*------------------------------------------------------------------------*/
// detect nanosecond support from a Java applet
each(doc && doc.applets || [], function(element) {
return !(timer.ns = applet = 'nanoTime' in element && element);
});
// check type in case Safari returns an object instead of a number
try {
if (typeof timer.ns.nanoTime() == 'number') {
timers.push({ 'ns': timer.ns, 'res': getRes('ns'), 'unit': 'ns' });
}
} catch(e) { }
// detect Chrome's microsecond timer:
// enable benchmarking via the --enable-benchmarking command
// line switch in at least Chrome 7 to use chrome.Interval
try {
if ((timer.ns = new (window.chrome || window.chromium).Interval)) {
timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });
}
} catch(e) { }
// detect `performance.now` microsecond resolution timer
if ((timer.ns = perfName && perfObject)) {
timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });
}
// detect Node's nanosecond resolution timer available in Node >= 0.8
if (processObject && typeof (timer.ns = processObject.hrtime) == 'function') {
timers.push({ 'ns': timer.ns, 'res': getRes('ns'), 'unit': 'ns' });
}
// detect Wade Simmons' Node microtime module
if (microtimeObject && typeof (timer.ns = microtimeObject.now) == 'function') {
timers.push({ 'ns': timer.ns, 'res': getRes('us'), 'unit': 'us' });
}
// pick timer with highest resolution
timer = reduce(timers, function(timer, other) {
return other.res < timer.res ? other : timer;
});
// remove unused applet
if (timer.unit != 'ns' && applet) {
applet = destroyElement(applet);
}
// error if there are no working timers
if (timer.res == Infinity) {
throw new Error('Benchmark.js was unable to find a working timer.');
}
// use API of chosen timer
if (timer.unit == 'ns') {
if (timer.ns.nanoTime) {
extend(template, {
'begin': 's$=n$.nanoTime()',
'end': 'r$=(n$.nanoTime()-s$)/1e9'
});
} else {
extend(template, {
'begin': 's$=n$()',
'end': 'r$=n$(s$);r$=r$[0]+(r$[1]/1e9)'
});
}
}
else if (timer.unit == 'us') {
if (timer.ns.stop) {
extend(template, {
'begin': 's$=n$.start()',
'end': 'r$=n$.microseconds()/1e6'
});
} else if (perfName) {
extend(template, {
'begin': 's$=n$.' + perfName + '()',
'end': 'r$=(n$.' + perfName + '()-s$)/1e3'
});
} else {
extend(template, {
'begin': 's$=n$()',
'end': 'r$=(n$()-s$)/1e6'
});
}
}
// define `timer` methods
timer.start = createFunction(preprocess('o$'),
preprocess('var n$=this.ns,#{begin};o$.elapsed=0;o$.timeStamp=s$'));
timer.stop = createFunction(preprocess('o$'),
preprocess('var n$=this.ns,s$=o$.timeStamp,#{end};o$.elapsed=r$'));
// resolve time span required to achieve a percent uncertainty of at most 1%
// http://spiff.rit.edu/classes/phys273/uncert/uncert.html
options.minTime || (options.minTime = max(timer.res / 2 / 0.01, 0.05));
return clock.apply(null, arguments);
}
/*--------------------------------------------------------------------------*/
/**
* Computes stats on benchmark results.
*
* @private
* @param {Object} bench The benchmark instance.
* @param {Object} options The options object.
*/
function compute(bench, options) {
options || (options = {});
var async = options.async,
elapsed = 0,
initCount = bench.initCount,
minSamples = bench.minSamples,
queue = [],
sample = bench.stats.sample;
/**
* Adds a clone to the queue.
*/
function enqueue() {
queue.push(bench.clone({
'_original': bench,
'events': {
'abort': [update],
'cycle': [update],
'error': [update],
'start': [update]
}
}));
}
/**
* Updates the clone/original benchmarks to keep their data in sync.
*/
function update(event) {
var clone = this,
type = event.type;
if (bench.running) {
if (type == 'start') {
// Note: `clone.minTime` prop is inited in `clock()`
clone.count = bench.initCount;
}
else {
if (type == 'error') {
bench.error = clone.error;
}
if (type == 'abort') {
bench.abort();
bench.emit('cycle');
} else {
event.currentTarget = event.target = bench;
bench.emit(event);
}
}
} else if (bench.aborted) {
// clear abort listeners to avoid triggering bench's abort/cycle again
clone.events.abort.length = 0;
clone.abort();
}
}
/**
* Determines if more clones should be queued or if cycling should stop.
*/
function evaluate(event) {
var critical,
df,
mean,
moe,
rme,
sd,
sem,
variance,
clone = event.target,
done = bench.aborted,
now = +new Date,
size = sample.push(clone.times.period),
maxedOut = size >= minSamples && (elapsed += now - clone.times.timeStamp) / 1e3 > bench.maxTime,
times = bench.times,
varOf = function(sum, x) { return sum + pow(x - mean, 2); };
// exit early for aborted or unclockable tests
if (done || clone.hz == Infinity) {
maxedOut = !(size = sample.length = queue.length = 0);
}
if (!done) {
// sample mean (estimate of the population mean)
mean = getMean(sample);
// sample variance (estimate of the population variance)
variance = reduce(sample, varOf, 0) / (size - 1) || 0;
// sample standard deviation (estimate of the population standard deviation)
sd = sqrt(variance);
// standard error of the mean (a.k.a. the standard deviation of the sampling distribution of the sample mean)
sem = sd / sqrt(size);
// degrees of freedom
df = size - 1;
// critical value
critical = tTable[Math.round(df) || 1] || tTable.infinity;
// margin of error
moe = sem * critical;
// relative margin of error
rme = (moe / mean) * 100 || 0;
extend(bench.stats, {
'deviation': sd,
'mean': mean,
'moe': moe,
'rme': rme,
'sem': sem,
'variance': variance
});
// Abort the cycle loop when the minimum sample size has been collected
// and the elapsed time exceeds the maximum time allowed per benchmark.
// We don't count cycle delays toward the max time because delays may be
// increased by browsers that clamp timeouts for inactive tabs.
// https://developer.mozilla.org/en/window.setTimeout#Inactive_tabs
if (maxedOut) {
// reset the `initCount` in case the benchmark is rerun
bench.initCount = initCount;
bench.running = false;
done = true;
times.elapsed = (now - times.timeStamp) / 1e3;
}
if (bench.hz != Infinity) {
bench.hz = 1 / mean;
times.cycle = mean * bench.count;
times.period = mean;
}
}
// if time permits, increase sample size to reduce the margin of error
if (queue.length < 2 && !maxedOut) {
enqueue();
}
// abort the invoke cycle when done
event.aborted = done;
}
// init queue and begin
enqueue();
invoke(queue, {
'name': 'run',
'args': { 'async': async },
'queued': true,
'onCycle': evaluate,
'onComplete': function() { bench.emit('complete'); }
});
}
/*--------------------------------------------------------------------------*/
/**
* Cycles a benchmark until a run `count` can be established.
*
* @private
* @param {Object} clone The cloned benchmark instance.
* @param {Object} options The options object.
*/
function cycle(clone, options) {
options || (options = {});
var deferred;
if (clone instanceof Deferred) {
deferred = clone;
clone = clone.benchmark;
}
var clocked,
cycles,
divisor,
event,
minTime,
period,
async = options.async,
bench = clone._original,
count = clone.count,
times = clone.times;
// continue, if not aborted between cycles
if (clone.running) {
// `minTime` is set to `Benchmark.options.minTime` in `clock()`
cycles = ++clone.cycles;
clocked = deferred ? deferred.elapsed : clock(clone);
minTime = clone.minTime;
if (cycles > bench.cycles) {
bench.cycles = cycles;
}
if (clone.error) {
event = Event('error');
event.message = clone.error;
clone.emit(event);
if (!event.cancelled) {
clone.abort();
}
}
}
// continue, if not errored
if (clone.running) {
// time taken to complete last test cycle
bench.times.cycle = times.cycle = clocked;
// seconds per operation
period = bench.times.period = times.period = clocked / count;
// ops per second
bench.hz = clone.hz = 1 / period;
// avoid working our way up to this next time
bench.initCount = clone.initCount = count;
// do we need to do another cycle?
clone.running = clocked < minTime;
if (clone.running) {
// tests may clock at `0` when `initCount` is a small number,
// to avoid that we set its count to something a bit higher
if (!clocked && (divisor = divisors[clone.cycles]) != null) {
count = floor(4e6 / divisor);
}
// calculate how many more iterations it will take to achive the `minTime`
if (count <= clone.count) {
count += Math.ceil((minTime - clocked) / period);
}
clone.running = count != Infinity;
}
}
// should we exit early?
event = Event('cycle');
clone.emit(event);
if (event.aborted) {
clone.abort();
}
// figure out what to do next
if (clone.running) {
// start a new cycle
clone.count = count;
if (deferred) {
clone.compiled.call(deferred, timer);
} else if (async) {
delay(clone, function() { cycle(clone, options); });
} else {
cycle(clone);
}
}
else {
// fix TraceMonkey bug associated with clock fallbacks
// http://bugzil.la/509069
if (support.browser) {
runScript(uid + '=1;delete ' + uid);
}
// done
clone.emit('complete');
}
}
/*--------------------------------------------------------------------------*/
/**
* Runs the benchmark.
*
* @memberOf Benchmark
* @param {Object} [options={}] Options object.
* @returns {Object} The benchmark instance.
* @example
*
* // basic usage
* bench.run();
*
* // or with options
* bench.run({ 'async': true });
*/
function run(options) {
var me = this,
event = Event('start');
// set `running` to `false` so `reset()` won't call `abort()`
me.running = false;
me.reset();
me.running = true;
me.count = me.initCount;
me.times.timeStamp = +new Date;
me.emit(event);
if (!event.cancelled) {
options = { 'async': ((options = options && options.async) == null ? me.async : options) && support.timeout };
// for clones created within `compute()`
if (me._original) {
if (me.defer) {
Deferred(me);
} else {
cycle(me, options);
}
}
// for original benchmarks
else {
compute(me, options);
}
}
return me;
}
/*--------------------------------------------------------------------------*/
// Firefox 1 erroneously defines variable and argument names of functions on
// the function itself as non-configurable properties with `undefined` values.
// The bugginess continues as the `Benchmark` constructor has an argument
// named `options` and Firefox 1 will not assign a value to `Benchmark.options`,
// making it non-writable in the process, unless it is the first property
// assigned by for-in loop of `extend()`.
extend(Benchmark, {
/**
* The default options copied by benchmark instances.
*
* @static
* @memberOf Benchmark
* @type Object
*/
'options': {
/**
* A flag to indicate that benchmark cycles will execute asynchronously
* by default.
*
* @memberOf Benchmark.options
* @type Boolean
*/
'async': false,
/**
* A flag to indicate that the benchmark clock is deferred.
*
* @memberOf Benchmark.options
* @type Boolean
*/
'defer': false,
/**
* The delay between test cycles (secs).
* @memberOf Benchmark.options
* @type Number
*/
'delay': 0.005,
/**
* Displayed by Benchmark#toString when a `name` is not available
* (auto-generated if absent).
*
* @memberOf Benchmark.options
* @type String
*/
'id': undefined,
/**
* The default number of times to execute a test on a benchmark's first cycle.
*
* @memberOf Benchmark.options
* @type Number
*/
'initCount': 1,
/**
* The maximum time a benchmark is allowed to run before finishing (secs).
*
* Note: Cycle delays aren't counted toward the maximum time.
*
* @memberOf Benchmark.options
* @type Number
*/
'maxTime': 5,
/**
* The minimum sample size required to perform statistical analysis.
*
* @memberOf Benchmark.options
* @type Number
*/
'minSamples': 5,
/**
* The time needed to reduce the percent uncertainty of measurement to 1% (secs).
*
* @memberOf Benchmark.options
* @type Number
*/
'minTime': 0,
/**
* The name of the benchmark.
*
* @memberOf Benchmark.options
* @type String
*/
'name': undefined,
/**
* An event listener called when the benchmark is aborted.
*
* @memberOf Benchmark.options
* @type Function
*/
'onAbort': undefined,
/**
* An event listener called when the benchmark completes running.
*
* @memberOf Benchmark.options
* @type Function
*/
'onComplete': undefined,
/**
* An event listener called after each run cycle.
*
* @memberOf Benchmark.options
* @type Function
*/
'onCycle': undefined,
/**
* An event listener called when a test errors.
*
* @memberOf Benchmark.options
* @type Function
*/
'onError': undefined,
/**
* An event listener called when the benchmark is reset.
*
* @memberOf Benchmark.options
* @type Function
*/
'onReset': undefined,
/**
* An event listener called when the benchmark starts running.
*
* @memberOf Benchmark.options
* @type Function
*/
'onStart': undefined
},
/**
* Platform object with properties describing things like browser name,
* version, and operating system.
*
* @static
* @memberOf Benchmark
* @type Object
*/
'platform': req('platform') || window.platform || {
/**
* The platform description.
*
* @memberOf Benchmark.platform
* @type String
*/
'description': window.navigator && navigator.userAgent || null,
/**
* The name of the browser layout engine.
*
* @memberOf Benchmark.platform
* @type String|Null
*/
'layout': null,
/**
* The name of the product hosting the browser.
*
* @memberOf Benchmark.platform
* @type String|Null
*/
'product': null,
/**
* The name of the browser/environment.
*
* @memberOf Benchmark.platform
* @type String|Null
*/
'name': null,
/**
* The name of the product's manufacturer.
*
* @memberOf Benchmark.platform
* @type String|Null
*/
'manufacturer': null,
/**
* The name of the operating system.
*
* @memberOf Benchmark.platform
* @type String|Null
*/
'os': null,
/**
* The alpha/beta release indicator.
*
* @memberOf Benchmark.platform
* @type String|Null
*/
'prerelease': null,
/**
* The browser/environment version.
*
* @memberOf Benchmark.platform
* @type String|Null
*/
'version': null,
/**
* Return platform description when the platform object is coerced to a string.
*
* @memberOf Benchmark.platform
* @type Function
* @returns {String} The platform description.
*/
'toString': function() {
return this.description || '';
}
},
/**
* The semantic version number.
*
* @static
* @memberOf Benchmark
* @type String
*/
'version': '1.0.0',
// an object of environment/feature detection flags
'support': support,
// clone objects
'deepClone': deepClone,
// iteration utility
'each': each,
// augment objects
'extend': extend,
// generic Array#filter
'filter': filter,
// generic Array#forEach
'forEach': forEach,
// generic own property iteration utility
'forOwn': forOwn,
// converts a number to a comma-separated string
'formatNumber': formatNumber,
// generic Object#hasOwnProperty
// (trigger hasKey's lazy define before assigning it to Benchmark)
'hasKey': (hasKey(Benchmark, ''), hasKey),
// generic Array#indexOf
'indexOf': indexOf,
// template utility
'interpolate': interpolate,
// invokes a method on each item in an array
'invoke': invoke,
// generic Array#join for arrays and objects
'join': join,
// generic Array#map
'map': map,
// retrieves a property value from each item in an array
'pluck': pluck,
// generic Array#reduce
'reduce': reduce
});
/*--------------------------------------------------------------------------*/
extend(Benchmark.prototype, {
/**
* The number of times a test was executed.
*
* @memberOf Benchmark
* @type Number
*/
'count': 0,
/**
* The number of cycles performed while benchmarking.
*
* @memberOf Benchmark
* @type Number
*/
'cycles': 0,
/**
* The number of executions per second.
*
* @memberOf Benchmark
* @type Number
*/
'hz': 0,
/**
* The compiled test function.
*
* @memberOf Benchmark
* @type Function|String
*/
'compiled': undefined,
/**
* The error object if the test failed.
*
* @memberOf Benchmark
* @type Object
*/
'error': undefined,
/**
* The test to benchmark.
*
* @memberOf Benchmark
* @type Function|String
*/
'fn': undefined,
/**
* A flag to indicate if the benchmark is aborted.
*
* @memberOf Benchmark
* @type Boolean
*/
'aborted': false,
/**
* A flag to indicate if the benchmark is running.
*
* @memberOf Benchmark
* @type Boolean
*/
'running': false,
/**
* Compiled into the test and executed immediately **before** the test loop.
*
* @memberOf Benchmark
* @type Function|String
* @example
*
* // basic usage
* var bench = Benchmark({
* 'setup': function() {
* var c = this.count,
* element = document.getElementById('container');
* while (c--) {
* element.appendChild(document.createElement('div'));
* }
* },
* 'fn': function() {
* element.removeChild(element.lastChild);
* }
* });
*
* // compiles to something like:
* var c = this.count,
* element = document.getElementById('container');
* while (c--) {
* element.appendChild(document.createElement('div'));
* }
* var start = new Date;
* while (count--) {
* element.removeChild(element.lastChild);
* }
* var end = new Date - start;
*
* // or using strings
* var bench = Benchmark({
* 'setup': '\
* var a = 0;\n\
* (function() {\n\
* (function() {\n\
* (function() {',
* 'fn': 'a += 1;',
* 'teardown': '\
* }())\n\
* }())\n\
* }())'
* });
*
* // compiles to something like:
* var a = 0;
* (function() {
* (function() {
* (function() {
* var start = new Date;
* while (count--) {
* a += 1;
* }
* var end = new Date - start;
* }())
* }())
* }())
*/
'setup': noop,
/**
* Compiled into the test and executed immediately **after** the test loop.
*
* @memberOf Benchmark
* @type Function|String
*/
'teardown': noop,
/**
* An object of stats including mean, margin or error, and standard deviation.
*
* @memberOf Benchmark
* @type Object
*/
'stats': {
/**
* The margin of error.
*
* @memberOf Benchmark#stats
* @type Number
*/
'moe': 0,
/**
* The relative margin of error (expressed as a percentage of the mean).
*
* @memberOf Benchmark#stats
* @type Number
*/
'rme': 0,
/**
* The standard error of the mean.
*
* @memberOf Benchmark#stats
* @type Number
*/
'sem': 0,
/**
* The sample standard deviation.
*
* @memberOf Benchmark#stats
* @type Number
*/
'deviation': 0,
/**
* The sample arithmetic mean.
*
* @memberOf Benchmark#stats
* @type Number
*/
'mean': 0,
/**
* The array of sampled periods.
*
* @memberOf Benchmark#stats
* @type Array
*/
'sample': [],
/**
* The sample variance.
*
* @memberOf Benchmark#stats
* @type Number
*/
'variance': 0
},
/**
* An object of timing data including cycle, elapsed, period, start, and stop.
*
* @memberOf Benchmark
* @type Object
*/
'times': {
/**
* The time taken to complete the last cycle (secs).
*
* @memberOf Benchmark#times
* @type Number
*/
'cycle': 0,
/**
* The time taken to complete the benchmark (secs).
*
* @memberOf Benchmark#times
* @type Number
*/
'elapsed': 0,
/**
* The time taken to execute the test once (secs).
*
* @memberOf Benchmark#times
* @type Number
*/
'period': 0,
/**
* A timestamp of when the benchmark started (ms).
*
* @memberOf Benchmark#times
* @type Number
*/
'timeStamp': 0
},
// aborts benchmark (does not record times)
'abort': abort,
// creates a new benchmark using the same test and options
'clone': clone,
// compares benchmark's hertz with another
'compare': compare,
// executes listeners
'emit': emit,
// get listeners
'listeners': listeners,
// unregister listeners
'off': off,
// register listeners
'on': on,
// reset benchmark properties
'reset': reset,
// runs the benchmark
'run': run,
// pretty print benchmark info
'toString': toStringBench
});
/*--------------------------------------------------------------------------*/
extend(Deferred.prototype, {
/**
* The deferred benchmark instance.
*
* @memberOf Benchmark.Deferred
* @type Object
*/
'benchmark': null,
/**
* The number of deferred cycles performed while benchmarking.
*
* @memberOf Benchmark.Deferred
* @type Number
*/
'cycles': 0,
/**
* The time taken to complete the deferred benchmark (secs).
*
* @memberOf Benchmark.Deferred
* @type Number
*/
'elapsed': 0,
/**
* A timestamp of when the deferred benchmark started (ms).
*
* @memberOf Benchmark.Deferred
* @type Number
*/
'timeStamp': 0,
// cycles/completes the deferred benchmark
'resolve': resolve
});
/*--------------------------------------------------------------------------*/
extend(Event.prototype, {
/**
* A flag to indicate if the emitters listener iteration is aborted.
*
* @memberOf Benchmark.Event
* @type Boolean
*/
'aborted': false,
/**
* A flag to indicate if the default action is cancelled.
*
* @memberOf Benchmark.Event
* @type Boolean
*/
'cancelled': false,
/**
* The object whose listeners are currently being processed.
*
* @memberOf Benchmark.Event
* @type Object
*/
'currentTarget': undefined,
/**
* The return value of the last executed listener.
*
* @memberOf Benchmark.Event
* @type Mixed
*/
'result': undefined,
/**
* The object to which the event was originally emitted.
*
* @memberOf Benchmark.Event
* @type Object
*/
'target': undefined,
/**
* A timestamp of when the event was created (ms).
*
* @memberOf Benchmark.Event
* @type Number
*/
'timeStamp': 0,
/**
* The event type.
*
* @memberOf Benchmark.Event
* @type String
*/
'type': ''
});
/*--------------------------------------------------------------------------*/
/**
* The default options copied by suite instances.
*
* @static
* @memberOf Benchmark.Suite
* @type Object
*/
Suite.options = {
/**
* The name of the suite.
*
* @memberOf Benchmark.Suite.options
* @type String
*/
'name': undefined
};
/*--------------------------------------------------------------------------*/
extend(Suite.prototype, {
/**
* The number of benchmarks in the suite.
*
* @memberOf Benchmark.Suite
* @type Number
*/
'length': 0,
/**
* A flag to indicate if the suite is aborted.
*
* @memberOf Benchmark.Suite
* @type Boolean
*/
'aborted': false,
/**
* A flag to indicate if the suite is running.
*
* @memberOf Benchmark.Suite
* @type Boolean
*/
'running': false,
/**
* An `Array#forEach` like method.
* Callbacks may terminate the loop by explicitly returning `false`.
*
* @memberOf Benchmark.Suite
* @param {Function} callback The function called per iteration.
* @returns {Object} The suite iterated over.
*/
'forEach': methodize(forEach),
/**
* An `Array#indexOf` like method.
*
* @memberOf Benchmark.Suite
* @param {Mixed} value The value to search for.
* @returns {Number} The index of the matched value or `-1`.
*/
'indexOf': methodize(indexOf),
/**
* Invokes a method on all benchmarks in the suite.
*
* @memberOf Benchmark.Suite
* @param {String|Object} name The name of the method to invoke OR options object.
* @param {Mixed} [arg1, arg2, ...] Arguments to invoke the method with.
* @returns {Array} A new array of values returned from each method invoked.
*/
'invoke': methodize(invoke),
/**
* Converts the suite of benchmarks to a string.
*
* @memberOf Benchmark.Suite
* @param {String} [separator=','] A string to separate each element of the array.
* @returns {String} The string.
*/
'join': [].join,
/**
* An `Array#map` like method.
*
* @memberOf Benchmark.Suite
* @param {Function} callback The function called per iteration.
* @returns {Array} A new array of values returned by the callback.
*/
'map': methodize(map),
/**
* Retrieves the value of a specified property from all benchmarks in the suite.
*
* @memberOf Benchmark.Suite
* @param {String} property The property to pluck.
* @returns {Array} A new array of property values.
*/
'pluck': methodize(pluck),
/**
* Removes the last benchmark from the suite and returns it.
*
* @memberOf Benchmark.Suite
* @returns {Mixed} The removed benchmark.
*/
'pop': [].pop,
/**
* Appends benchmarks to the suite.
*
* @memberOf Benchmark.Suite
* @returns {Number} The suite's new length.
*/
'push': [].push,
/**
* Sorts the benchmarks of the suite.
*
* @memberOf Benchmark.Suite
* @param {Function} [compareFn=null] A function that defines the sort order.
* @returns {Object} The sorted suite.
*/
'sort': [].sort,
/**
* An `Array#reduce` like method.
*
* @memberOf Benchmark.Suite
* @param {Function} callback The function called per iteration.
* @param {Mixed} accumulator Initial value of the accumulator.
* @returns {Mixed} The accumulator.
*/
'reduce': methodize(reduce),
// aborts all benchmarks in the suite
'abort': abortSuite,
// adds a benchmark to the suite
'add': add,
// creates a new suite with cloned benchmarks
'clone': cloneSuite,
// executes listeners of a specified type
'emit': emit,
// creates a new suite of filtered benchmarks
'filter': filterSuite,
// get listeners
'listeners': listeners,
// unregister listeners
'off': off,
// register listeners
'on': on,
// resets all benchmarks in the suite
'reset': resetSuite,
// runs all benchmarks in the suite
'run': runSuite,
// array methods
'concat': concat,
'reverse': reverse,
'shift': shift,
'slice': slice,
'splice': splice,
'unshift': unshift
});
/*--------------------------------------------------------------------------*/
// expose Deferred, Event and Suite
extend(Benchmark, {
'Deferred': Deferred,
'Event': Event,
'Suite': Suite
});
// expose Benchmark
// some AMD build optimizers, like r.js, check for specific condition patterns like the following:
if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
// define as an anonymous module so, through path mapping, it can be aliased
define(function() {
return Benchmark;
});
}
// check for `exports` after `define` in case a build optimizer adds an `exports` object
else if (freeExports) {
// in Node.js or RingoJS v0.8.0+
if (typeof module == 'object' && module && module.exports == freeExports) {
(module.exports = Benchmark).Benchmark = Benchmark;
}
// in Narwhal or RingoJS v0.7.0-
else {
freeExports.Benchmark = Benchmark;
}
}
// in a browser or Rhino
else {
// use square bracket notation so Closure Compiler won't munge `Benchmark`
// http://code.google.com/closure/compiler/docs/api-tutorial3.html#export
window['Benchmark'] = Benchmark;
}
// trigger clock's lazy define early to avoid a security error
if (support.air) {
clock({ '_original': { 'fn': noop, 'count': 1, 'options': {} } });
}
}(this));
Raw
flowdock-text-old.js
/*!
* flowdock-text 0.1.7
*
* Copyright 2011 Twitter, Inc.
* Copyright 2011 Flowdock Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this work except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
if (typeof window === "undefined" || window === null) {
window = { FlowdockOldText: {} };
}
if (window.FlowdockOldText == null) {
window.FlowdockOldText = {};
}
if (typeof FlowdockOldText === "undefined" || FlowdockOldText === null) {
FlowdockOldText = {};
}
(function() {
FlowdockOldText = {};
FlowdockOldText.regexen = {};
var HTML_ENTITIES = {
'&': '&amp;',
'>': '&gt;',
'<': '&lt;',
'"': '&quot;',
"'": '&#39;'
};
// HTML escaping
FlowdockOldText.htmlEscape = function(text) {
return text && text.replace(/[&"'><]/g, function(character) {
return HTML_ENTITIES[character];
});
};
// Builds a RegExp
function regexSupplant(regex, flags) {
flags = flags || "";
if (typeof regex !== "string") {
if (regex.global && flags.indexOf("g") < 0) {
flags += "g";
}
if (regex.ignoreCase && flags.indexOf("i") < 0) {
flags += "i";
}
if (regex.multiline && flags.indexOf("m") < 0) {
flags += "m";
}
regex = regex.source;
}
return new RegExp(regex.replace(/#\{(\w+)\}/g, function(match, name) {
var newRegex = FlowdockOldText.regexen[name] || "";
if (typeof newRegex !== "string") {
newRegex = newRegex.source;
}
return newRegex;
}), flags);
}
// simple string interpolation
function stringSupplant(str, values) {
return str.replace(/#\{(\w+)\}/g, function(match, name) {
return values[name] || "";
});
}
function addCharsToCharClass(charClass, start, end) {
var s = String.fromCharCode(start);
if (end !== start) {
s += "-" + String.fromCharCode(end);
}
charClass.push(s);
return charClass;
}
// Space is more than %20, U+3000 for example is the full-width space used with Kanji. Provide a short-hand
// to access both the list of characters and a pattern suitible for use with String#split
// Taken from: ActiveSupport::Multibyte::Handlers::UTF8Handler::UNICODE_WHITESPACE
var fromCode = String.fromCharCode;
var UNICODE_SPACES = [
fromCode(0x0020), // White_Space # Zs SPACE
fromCode(0x0085), // White_Space # Cc <control-0085>
fromCode(0x00A0), // White_Space # Zs NO-BREAK SPACE
fromCode(0x1680), // White_Space # Zs OGHAM SPACE MARK
fromCode(0x180E), // White_Space # Zs MONGOLIAN VOWEL SEPARATOR
fromCode(0x2028), // White_Space # Zl LINE SEPARATOR
fromCode(0x2029), // White_Space # Zp PARAGRAPH SEPARATOR
fromCode(0x202F), // White_Space # Zs NARROW NO-BREAK SPACE
fromCode(0x205F), // White_Space # Zs MEDIUM MATHEMATICAL SPACE
fromCode(0x3000) // White_Space # Zs IDEOGRAPHIC SPACE
];
addCharsToCharClass(UNICODE_SPACES, 0x009, 0x00D); // White_Space # Cc [5] <control-0009>..<control-000D>
addCharsToCharClass(UNICODE_SPACES, 0x2000, 0x200A); // White_Space # Zs [11] EN QUAD..HAIR SPACE
var INVALID_CHARS = [
fromCode(0xFFFE),
fromCode(0xFEFF), // BOM
fromCode(0xFFFF) // Special
];
addCharsToCharClass(INVALID_CHARS, 0x202A, 0x202E); // Directional change
FlowdockOldText.regexen.spaces_group = regexSupplant(UNICODE_SPACES.join(""));
FlowdockOldText.regexen.spaces = regexSupplant("[" + UNICODE_SPACES.join("") + "]");
FlowdockOldText.regexen.invalid_chars_group = regexSupplant(INVALID_CHARS.join(""));
FlowdockOldText.regexen.punct = /\!'#%&'\(\)*\+,\\\-\.\/:;<=>\?@\[\]\^_{|}~\$/;
FlowdockOldText.regexen.atSigns = /[@＠]/;
FlowdockOldText.regexen.extractMentions = regexSupplant(/(^|[^a-zA-Z0-9_!#$%&*@＠])(#{atSigns})([a-zA-Z0-9_]{1,20})/g);
var nonLatinHashtagChars = [];
// Cyrillic
addCharsToCharClass(nonLatinHashtagChars, 0x0400, 0x04ff); // Cyrillic
addCharsToCharClass(nonLatinHashtagChars, 0x0500, 0x0527); // Cyrillic Supplement
addCharsToCharClass(nonLatinHashtagChars, 0x2de0, 0x2dff); // Cyrillic Extended A
addCharsToCharClass(nonLatinHashtagChars, 0xa640, 0xa69f); // Cyrillic Extended B
// Hangul (Korean)
addCharsToCharClass(nonLatinHashtagChars, 0x1100, 0x11ff); // Hangul Jamo
addCharsToCharClass(nonLatinHashtagChars, 0x3130, 0x3185); // Hangul Compatibility Jamo
addCharsToCharClass(nonLatinHashtagChars, 0xA960, 0xA97F); // Hangul Jamo Extended-A
addCharsToCharClass(nonLatinHashtagChars, 0xAC00, 0xD7AF); // Hangul Syllables
addCharsToCharClass(nonLatinHashtagChars, 0xD7B0, 0xD7FF); // Hangul Jamo Extended-B
addCharsToCharClass(nonLatinHashtagChars, 0xFFA1, 0xFFDC); // half-width Hangul
// Japanese and Chinese
addCharsToCharClass(nonLatinHashtagChars, 0x30A1, 0x30FA); // Katakana (full-width)
addCharsToCharClass(nonLatinHashtagChars, 0x30FC, 0x30FE); // Katakana Chouon and iteration marks (full-width)
addCharsToCharClass(nonLatinHashtagChars, 0xFF66, 0xFF9F); // Katakana (half-width)
addCharsToCharClass(nonLatinHashtagChars, 0xFF70, 0xFF70); // Katakana Chouon (half-width)
addCharsToCharClass(nonLatinHashtagChars, 0xFF10, 0xFF19); // \
addCharsToCharClass(nonLatinHashtagChars, 0xFF21, 0xFF3A); // - Latin (full-width)
addCharsToCharClass(nonLatinHashtagChars, 0xFF41, 0xFF5A); // /
addCharsToCharClass(nonLatinHashtagChars, 0x3041, 0x3096); // Hiragana
addCharsToCharClass(nonLatinHashtagChars, 0x3099, 0x309E); // Hiragana voicing and iteration mark
addCharsToCharClass(nonLatinHashtagChars, 0x3400, 0x4DBF); // Kanji (CJK Extension A)
addCharsToCharClass(nonLatinHashtagChars, 0x4E00, 0x9FFF); // Kanji (Unified)
// -- Disabled as it breaks the Regex.
//addCharsToCharClass(nonLatinHashtagChars, 0x20000, 0x2A6DF); // Kanji (CJK Extension B)
addCharsToCharClass(nonLatinHashtagChars, 0x2A700, 0x2B73F); // Kanji (CJK Extension C)
addCharsToCharClass(nonLatinHashtagChars, 0x2B740, 0x2B81F); // Kanji (CJK Extension D)
addCharsToCharClass(nonLatinHashtagChars, 0x2F800, 0x2FA1F); // Kanji (CJK supplement)
addCharsToCharClass(nonLatinHashtagChars, 0x3003, 0x3003); // Kanji iteration mark
addCharsToCharClass(nonLatinHashtagChars, 0x3005, 0x3005); // Kanji iteration mark
addCharsToCharClass(nonLatinHashtagChars, 0x303B, 0x303B); // Han iteration mark
FlowdockOldText.regexen.nonLatinHashtagChars = regexSupplant(nonLatinHashtagChars.join(""));
// Latin accented characters (subtracted 0xD7 from the range, it's a confusable multiplication sign. Looks like "x")
FlowdockOldText.regexen.latinAccentChars = regexSupplant("ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏİÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïıðñòóôõöøùúûüýþş\\303\\277");
FlowdockOldText.regexen.endScreenNameMatch = regexSupplant(/^(?:#{atSigns}|[#{latinAccentChars}]|:\/\/)/);
// A hashtag must contain characters, numbers and underscores, but not all numbers.
FlowdockOldText.regexen.hashtagAlpha = regexSupplant(/[a-z_#{latinAccentChars}#{nonLatinHashtagChars}]/i);
FlowdockOldText.regexen.usernameAlphaNumeric = regexSupplant(/[a-z0-9_\-\.#{latinAccentChars}#{nonLatinHashtagChars}]/i);
FlowdockOldText.regexen.usernameAlphaNumericEnd = regexSupplant(/[a-z0-9_\-#{latinAccentChars}#{nonLatinHashtagChars}]/i);
FlowdockOldText.regexen.hashtagAlphaNumeric = regexSupplant(/[a-z0-9_\-#{latinAccentChars}#{nonLatinHashtagChars}]/i);
FlowdockOldText.regexen.endHashtagMatch = /^(?:[#＃]|:\/\/)/;
FlowdockOldText.regexen.hashtagBoundary = regexSupplant(/(?:^|$|[^&\/a-z0-9_#{latinAccentChars}#{nonLatinHashtagChars}])/);
FlowdockOldText.regexen.singleValidHashTag = regexSupplant(/^#{hashtagAlphaNumeric}+$/i);
// FlowdockOldText change: allow all-numeric hashtags
FlowdockOldText.regexen.autoLinkHashtags = regexSupplant(/(#{hashtagBoundary})(#|＃)(#{hashtagAlphaNumeric}+)/gi);
FlowdockOldText.regexen.autoLinkMentions = regexSupplant(/(#{hashtagBoundary})(@)(#{usernameAlphaNumeric}*#{usernameAlphaNumericEnd}+)/gi);
// We want to only match words starting with the nickname and ignore case
FlowdockOldText.regexen.highlightRegex = function(nick) {
if (nick && nick.length > 0) { return new RegExp('([\\b\\s]|^)+' + regexEscape(nick) + '([\\b\\s\\!\\?\\,\\:\\;\\.]|$)+', 'i'); }
};
// URL related hash regex collection
FlowdockOldText.regexen.validPrecedingChars = regexSupplant(/(?:[^-\/"'!=A-Za-z0-9_@＠$#＃\.#{invalid_chars_group}]|^)/);
FlowdockOldText.regexen.invalidDomainChars = stringSupplant("#{punct}#{spaces_group}#{invalid_chars_group}", FlowdockOldText.regexen);
FlowdockOldText.regexen.validDomainChars = regexSupplant(/[^#{invalidDomainChars}]/);
FlowdockOldText.regexen.validSubdomain = regexSupplant(/(?:(?:#{validDomainChars}(?:[_-]|#{validDomainChars})*)?#{validDomainChars}\.)/);
FlowdockOldText.regexen.validDomainName = regexSupplant(/(?:(?:#{validDomainChars}(?:-|#{validDomainChars})*)?#{validDomainChars}\.)/);
FlowdockOldText.regexen.validGTLD = regexSupplant(/(?:(?:aero|asia|biz|cat|com|coop|edu|gov|info|int|jobs|mil|mobi|museum|name|net|org|pro|tel|travel|xxx|local|dmz|lan|corp)(?=[^a-zA-Z]|$))/);
FlowdockOldText.regexen.validCCTLD = regexSupplant(/(?:(?:ac|ad|ae|af|ag|ai|al|am|an|ao|aq|ar|as|at|au|aw|ax|az|ba|bb|bd|be|bf|bg|bh|bi|bj|bm|bn|bo|br|bs|bt|bv|bw|by|bz|ca|cc|cd|cf|cg|ch|ci|ck|cl|cm|cn|co|cr|cs|cu|cv|cx|cy|cz|dd|de|dj|dk|dm|do|dz|ec|ee|eg|eh|er|es|et|eu|fi|fj|fk|fm|fo|fr|ga|gb|gd|ge|gf|gg|gh|gi|gl|gm|gn|gp|gq|gr|gs|gt|gu|gw|gy|hk|hm|hn|hr|ht|hu|id|ie|il|im|in|io|iq|ir|is|it|je|jm|jo|jp|ke|kg|kh|ki|km|kn|kp|kr|kw|ky|kz|la|lb|lc|li|lk|lr|ls|lt|lu|lv|ly|ma|mc|md|me|mg|mh|mk|ml|mm|mn|mo|mp|mq|mr|ms|mt|mu|mv|mw|mx|my|mz|na|nc|ne|nf|ng|ni|nl|no|np|nr|nu|nz|om|pa|pe|pf|pg|ph|pk|pl|pm|pn|pr|ps|pt|pw|py|qa|re|ro|rs|ru|rw|sa|sb|sc|sd|se|sg|sh|si|sj|sk|sl|sm|sn|so|sr|ss|st|su|sv|sy|sz|tc|td|tf|tg|th|tj|tk|tl|tm|tn|to|tp|tr|tt|tv|tw|tz|ua|ug|uk|us|uy|uz|va|vc|ve|vg|vi|vn|vu|wf|ws|ye|yt|za|zm|zw)(?=[^a-zA-Z]|$))/);
FlowdockOldText.regexen.validPunycode = regexSupplant(/(?:xn--[0-9a-z]+)/);
FlowdockOldText.regexen.validDomain = regexSupplant(/(?:#{validSubdomain}*#{validDomainName}(?:#{validGTLD}|#{validCCTLD}|#{validPunycode}))/);
FlowdockOldText.regexen.pseudoValidIP = regexSupplant(/(?:\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})/);
FlowdockOldText.regexen.validAsciiDomain = regexSupplant(/(?:(?:[a-z0-9#{latinAccentChars}\-]+)\.)+(?:#{validGTLD}|#{validCCTLD}|#{validPunycode})/gi);
FlowdockOldText.regexen.validPortNumber = regexSupplant(/[0-9]+/);
FlowdockOldText.regexen.validGeneralUrlPathChars = regexSupplant(/[a-z0-9!\*';:=\+,\.\$\/%#\[\]\-_~|&#{latinAccentChars}]/i);
// Allow URL paths to contain balanced parens
// 1. Used in Wikipedia URLs like /Primer_(film)
// 2. Used in IIS sessions like /S(dfd346)/
FlowdockOldText.regexen.validUrlBalancedParens = regexSupplant(/\(#{validGeneralUrlPathChars}+\)/i);
// Valid end-of-path chracters (so /foo. does not gobble the period).
// 1. Allow =&# for empty URL parameters and other URL-join artifacts
FlowdockOldText.regexen.validUrlPathEndingChars = regexSupplant(/[\+\-a-z0-9=_#\/#{latinAccentChars}]|(?:#{validUrlBalancedParens})/i);
// Allow @ in a url, but only in the middle. Catch things like http://example.com/@user/ and Plone urls like http://example.org/my-document/@@as-message
FlowdockOldText.regexen.validUrlPath = regexSupplant('(?:' +
'(?:' +
'#{validGeneralUrlPathChars}*' +
'(?:#{validUrlBalancedParens}#{validGeneralUrlPathChars}*)*' +
'#{validUrlPathEndingChars}'+
')|(?:(@|@@)#{validGeneralUrlPathChars}+\/?)'+
')', 'i');
FlowdockOldText.regexen.validUrlQueryChars = /[a-z0-9!?\*'\(\);:&=\+\$\/%#\[\]\-_\.,~|]/i;
FlowdockOldText.regexen.validUrlQueryEndingChars = /[a-z0-9_&=#\/]/i;
FlowdockOldText.regexen.extractUrl = regexSupplant(
'(' + // $1 total match
'(#{validPrecedingChars})' + // $2 Preceeding chracter
'(' + // $3 URL
'(?:' +
'(?:' +
'(https?:\\/\\/)?' + // $4 Protocol (optional)
'(#{validDomain}|#{pseudoValidIP})' + // $5 Domain(s)
')|(?:' + // OR
'(https?:\\/\\/)' + // $6 Protocol
'((?:#{validDomainChars}|-)+)(?=:|\/|#{spaces}|\$)' + // $7 Domain with a following port, path, whitespace or an end of string
')' +
')' +
'(?::(#{validPortNumber}))?' + // $8 Port number (optional)
'(\\/#{validUrlPath}*)?' + // $9 URL Path
'(\\?#{validUrlQueryChars}*#{validUrlQueryEndingChars})?' + // $10 Query String
')' +
')'
, 'gi');
FlowdockOldText.regexen.validTcoUrl = /^https?:\/\/t\.co\/[a-z0-9]+/i;
// These URL validation pattern strings are based on the ABNF from RFC 3986
FlowdockOldText.regexen.validateUrlUnreserved = /[a-z0-9\-._~]/i;
FlowdockOldText.regexen.validateUrlPctEncoded = /(?:%[0-9a-f]{2})/i;
FlowdockOldText.regexen.validateUrlSubDelims = /[!$&'()*+,;=]/i;
FlowdockOldText.regexen.validateUrlPchar = regexSupplant('(?:' +
'#{validateUrlUnreserved}|' +
'#{validateUrlPctEncoded}|' +
'#{validateUrlSubDelims}|' +
'[:|@]' +
')', 'i');
FlowdockOldText.regexen.validateUrlScheme = /(?:[a-z][a-z0-9+\-.]*)/i;
FlowdockOldText.regexen.validateUrlUserinfo = regexSupplant('(?:' +
'#{validateUrlUnreserved}|' +
'#{validateUrlPctEncoded}|' +
'#{validateUrlSubDelims}|' +
':' +
')*', 'i');
FlowdockOldText.regexen.validateUrlDecOctet = /(?:[0-9]|(?:[1-9][0-9])|(?:1[0-9]{2})|(?:2[0-4][0-9])|(?:25[0-5]))/i;
FlowdockOldText.regexen.validateUrlIpv4 = regexSupplant(/(?:#{validateUrlDecOctet}(?:\.#{validateUrlDecOctet}){3})/i);
// Punting on real IPv6 validation for now
FlowdockOldText.regexen.validateUrlIpv6 = /(?:\[[a-f0-9:\.]+\])/i;
// Also punting on IPvFuture for now
FlowdockOldText.regexen.validateUrlIp = regexSupplant('(?:' +
'#{validateUrlIpv4}|' +
'#{validateUrlIpv6}' +
')', 'i');
// This is more strict than the rfc specifies
FlowdockOldText.regexen.validateUrlSubDomainSegment = /(?:[a-z0-9](?:[a-z0-9_\-]*[a-z0-9])?)/i;
FlowdockOldText.regexen.validateUrlDomainSegment = /(?:[a-z0-9](?:[a-z0-9\-]*[a-z0-9])?)/i;
FlowdockOldText.regexen.validateUrlDomainTld = /(?:[a-z](?:[a-z0-9\-]*[a-z0-9])?)/i;
FlowdockOldText.regexen.validateUrlDomain = regexSupplant(/(?:(?:#{validateUrlSubDomainSegment]}\.)*(?:#{validateUrlDomainSegment]}\.)#{validateUrlDomainTld})/i);
FlowdockOldText.regexen.validateUrlHost = regexSupplant('(?:' +
'#{validateUrlIp}|' +
'#{validateUrlDomain}' +
')', 'i');
// Unencoded internationalized domains - this doesn't check for invalid UTF-8 sequences
FlowdockOldText.regexen.validateUrlUnicodeSubDomainSegment = /(?:(?:[a-z0-9]|[^\u0000-\u007f])(?:(?:[a-z0-9_\-]|[^\u0000-\u007f])*(?:[a-z0-9]|[^\u0000-\u007f]))?)/i;
FlowdockOldText.regexen.validateUrlUnicodeDomainSegment = /(?:(?:[a-z0-9]|[^\u0000-\u007f])(?:(?:[a-z0-9\-]|[^\u0000-\u007f])*(?:[a-z0-9]|[^\u0000-\u007f]))?)/i;
FlowdockOldText.regexen.validateUrlUnicodeDomainTld = /(?:(?:[a-z]|[^\u0000-\u007f])(?:(?:[a-z0-9\-]|[^\u0000-\u007f])*(?:[a-z0-9]|[^\u0000-\u007f]))?)/i;
FlowdockOldText.regexen.validateUrlUnicodeDomain = regexSupplant(/(?:(?:#{validateUrlUnicodeSubDomainSegment}\.)*(?:#{validateUrlUnicodeDomainSegment}\.)#{validateUrlUnicodeDomainTld})/i);
FlowdockOldText.regexen.validateUrlUnicodeHost = regexSupplant('(?:' +
'#{validateUrlIp}|' +
'#{validateUrlUnicodeDomain}' +
')', 'i');
FlowdockOldText.regexen.validateUrlPort = /[0-9]{1,5}/;
FlowdockOldText.regexen.validateUrlUnicodeAuthority = regexSupplant(
'(?:(#{validateUrlUserinfo})@)?' + // $1 userinfo
'(#{validateUrlUnicodeHost})' + // $2 host
'(?::(#{validateUrlPort}))?' //$3 port
, "i");
FlowdockOldText.regexen.validateUrlAuthority = regexSupplant(
'(?:(#{validateUrlUserinfo})@)?' + // $1 userinfo
'(#{validateUrlHost})' + // $2 host
'(?::(#{validateUrlPort}))?' // $3 port
, "i");
FlowdockOldText.regexen.validateUrlPath = regexSupplant(/(\/#{validateUrlPchar}*)*/i);
FlowdockOldText.regexen.validateUrlQuery = regexSupplant(/(#{validateUrlPchar}|\/|\?)*/i);
FlowdockOldText.regexen.validateUrlFragment = regexSupplant(/(#{validateUrlPchar}|\/|\?)*/i);
// Modified version of RFC 3986 Appendix B
FlowdockOldText.regexen.validateUrlUnencoded = regexSupplant(
'^' + // Full URL
'(?:' +
'([^:/?#]+):\\/\\/' + // $1 Scheme
')?' +
'([^/?#]*)' + // $2 Authority
'([^?#]*)' + // $3 Path
'(?:' +
'\\?([^#]*)' + // $4 Query
')?' +
'(?:' +
'#(.*)' + // $5 Fragment
')?$'
, "i");
FlowdockOldText.regexen.validEmailLocalPart = regexSupplant("[A-z|0-9|.|_|%|+|-]+");
FlowdockOldText.regexen.email = regexSupplant(
/#{validEmailLocalPart}@#{validDomain}/
, 'gi');
FlowdockOldText.regexen.extractEmails = regexSupplant(
/(?:^|\s|,|"|')?(#{email})/
, 'gi');
// Default CSS class for auto-linked URLs
var DEFAULT_URL_CLASS = "linkify-link";
// Default CSS class for auto-linked usernames (along with the url class)
var DEFAULT_USERNAME_CLASS = "app-tag-link";
// Default CSS class for auto-linked hashtags (along with the url class)
var DEFAULT_HASHTAG_CLASS = "app-tag-link";
// Simple object cloning function for simple objects
function clone(o) {
var r = {};
for (var k in o) {
if (o.hasOwnProperty(k)) {
r[k] = o[k];
}
}
return r;
}
FlowdockOldText.autoLink = function(text, options, urlLinkOptions) {
options = clone(options || {});
urlLinkOptions = clone(urlLinkOptions || {})
return FlowdockOldText.autoLinkEmails(
FlowdockOldText.autoLinkUrlsCustom(
FlowdockOldText.autoLinkMentions(
FlowdockOldText.autoLinkHashtags(text, options),
options),
urlLinkOptions)
);
};
FlowdockOldText.autoLinkHashtags = function(text, options) {
options = clone(options || {});
options.hashtagClass = options.hashtagClass || DEFAULT_HASHTAG_CLASS;
options.hashtagUrlBase = options.hashtagUrlBase || "#flowser/all/";
return text.replace(FlowdockOldText.regexen.autoLinkHashtags, function(match, before, hash, text, offset, chunk) {
var after = chunk.slice(offset + match.length);
if (after.match(FlowdockOldText.regexen.endHashtagMatch))
return match;
var d = {
before: before,
hash: FlowdockOldText.htmlEscape(hash),
preText: "",
text: FlowdockOldText.htmlEscape(text),
postText: ""
};
for (var k in options) {
if (options.hasOwnProperty(k)) {
d[k] = options[k];
}
}
return stringSupplant("#{before}<a href=\"#{hashtagUrlBase}#{text}\" title=\"##{text}\" class=\"#{hashtagClass}\">#{hash}#{preText}#{text}#{postText}</a>", d);
});
};
FlowdockOldText.autoLinkEmails = function(text, options) {
if (!options) {
options = {};
}
options.emailClass = options.emailClass || "email-link";
return text.replace(FlowdockOldText.regexen.extractEmails, function(match) {
return match.replace(FlowdockOldText.regexen.email, function(subMatch) {
d = {
subMatch: FlowdockOldText.htmlEscape(subMatch)
};
for (var k in options) {
if (options.hasOwnProperty(k)) {
d[k] = options[k];
}
}
return stringSupplant("<a href='mailto:#{subMatch}' class='#{emailClass}'>#{subMatch}</a>", d);
});
});
}
FlowdockOldText.autoLinkUrlsCustom = function(text, options) {
options = clone(options || {});
if (options.urlClass) {
options["class"] = options.urlClass;
delete options.urlClass;
}
// remap url entities to hash
var urlEntities, i, len;
if(options.urlEntities) {
urlEntities = {};
for(i = 0, len = options.urlEntities.length; i < len; i++) {
urlEntities[options.urlEntities[i].url] = options.urlEntities[i];
}
}
delete options.usernameClass;
delete options.usernameUrlBase;
return text.replace(FlowdockOldText.regexen.extractUrl, function() {
var before = arguments[2],
url = arguments[3],
protocol = (arguments[4] || arguments[6]),
htmlAttrs = "",
after = "";
for (var k in options) {
htmlAttrs += stringSupplant(" #{k}=\"#{v}\" ", {k: k, v: options[k].toString().replace(/"/, "&quot;").replace(/</, "&lt;").replace(/>/, "&gt;")});
}
// In the case of t.co URLs, don't allow additional path characters.
if (url.match(FlowdockOldText.regexen.validTcoUrl)) {
url = RegExp.lastMatch;
after = RegExp.rightContext;
}
var d = {
before: before,
htmlAttrs: htmlAttrs,
url: FlowdockOldText.htmlEscape(url),
after: after
};
if (urlEntities && urlEntities[url] && urlEntities[url].display_url) {
d.displayUrl = FlowdockOldText.htmlEscape(urlEntities[url].display_url);
} else {
d.displayUrl = d.url;
}
if (!protocol) {
d.url = 'http://' + d.url;
}
return stringSupplant("#{before}<a href=\"#{url}\"#{htmlAttrs}>#{displayUrl}</a>#{after}", d);
});
};
FlowdockOldText.autoLinkMentions = function(text, options) {
options = clone(options || {});
options.hashtagClass = options.hashtagClass || "app-tag-link";
options.hashtagUrlBase = options.hashtagUrlBase || "#flowser/all/";
var userTags = [];
if(options && options.userTags){
userTags = options.userTags.map(function(tag){ return tag.toLowerCase() });
}
return text.replace(FlowdockOldText.regexen.autoLinkMentions, function(match, before, hash, text, offset, chunk) {
var after = chunk.slice(offset + match.length);
if (after.match(FlowdockOldText.regexen.endHashtagMatch))
return match;
var d = {
before: before,
hash: FlowdockOldText.htmlEscape(hash),
preText: "",
text: FlowdockOldText.htmlEscape(text),
postText: "",
};
for (var k in options) {
if (options.hasOwnProperty(k)) {
d[k] = options[k];
}
}
if(userTags.length !== 0 && !inArray(d.hash + d.text.toLowerCase(), userTags)){
return stringSupplant("#{before}#{hash}#{preText}#{text}#{postText}", d);
} else {
return stringSupplant("#{before}<a title=\"Search #{hash}#{text}\" class=\"#{hashtagClass}\" href=\"#{hashtagUrlBase}#{hash}#{text}\">#{hash}#{preText}#{text}#{postText}</a>", d);
}
});
};
FlowdockOldText.extractMentions = function(text) {
var screenNamesOnly = [],
screenNamesWithIndices = FlowdockOldText.extractMentionsWithIndices(text);
for (var i = 0; i < screenNamesWithIndices.length; i++) {
var screenName = screenNamesWithIndices[i].screenName;
screenNamesOnly.push(screenName);
}
return screenNamesOnly;
};
FlowdockOldText.extractMentionsWithIndices = function(text) {
if (!text) {
return [];
}
var possibleScreenNames = [],
position = 0;
text.replace(FlowdockOldText.regexen.extractMentions, function(match, before, atSign, screenName, offset, chunk) {
var after = chunk.slice(offset + match.length);
if (!after.match(FlowdockOldText.regexen.endScreenNameMatch)) {
var startPosition = text.indexOf(atSign + screenName, position);
position = startPosition + screenName.length + 1;
possibleScreenNames.push({
username: screenName,
indices: [startPosition, position]
});
}
});
return possibleScreenNames;
};
FlowdockOldText.extractUrls = function(text) {
var urlsOnly = [],
urlsWithIndices = FlowdockOldText.extractUrlsWithIndices(text);
for (var i = 0; i < urlsWithIndices.length; i++) {
urlsOnly.push(urlsWithIndices[i].url);
}
return urlsOnly;
};
FlowdockOldText.extractEmails = function(text) {
var emailsOnly = [],
emailsWithIndices = FlowdockOldText.extractEmailsWithIndices(text);
for (var i = 0; i < emailsWithIndices.length; i++){
emailsOnly.push(emailsWithIndices[i].email)
}
return emailsOnly;
}
FlowdockOldText.extractEmailsWithIndices = function(text){
if (!text) {
return [];
}
emails = [];
while (match = FlowdockOldText.regexen.extractEmails.exec(text)) {
var email = match[1],
endPosition = FlowdockOldText.regexen.extractEmails.lastIndex,
startPosition = endPosition - email.length
emails.push({email: email, indices: [startPosition, endPosition]})
}
return emails;
}
FlowdockOldText.extractUrlsWithIndices = function(text) {
if (!text) {
return [];
}
var urls = [];
while (match = FlowdockOldText.regexen.extractUrl.exec(text)) {
var before = match[2],
url = match[3],
protocol = (match[4] || match[6]),
domain = (match[5] || match[7]),
path = match[9],
endPosition = FlowdockOldText.regexen.extractUrl.lastIndex,
startPosition = endPosition - url.length;
// if protocol is missing and domain contains non-ASCII characters,
// extract ASCII-only domains.
if (!protocol) {
var lastUrl = null,
lastUrlInvalidMatch = false,
asciiEndPosition = 0;
domain.replace(FlowdockOldText.regexen.validAsciiDomain, function(asciiDomain) {
var asciiStartPosition = domain.indexOf(asciiDomain, asciiEndPosition);
asciiEndPosition = asciiStartPosition + asciiDomain.length
lastUrl = {
url: asciiDomain,
indices: [startPosition + asciiStartPosition, startPosition + asciiEndPosition]
}
urls.push(lastUrl);
});
// no ASCII-only domain found. Skip the entire URL.
if (lastUrl == null) {
continue;
}
// lastUrl only contains domain. Need to add path and query if they exist.
if (path) {
if (lastUrlInvalidMatch) {
urls.push(lastUrl);
}
lastUrl.url = url.replace(domain, lastUrl.url);
lastUrl.indices[1] = endPosition;
}
} else {
// In the case of t.co URLs, don't allow additional path characters.
if (url.match(FlowdockOldText.regexen.validTcoUrl)) {
url = RegExp.lastMatch;
endPosition = startPosition + url.length;
}
urls.push({
url: url,
indices: [startPosition, endPosition]
});
}
}
return urls;
};
FlowdockOldText.extractHashtags = function(text) {
var hashtagsOnly = [],
hashtagsWithIndices = FlowdockOldText.extractHashtagsWithIndices(text);
for (var i = 0; i < hashtagsWithIndices.length; i++) {
hashtagsOnly.push(hashtagsWithIndices[i].tag);
}
return hashtagsOnly;
};
FlowdockOldText.extractHashtagsWithIndices = function(text) {
if (!text) {
return [];
}
var tags = [],
position = 0;
text.replace(FlowdockOldText.regexen.autoLinkHashtags, function(match, before, hash, hashText, offset, chunk) {
var after = chunk.slice(offset + match.length);
if (after.match(FlowdockOldText.regexen.endHashtagMatch))
return;
var startPosition = text.indexOf(hash + hashText, position);
position = startPosition + hashText.length + 1;
tags.push({
tag: hashText,
indices: [startPosition, position]
});
});
return tags;
};
FlowdockOldText.modifyIndicesFromUnicodeToUTF16 = function(text, entities) {
FlowdockOldText.shiftIndices(text, entities, 1);
};
FlowdockOldText.modifyIndicesFromUTF16ToUnicode = function(text, entities) {
FlowdockOldText.shiftIndices(text, entities, -1);
};
FlowdockOldText.shiftIndices = function(text, entities, diff) {
for (var i = 0; i < text.length - 1; i++) {
var c1 = text.charCodeAt(i);
var c2 = text.charCodeAt(i + 1);
if (0xD800 <= c1 && c1 <= 0xDBFF && 0xDC00 <= c2 && c2 <= 0xDFFF) {
// supplementary character
i++; // skip surrogate pair character
for (var j = 0; j < entities.length; j++) {
if (entities[j].indices[0] >= i) {
entities[j].indices[0] += diff;
entities[j].indices[1] += diff;
}
}
}
}
};
FlowdockOldText.extractMentions = function(text, userTags){
var mentionsOnly = [],
mentionsWithIndices = FlowdockOldText.extractMentionsWithIndices(text, userTags);
for (var i = 0; i < mentionsWithIndices.length; i++) {
mentionsOnly.push(mentionsWithIndices[i].tag);
}
if(userTags){
userTags = downCase(userTags.map(getUserTag));
return mentionsOnly.filter(function(tag){ return inArray(tag.toLowerCase(), userTags) });
}
return mentionsOnly;
};
FlowdockOldText.extractMentionsWithIndices = function(text, userTags) {
if (!text) {
return [];
}
var tags = [],
position = 0;
text.replace(FlowdockOldText.regexen.autoLinkMentions, function(match, before, hash, hashText, offset, chunk) {
var after = chunk.slice(offset + match.length);
if (after.match(FlowdockOldText.regexen.endHashtagMatch))
return;
var startPosition = text.indexOf(hash + hashText, position);
position = startPosition + hashText.length + 1;
tags.push({
tag: (hash + hashText),
indices: [startPosition, position]
});
});
if(userTags){
userTags = downCase(userTags.map(getUserTag));
return tags.filter(function(tag){ return inArray(tag.tag.toLowerCase(), userTags) });
}
return tags;
};
FlowdockOldText.parseTags = function(message, users, me) {
var tags = [];
var users = users || [];
var me = me || {};
var urls = FlowdockOldText.extractUrls(message);
var matchedTags = FlowdockOldText.extractHashtags(message);
var matchedMentions = FlowdockOldText.extractMentions(message);
if (matchedTags.length > 0) {
//Uniq the matchedTags
matchedTags.forEach(function(tag) {
if(!inArray(tag.toLowerCase(), tags)) tags.push(tag);
});
}
//Add the :url metatag if any urls in the message
if (urls.length > 0) tags.push(":url");
// Find @everyone-tags from messages and tag with :user:everyone
if (FlowdockOldText.mentionsAll(matchedMentions)) tags.push(":user:everyone");
users.forEach(function(user) {
if (!user.nick || user.nick.length == 0 || user.id == 0 || user.disabled) return;
// Find nicknames from messages sent by other users and tag with :highlight
if (user.id != me.id && message.match(FlowdockOldText.regexen.highlightRegex(user.nick))) {
tags.push(":highlight:" + user.id);
}
if (FlowdockOldText.mentionsUser(matchedMentions, user)) tags.push(":user:" + user.id);
if([":highlight:" + user.id, ":user:" + user.id, ":user:everyone"].some(function(tag){
return tags.indexOf(tag) !== -1;
}) && user.id !== me.id){
tags.push(":unread:" + user.id);
}
});
return tags.filter(function(tag){ return tag[0] !== "@"});
};
FlowdockOldText.mentionsAll = function(check){
if(isArray(check)){
return ["@everyone", "@everybody", "@all", "@anyone", "@anybody"].some(function(tag) {
return downCase(check).indexOf(tag) !== -1;
});
} else {
return FlowdockOldText.mentionsAll(FlowdockOldText.extractMentions(check));
}
};
FlowdockOldText.mentionsUser = function(check, user){
if(isArray(check)){
return downCase(check).indexOf(getUserTag(user).toLowerCase()) !== -1;
} else {
return FlowdockOldText.extractMentions(check, [getUserTag(user)]).length > 0;
}
};
FlowdockOldText.isValidUrl = function(url, unicodeDomains, requireProtocol) {
if (unicodeDomains == null) {
unicodeDomains = true;
}
if (requireProtocol == null) {
requireProtocol = true;
}
if (!url) {
return false;
}
var urlParts = url.match(FlowdockOldText.regexen.validateUrlUnencoded);
if (!urlParts || urlParts[0] !== url) {
return false;
}
var scheme = urlParts[1],
authority = urlParts[2],
path = urlParts[3],
query = urlParts[4],
fragment = urlParts[5];
if (!(
(!requireProtocol || (isValidMatch(scheme, FlowdockOldText.regexen.validateUrlScheme) && scheme.match(/^https?$/i))) &&
isValidMatch(path, FlowdockOldText.regexen.validateUrlPath) &&
isValidMatch(query, FlowdockOldText.regexen.validateUrlQuery, true) &&
isValidMatch(fragment, FlowdockOldText.regexen.validateUrlFragment, true)
)) {
return false;
}
return (unicodeDomains && isValidMatch(authority, FlowdockOldText.regexen.validateUrlUnicodeAuthority)) ||
(!unicodeDomains && isValidMatch(authority, FlowdockOldText.regexen.validateUrlAuthority));
};
function isValidMatch(string, regex, optional) {
if (!optional) {
// RegExp["$&"] is the text of the last match
// blank strings are ok, but are falsy, so we check stringiness instead of truthiness
return ((typeof string === "string") && string.match(regex) && RegExp["$&"] === string);
}
// RegExp["$&"] is the text of the last match
return (!string || (string.match(regex) && RegExp["$&"] === string));
}
function getUserTag(user){
if(typeof user === "string"){
return (user[0] === "@" ? user : "@" + user)
} else {
return "@" + user.nick;
}
}
function downCase(arr){
return arr.map(function(item){ return item.toLowerCase(); });
}
function inArray(needle, haystack){
return haystack.indexOf(needle) !== -1;
}
function isArray(thing){
return Object.prototype.toString.call(thing) === "[object Array]";
}
// Escape regex special chars
function regexEscape(text) {
return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
}
if (typeof module != 'undefined' && module.exports) {
module.exports = FlowdockOldText;
}
}());
Raw
flowdock-text-pr.js
/*!
* flowdock-text 0.1.7
*
* Copyright 2011 Twitter, Inc.
* Copyright 2011 Flowdock Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this work except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*/
if (typeof window === "undefined" || window === null) {
window = { FlowdockText: {} };
}
if (window.FlowdockText == null) {
window.FlowdockText = {};
}
if (typeof FlowdockText === "undefined" || FlowdockText === null) {
FlowdockText = {};
}
(function() {
FlowdockText = {};
FlowdockText.regexen = {};
var HTML_ENTITIES = {
'&': '&amp;',
'>': '&gt;',
'<': '&lt;',
'"': '&quot;',
"'": '&#39;'
};
// HTML escaping
FlowdockText.htmlEscape = function(text) {
return text && text.replace(/[&"'><]/g, function(character) {
return HTML_ENTITIES[character];
});
};
// Builds a RegExp
function regexSupplant(regex, flags) {
flags = flags || "";
if (typeof regex !== "string") {
if (regex.global && flags.indexOf("g") < 0) {
flags += "g";
}
if (regex.ignoreCase && flags.indexOf("i") < 0) {
flags += "i";
}
if (regex.multiline && flags.indexOf("m") < 0) {
flags += "m";
}
regex = regex.source;
}
return new RegExp(regex.replace(/#\{(\w+)\}/g, function(match, name) {
var newRegex = FlowdockText.regexen[name] || "";
if (typeof newRegex !== "string") {
newRegex = newRegex.source;
}
return newRegex;
}), flags);
}
// simple string interpolation
function stringSupplant(str, values) {
return str.replace(/#\{(\w+)\}/g, function(match, name) {
return values[name] || "";
});
}
function addCharsToCharClass(charClass, start, end) {
var s = String.fromCharCode(start);
if (end !== start) {
s += "-" + String.fromCharCode(end);
}
charClass.push(s);
return charClass;
}
// Space is more than %20, U+3000 for example is the full-width space used with Kanji. Provide a short-hand
// to access both the list of characters and a pattern suitible for use with String#split
// Taken from: ActiveSupport::Multibyte::Handlers::UTF8Handler::UNICODE_WHITESPACE
var fromCode = String.fromCharCode;
var UNICODE_SPACES = [
fromCode(0x0020), // White_Space # Zs SPACE
fromCode(0x0085), // White_Space # Cc <control-0085>
fromCode(0x00A0), // White_Space # Zs NO-BREAK SPACE
fromCode(0x1680), // White_Space # Zs OGHAM SPACE MARK
fromCode(0x180E), // White_Space # Zs MONGOLIAN VOWEL SEPARATOR
fromCode(0x2028), // White_Space # Zl LINE SEPARATOR
fromCode(0x2029), // White_Space # Zp PARAGRAPH SEPARATOR
fromCode(0x202F), // White_Space # Zs NARROW NO-BREAK SPACE
fromCode(0x205F), // White_Space # Zs MEDIUM MATHEMATICAL SPACE
fromCode(0x3000) // White_Space # Zs IDEOGRAPHIC SPACE
];
addCharsToCharClass(UNICODE_SPACES, 0x009, 0x00D); // White_Space # Cc [5] <control-0009>..<control-000D>
addCharsToCharClass(UNICODE_SPACES, 0x2000, 0x200A); // White_Space # Zs [11] EN QUAD..HAIR SPACE
var INVALID_CHARS = [
fromCode(0xFFFE),
fromCode(0xFEFF), // BOM
fromCode(0xFFFF) // Special
];
addCharsToCharClass(INVALID_CHARS, 0x202A, 0x202E); // Directional change
FlowdockText.regexen.spaces_group = regexSupplant(UNICODE_SPACES.join(""));
FlowdockText.regexen.spaces = regexSupplant("[" + UNICODE_SPACES.join("") + "]");
FlowdockText.regexen.invalid_chars_group = regexSupplant(INVALID_CHARS.join(""));
FlowdockText.regexen.punct = /\!'#%&'\(\)*\+,\\\-\.\/:;<=>\?@\[\]\^_{|}~\$/;
FlowdockText.regexen.atSigns = /[@＠]/;
FlowdockText.regexen.extractMentions = regexSupplant(/(^|[^a-zA-Z0-9_!#$%&*@＠])(#{atSigns})([a-zA-Z0-9_]{1,20})/g);
var nonLatinHashtagChars = [];
// Cyrillic
addCharsToCharClass(nonLatinHashtagChars, 0x0400, 0x04ff); // Cyrillic
addCharsToCharClass(nonLatinHashtagChars, 0x0500, 0x0527); // Cyrillic Supplement
addCharsToCharClass(nonLatinHashtagChars, 0x2de0, 0x2dff); // Cyrillic Extended A
addCharsToCharClass(nonLatinHashtagChars, 0xa640, 0xa69f); // Cyrillic Extended B
// Hangul (Korean)
addCharsToCharClass(nonLatinHashtagChars, 0x1100, 0x11ff); // Hangul Jamo
addCharsToCharClass(nonLatinHashtagChars, 0x3130, 0x3185); // Hangul Compatibility Jamo
addCharsToCharClass(nonLatinHashtagChars, 0xA960, 0xA97F); // Hangul Jamo Extended-A
addCharsToCharClass(nonLatinHashtagChars, 0xAC00, 0xD7AF); // Hangul Syllables
addCharsToCharClass(nonLatinHashtagChars, 0xD7B0, 0xD7FF); // Hangul Jamo Extended-B
addCharsToCharClass(nonLatinHashtagChars, 0xFFA1, 0xFFDC); // half-width Hangul
// Japanese and Chinese
addCharsToCharClass(nonLatinHashtagChars, 0x30A1, 0x30FA); // Katakana (full-width)
addCharsToCharClass(nonLatinHashtagChars, 0x30FC, 0x30FE); // Katakana Chouon and iteration marks (full-width)
addCharsToCharClass(nonLatinHashtagChars, 0xFF66, 0xFF9F); // Katakana (half-width)
addCharsToCharClass(nonLatinHashtagChars, 0xFF70, 0xFF70); // Katakana Chouon (half-width)
addCharsToCharClass(nonLatinHashtagChars, 0xFF10, 0xFF19); // \
addCharsToCharClass(nonLatinHashtagChars, 0xFF21, 0xFF3A); // - Latin (full-width)
addCharsToCharClass(nonLatinHashtagChars, 0xFF41, 0xFF5A); // /
addCharsToCharClass(nonLatinHashtagChars, 0x3041, 0x3096); // Hiragana
addCharsToCharClass(nonLatinHashtagChars, 0x3099, 0x309E); // Hiragana voicing and iteration mark
addCharsToCharClass(nonLatinHashtagChars, 0x3400, 0x4DBF); // Kanji (CJK Extension A)
addCharsToCharClass(nonLatinHashtagChars, 0x4E00, 0x9FFF); // Kanji (Unified)
// -- Disabled as it breaks the Regex.
//addCharsToCharClass(nonLatinHashtagChars, 0x20000, 0x2A6DF); // Kanji (CJK Extension B)
addCharsToCharClass(nonLatinHashtagChars, 0x2A700, 0x2B73F); // Kanji (CJK Extension C)
addCharsToCharClass(nonLatinHashtagChars, 0x2B740, 0x2B81F); // Kanji (CJK Extension D)
addCharsToCharClass(nonLatinHashtagChars, 0x2F800, 0x2FA1F); // Kanji (CJK supplement)
addCharsToCharClass(nonLatinHashtagChars, 0x3003, 0x3003); // Kanji iteration mark
addCharsToCharClass(nonLatinHashtagChars, 0x3005, 0x3005); // Kanji iteration mark
addCharsToCharClass(nonLatinHashtagChars, 0x303B, 0x303B); // Han iteration mark
FlowdockText.regexen.nonLatinHashtagChars = regexSupplant(nonLatinHashtagChars.join(""));
// Latin accented characters (subtracted 0xD7 from the range, it's a confusable multiplication sign. Looks like "x")
FlowdockText.regexen.latinAccentChars = regexSupplant("ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏİÐÑÒÓÔÕÖØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïıðñòóôõöøùúûüýþş\\303\\277");
FlowdockText.regexen.endScreenNameMatch = regexSupplant(/^(?:#{atSigns}|[#{latinAccentChars}]|:\/\/)/);
// A hashtag must contain characters, numbers and underscores, but not all numbers.
FlowdockText.regexen.hashtagAlpha = regexSupplant(/[a-z_#{latinAccentChars}#{nonLatinHashtagChars}]/i);
FlowdockText.regexen.usernameAlphaNumeric = regexSupplant(/[a-z0-9_\-\.#{latinAccentChars}#{nonLatinHashtagChars}]/i);
FlowdockText.regexen.usernameAlphaNumericEnd = regexSupplant(/[a-z0-9_\-#{latinAccentChars}#{nonLatinHashtagChars}]/i);
FlowdockText.regexen.hashtagAlphaNumeric = regexSupplant(/[a-z0-9_\-#{latinAccentChars}#{nonLatinHashtagChars}]/i);
FlowdockText.regexen.endHashtagMatch = /^(?:[#＃]|:\/\/)/;
FlowdockText.regexen.hashtagBoundary = regexSupplant(/(?:^|$|[^&\/a-z0-9_#{latinAccentChars}#{nonLatinHashtagChars}])/);
FlowdockText.regexen.singleValidHashTag = regexSupplant(/^#{hashtagAlphaNumeric}+$/i);
// FlowdockText change: allow all-numeric hashtags
FlowdockText.regexen.autoLinkHashtags = regexSupplant(/(#{hashtagBoundary})(#|＃)(#{hashtagAlphaNumeric}+)/gi);
FlowdockText.regexen.startHashTagMatch = regexSupplant(/(?:^|[^&\/a-z0-9_#{latinAccentChars}#{nonLatinHashtagChars}])$/);
FlowdockText.regexen.singleHashTag = regexSupplant(/(#|＃)(#{hashtagAlphaNumeric}+)/i);
FlowdockText.regexen.singleMention = regexSupplant(/(@)(#{usernameAlphaNumeric}*#{usernameAlphaNumericEnd}+)/i);
FlowdockText.regexen.autoLinkMentions = regexSupplant(/(#{hashtagBoundary})(@)(#{usernameAlphaNumeric}*#{usernameAlphaNumericEnd}+)/gi);
// We want to only match words starting with the nickname and ignore case
FlowdockText.regexen.highlightRegex = function(nick) {
if (nick && nick.length > 0) { return new RegExp('([\\b\\s]|^)+' + regexEscape(nick) + '([\\b\\s\\!\\?\\,\\:\\;\\.]|$)+', 'i'); }
};
// URL related hash regex collection
FlowdockText.regexen.validPrecedingChars = regexSupplant(/(?:[^-\/"'!=A-Za-z0-9_@＠$#＃\.#{invalid_chars_group}]|^)/);
FlowdockText.regexen.invalidDomainChars = stringSupplant("#{punct}#{spaces_group}#{invalid_chars_group}", FlowdockText.regexen);
FlowdockText.regexen.validDomainChars = regexSupplant(/[^#{invalidDomainChars}]/);
FlowdockText.regexen.validSubdomain = regexSupplant(/(?:(?:#{validDomainChars}(?:[_-]|#{validDomainChars})*)?#{validDomainChars}\.)/);
FlowdockText.regexen.validDomainName = regexSupplant(/(?:(?:#{validDomainChars}(?:-|#{validDomainChars})*)?#{validDomainChars}\.)/);
FlowdockText.regexen.validGTLD = regexSupplant(/(?:(?:aero|asia|biz|cat|com|coop|edu|gov|info|int|jobs|mil|mobi|museum|name|net|org|pro|tel|travel|xxx|local|dmz|lan|corp)(?=[^a-zA-Z]|$))/);
FlowdockText.regexen.validCCTLD = regexSupplant(/(?:(?:ac|ad|ae|af|ag|ai|al|am|an|ao|aq|ar|as|at|au|aw|ax|az|ba|bb|bd|be|bf|bg|bh|bi|bj|bm|bn|bo|br|bs|bt|bv|bw|by|bz|ca|cc|cd|cf|cg|ch|ci|ck|cl|cm|cn|co|cr|cs|cu|cv|cx|cy|cz|dd|de|dj|dk|dm|do|dz|ec|ee|eg|eh|er|es|et|eu|fi|fj|fk|fm|fo|fr|ga|gb|gd|ge|gf|gg|gh|gi|gl|gm|gn|gp|gq|gr|gs|gt|gu|gw|gy|hk|hm|hn|hr|ht|hu|id|ie|il|im|in|io|iq|ir|is|it|je|jm|jo|jp|ke|kg|kh|ki|km|kn|kp|kr|kw|ky|kz|la|lb|lc|li|lk|lr|ls|lt|lu|lv|ly|ma|mc|md|me|mg|mh|mk|ml|mm|mn|mo|mp|mq|mr|ms|mt|mu|mv|mw|mx|my|mz|na|nc|ne|nf|ng|ni|nl|no|np|nr|nu|nz|om|pa|pe|pf|pg|ph|pk|pl|pm|pn|pr|ps|pt|pw|py|qa|re|ro|rs|ru|rw|sa|sb|sc|sd|se|sg|sh|si|sj|sk|sl|sm|sn|so|sr|ss|st|su|sv|sy|sz|tc|td|tf|tg|th|tj|tk|tl|tm|tn|to|tp|tr|tt|tv|tw|tz|ua|ug|uk|us|uy|uz|va|vc|ve|vg|vi|vn|vu|wf|ws|ye|yt|za|zm|zw)(?=[^a-zA-Z]|$))/);
FlowdockText.regexen.validPunycode = regexSupplant(/(?:xn--[0-9a-z]+)/);
FlowdockText.regexen.validDomain = regexSupplant(/(?:#{validSubdomain}*#{validDomainName}(?:#{validGTLD}|#{validCCTLD}|#{validPunycode}))/);
FlowdockText.regexen.pseudoValidIP = regexSupplant(/(?:\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})/);
FlowdockText.regexen.validAsciiDomain = regexSupplant(/(?:(?:[a-z0-9#{latinAccentChars}\-]+)\.)+(?:#{validGTLD}|#{validCCTLD}|#{validPunycode})/gi);
FlowdockText.regexen.validPortNumber = regexSupplant(/[0-9]+/);
FlowdockText.regexen.validGeneralUrlPathChars = regexSupplant(/[a-z0-9!\*';:=\+,\.\$\/%#\[\]\-_~|&#{latinAccentChars}]/i);
// Allow URL paths to contain balanced parens
// 1. Used in Wikipedia URLs like /Primer_(film)
// 2. Used in IIS sessions like /S(dfd346)/
FlowdockText.regexen.validUrlBalancedParens = regexSupplant(/\(#{validGeneralUrlPathChars}+\)/i);
// Valid end-of-path chracters (so /foo. does not gobble the period).
// 1. Allow =&# for empty URL parameters and other URL-join artifacts
FlowdockText.regexen.validUrlPathEndingChars = regexSupplant(/[\+\-a-z0-9=_#\/#{latinAccentChars}]|(?:#{validUrlBalancedParens})/i);
// Allow @ in a url, but only in the middle. Catch things like http://example.com/@user/ and Plone urls like http://example.org/my-document/@@as-message
FlowdockText.regexen.validUrlPath = regexSupplant('(?:' +
'(?:' +
'#{validGeneralUrlPathChars}*' +
'(?:#{validUrlBalancedParens}#{validGeneralUrlPathChars}*)*' +
'#{validUrlPathEndingChars}'+
')|(?:(@|@@)#{validGeneralUrlPathChars}+\/?)'+
')', 'i');
FlowdockText.regexen.validUrlQueryChars = /[a-z0-9!?\*'\(\);:&=\+\$\/%#\[\]\-_\.,~|]/i;
FlowdockText.regexen.validUrlQueryEndingChars = /[a-z0-9_&=#\/]/i;
FlowdockText.regexen.extractUrl = regexSupplant(
'(' + // $1 total match
'(#{validPrecedingChars})' + // $2 Preceeding chracter
'(' + // $3 URL
'(?:' +
'(?:' +
'(https?:\\/\\/)?' + // $4 Protocol (optional)
'(#{validDomain}|#{pseudoValidIP})' + // $5 Domain(s)
')|(?:' + // OR
'(https?:\\/\\/)' + // $6 Protocol
'((?:#{validDomainChars}|-)+)(?=:|\/|#{spaces}|\$)' + // $7 Domain with a following port, path, whitespace or an end of string
')' +
')' +
'(?::(#{validPortNumber}))?' + // $8 Port number (optional)
'(\\/#{validUrlPath}*)?' + // $9 URL Path
'(\\?#{validUrlQueryChars}*#{validUrlQueryEndingChars})?' + // $10 Query String
')' +
')'
, 'gi');
FlowdockText.regexen.singleUrl = regexSupplant(
'(#{validPrecedingChars})' + // before
'(' + // $1 URL
'(?:' +
'(?:' +
'(https?:\\/\\/)?' + // $2 Protocol (optional)
'(#{validDomain}|#{pseudoValidIP})' + // $3 Domain(s)
')|(?:' + // OR
'(https?:\\/\\/)' + // $4 Protocol
'((?:#{validDomainChars}|-)+)(?=:|\/|#{spaces}|\$)' + // $5 Domain with a following port, path, whitespace or an end of string
')' +
')' +
'(?::(#{validPortNumber}))?' + // $6 Port number (optional)
'(\\/#{validUrlPath}*)?' + // $7 URL Path
'(\\?#{validUrlQueryChars}*#{validUrlQueryEndingChars})?' + // $8 Query String
')'
, 'i');
FlowdockText.regexen.validTcoUrl = /^https?:\/\/t\.co\/[a-z0-9]+/i;
// These URL validation pattern strings are based on the ABNF from RFC 3986
FlowdockText.regexen.validateUrlUnreserved = /[a-z0-9\-._~]/i;
FlowdockText.regexen.validateUrlPctEncoded = /(?:%[0-9a-f]{2})/i;
FlowdockText.regexen.validateUrlSubDelims = /[!$&'()*+,;=]/i;
FlowdockText.regexen.validateUrlPchar = regexSupplant('(?:' +
'#{validateUrlUnreserved}|' +
'#{validateUrlPctEncoded}|' +
'#{validateUrlSubDelims}|' +
'[:|@]' +
')', 'i');
FlowdockText.regexen.validateUrlScheme = /(?:[a-z][a-z0-9+\-.]*)/i;
FlowdockText.regexen.validateUrlUserinfo = regexSupplant('(?:' +
'#{validateUrlUnreserved}|' +
'#{validateUrlPctEncoded}|' +
'#{validateUrlSubDelims}|' +
':' +
')*', 'i');
FlowdockText.regexen.validateUrlDecOctet = /(?:[0-9]|(?:[1-9][0-9])|(?:1[0-9]{2})|(?:2[0-4][0-9])|(?:25[0-5]))/i;
FlowdockText.regexen.validateUrlIpv4 = regexSupplant(/(?:#{validateUrlDecOctet}(?:\.#{validateUrlDecOctet}){3})/i);
// Punting on real IPv6 validation for now
FlowdockText.regexen.validateUrlIpv6 = /(?:\[[a-f0-9:\.]+\])/i;
// Also punting on IPvFuture for now
FlowdockText.regexen.validateUrlIp = regexSupplant('(?:' +
'#{validateUrlIpv4}|' +
'#{validateUrlIpv6}' +
')', 'i');
// This is more strict than the rfc specifies
FlowdockText.regexen.validateUrlSubDomainSegment = /(?:[a-z0-9](?:[a-z0-9_\-]*[a-z0-9])?)/i;
FlowdockText.regexen.validateUrlDomainSegment = /(?:[a-z0-9](?:[a-z0-9\-]*[a-z0-9])?)/i;
FlowdockText.regexen.validateUrlDomainTld = /(?:[a-z](?:[a-z0-9\-]*[a-z0-9])?)/i;
FlowdockText.regexen.validateUrlDomain = regexSupplant(/(?:(?:#{validateUrlSubDomainSegment]}\.)*(?:#{validateUrlDomainSegment]}\.)#{validateUrlDomainTld})/i);
FlowdockText.regexen.validateUrlHost = regexSupplant('(?:' +
'#{validateUrlIp}|' +
'#{validateUrlDomain}' +
')', 'i');
// Unencoded internationalized domains - this doesn't check for invalid UTF-8 sequences
FlowdockText.regexen.validateUrlUnicodeSubDomainSegment = /(?:(?:[a-z0-9]|[^\u0000-\u007f])(?:(?:[a-z0-9_\-]|[^\u0000-\u007f])*(?:[a-z0-9]|[^\u0000-\u007f]))?)/i;
FlowdockText.regexen.validateUrlUnicodeDomainSegment = /(?:(?:[a-z0-9]|[^\u0000-\u007f])(?:(?:[a-z0-9\-]|[^\u0000-\u007f])*(?:[a-z0-9]|[^\u0000-\u007f]))?)/i;
FlowdockText.regexen.validateUrlUnicodeDomainTld = /(?:(?:[a-z]|[^\u0000-\u007f])(?:(?:[a-z0-9\-]|[^\u0000-\u007f])*(?:[a-z0-9]|[^\u0000-\u007f]))?)/i;
FlowdockText.regexen.validateUrlUnicodeDomain = regexSupplant(/(?:(?:#{validateUrlUnicodeSubDomainSegment}\.)*(?:#{validateUrlUnicodeDomainSegment}\.)#{validateUrlUnicodeDomainTld})/i);
FlowdockText.regexen.validateUrlUnicodeHost = regexSupplant('(?:' +
'#{validateUrlIp}|' +
'#{validateUrlUnicodeDomain}' +
')', 'i');
FlowdockText.regexen.validateUrlPort = /[0-9]{1,5}/;
FlowdockText.regexen.validateUrlUnicodeAuthority = regexSupplant(
'(?:(#{validateUrlUserinfo})@)?' + // $1 userinfo
'(#{validateUrlUnicodeHost})' + // $2 host
'(?::(#{validateUrlPort}))?' //$3 port
, "i");
FlowdockText.regexen.validateUrlAuthority = regexSupplant(
'(?:(#{validateUrlUserinfo})@)?' + // $1 userinfo
'(#{validateUrlHost})' + // $2 host
'(?::(#{validateUrlPort}))?' // $3 port
, "i");
FlowdockText.regexen.validateUrlPath = regexSupplant(/(\/#{validateUrlPchar}*)*/i);
FlowdockText.regexen.validateUrlQuery = regexSupplant(/(#{validateUrlPchar}|\/|\?)*/i);
FlowdockText.regexen.validateUrlFragment = regexSupplant(/(#{validateUrlPchar}|\/|\?)*/i);
// Modified version of RFC 3986 Appendix B
FlowdockText.regexen.validateUrlUnencoded = regexSupplant(
'^' + // Full URL
'(?:' +
'([^:/?#]+):\\/\\/' + // $1 Scheme
')?' +
'([^/?#]*)' + // $2 Authority
'([^?#]*)' + // $3 Path
'(?:' +
'\\?([^#]*)' + // $4 Query
')?' +
'(?:' +
'#(.*)' + // $5 Fragment
')?$'
, "i");
FlowdockText.regexen.validEmailLocalPart = regexSupplant("[A-z|0-9|.|_|%|+|-]+");
FlowdockText.regexen.email = regexSupplant(
/#{validEmailLocalPart}@#{validDomain}/
, 'gi');
FlowdockText.regexen.extractEmails = regexSupplant(
/(?:^|\s|,|"|')?(#{email})/
, 'gi');
FlowdockText.regexen.singleEmail = regexSupplant(/(?:^|\s|,|"|')?(#{email})/, 'i');
// Default CSS class for auto-linked URLs
var DEFAULT_URL_CLASS = "linkify-link";
// Default CSS class for auto-linked usernames (along with the url class)
var DEFAULT_USERNAME_CLASS = "app-tag-link";
// Default CSS class for auto-linked hashtags (along with the url class)
var DEFAULT_HASHTAG_CLASS = "app-tag-link";
// Simple object cloning function for simple objects
function clone(o) {
var r = {};
for (var k in o) {
if (o.hasOwnProperty(k)) {
r[k] = o[k];
}
}
return r;
}
function checkHashtagMention(match, originalText, position) {
var start = position + match.index;
var before = originalText.slice(0, start);
var after = originalText.slice(start + match[0].length);
return FlowdockText.regexen.startHashTagMatch.test(before) && !FlowdockText.regexen.endHashtagMatch.test(after);
}
var TOKEN_SPECS = [
{
type: "url",
regex: FlowdockText.regexen.singleUrl,
check: function () { return true; },
},
{
type: "hash",
regex: FlowdockText.regexen.singleHashTag,
check: checkHashtagMention,
},
{
type: "mention",
regex: FlowdockText.regexen.singleMention,
check: checkHashtagMention,
},
{
type: "email",
regex: FlowdockText.regexen.singleEmail,
check: function () { return true; },
},
];
function tokenizeHelper(text, originalText, position, spec) {
var m = text.match(spec.regex);
// console.log("match", m);
if (m) {
if (!spec.check(m, originalText, position)) {
return null;
}
return {
type: spec.type,
match: m,
start: position + m.index,
end: position + m.index + m[0].length,
}
}
return m;
}
function tokenize(text) {
var tokens = [];
var position = 0;
while (true) {
// javascript regexps doesn't have "match from" functionality,
// so we need to take a substr
var textpart = text.substr(position);
// try to match all token specs
var ts = TOKEN_SPECS.map(tokenizeHelper.bind(null, textpart, text, position));
// find match with smallest start offset
var min = undefined;
for (var i = 0; i < ts.length; i++) {
var m = ts[i];
if (!min || (m && m.start < min.start)) {
min = m;
}
}
if (min) {
// if there's a match,
// add text token, if there's something
if (min.start > position) {
tokens.push({
type: "text",
value: textpart.substr(0, min.start - position),
});
}
// and add matched token
tokens.push(min);
// update position for the next iteration
position = min.end;
} else {
// if none of token specs matched, the rest of the input is plain text
tokens.push({
type: "text",
value: textpart,
});
return tokens;
}
}
}
function transformUrl(options, urlToken) {
var urlEntities, i, len;
if(options.urlEntities) {
urlEntities = {};
for(i = 0, len = options.urlEntities.length; i < len; i++) {
urlEntities[options.urlEntities[i].url] = options.urlEntities[i];
}
}
var url = urlToken.match[2],
protocol = (urlToken.match[3] || urlToken.match[5]),
htmlAttrs = "";
var before = urlToken.match[1];
var after = "";
for (var k in options) {
htmlAttrs += stringSupplant(" #{k}=\"#{v}\" ", {k: k, v: options[k].toString().replace(/"/, "&quot;").replace(/</, "&lt;").replace(/>/, "&gt;")});
}
if (url.match(FlowdockText.regexen.validTcoUrl)) {
url = RegExp.lastMatch;
after = RegExp.rightContext;
}
var d = {
htmlAttrs: htmlAttrs,
url: FlowdockText.htmlEscape(url),
after: after,
before: before,
};
if (urlEntities && urlEntities[url] && urlEntities[url].display_url) {
d.displayUrl = FlowdockText.htmlEscape(urlEntities[url].display_url);
} else {
d.displayUrl = d.url;
}
if (!protocol) {
d.url = 'http://' + d.url;
}
return stringSupplant("#{before}<a href=\"#{url}\"#{htmlAttrs}>#{displayUrl}</a>#{after}", d);
}
function transformEmail(options, emailToken) {
return emailToken.match[0].replace(FlowdockText.regexen.email, function(subMatch) {
d = {
subMatch: FlowdockText.htmlEscape(subMatch)
};
for (var k in options) {
if (options.hasOwnProperty(k)) {
d[k] = options[k];
}
}
return stringSupplant("<a href='mailto:#{subMatch}' class='#{emailClass}'>#{subMatch}</a>", d);
});
}
function transformHashTag(options, hashtagToken) {
var match = hashtagToken.match;
var hash = match[1];
var text = match[2];
var d = {
hash: FlowdockText.htmlEscape(hash),
preText: "",
text: FlowdockText.htmlEscape(text),
postText: "",
};
for (var k in options) {
if (options.hasOwnProperty(k)) {
d[k] = options[k];
}
}
return stringSupplant("<a href=\"#{hashtagUrlBase}#{text}\" title=\"##{text}\" class=\"#{hashtagClass}\">#{hash}#{preText}#{text}#{postText}</a>", d);
}
function transformMention(options, userToken) {
var userTags = [];
if(options && options.userTags){
userTags = options.userTags.map(function(tag){ return tag.toLowerCase() });
}
var match = userToken.match;
var hash = match[1];
var text = match[2];
var d = {
hash: FlowdockText.htmlEscape(hash),
preText: "",
text: FlowdockText.htmlEscape(text),
postText: "",
};
for (var k in options) {
if (options.hasOwnProperty(k)) {
d[k] = options[k];
}
}
if (userTags.length !== 0 && !inArray(d.hash + d.text.toLowerCase(), userTags)){
return stringSupplant("#{hash}#{preText}#{text}#{postText}", d);
} else {
return stringSupplant("<a title=\"Search #{hash}#{text}\" class=\"#{hashtagClass}\" href=\"#{hashtagUrlBase}#{hash}#{text}\">#{hash}#{preText}#{text}#{postText}</a>", d);
}
}
function transformToken(options, urlLinkOptions, token) {
switch (token.type) {
case "text":
return token.value;
case "url":
return transformUrl(urlLinkOptions, token);
case "hash":
return transformHashTag(options, token);
case "mention":
return transformMention(options, token);
case "email":
return transformEmail(options, token);
}
}
function autoLinkOptions(options) {
options = clone(options || {});
options.hashtagClass = options.hashtagClass || DEFAULT_HASHTAG_CLASS;
options.hashtagUrlBase = options.hashtagUrlBase || "#flowser/all/";
options.emailClass = options.emailClass || "email-link";
return options;
}
function autoLinkUrlLinkOptions(options) {
return clone(options || {});
}
function filterToken(type, token) {
if (token.type === type || token.type === "text") {
return token;
} else {
return {
type: "text",
value: token.match[0],
};
}
}
function autoLinkImpl(text, options, urlLinkOptions, filter) {
options = autoLinkOptions(options);
urlLinkOptions = autoLinkUrlLinkOptions(urlLinkOptions);
var tokens = tokenize(text);
if (filter) {
tokens = tokens.map(filterToken.bind(null, filter));
}
var parts = tokens.map(transformToken.bind(null, options, urlLinkOptions));
return parts.join("");
}
FlowdockText.autoLink = function(text, options, urlLinkOptions) {
return autoLinkImpl(text, options, urlLinkOptions);
};
FlowdockText.autoLinkHashtags = function(text, options) {
return autoLinkImpl(text, options, {}, "hash");
};
FlowdockText.autoLinkEmails = function(text, options) {
return autoLinkImpl(text, options, {}, "email");
}
FlowdockText.autoLinkUrlsCustom = function(text, urlLinkOptions) {
return autoLinkImpl(text, {}, urlLinkOptions, "url");
};
FlowdockText.autoLinkMentions = function(text, options) {
return autoLinkImpl(text, options, {}, "mention");
};
FlowdockText.extractMentions = function(text) {
var screenNamesOnly = [],
screenNamesWithIndices = FlowdockText.extractMentionsWithIndices(text);
for (var i = 0; i < screenNamesWithIndices.length; i++) {
var screenName = screenNamesWithIndices[i].screenName;
screenNamesOnly.push(screenName);
}
return screenNamesOnly;
};
FlowdockText.extractMentionsWithIndices = function(text) {
if (!text) {
return [];
}
var possibleScreenNames = [],
position = 0;
text.replace(FlowdockText.regexen.extractMentions, function(match, before, atSign, screenName, offset, chunk) {
var after = chunk.slice(offset + match.length);
if (!after.match(FlowdockText.regexen.endScreenNameMatch)) {
var startPosition = text.indexOf(atSign + screenName, position);
position = startPosition + screenName.length + 1;
possibleScreenNames.push({
username: screenName,
indices: [startPosition, position]
});
}
});
return possibleScreenNames;
};
FlowdockText.extractUrls = function(text) {
var urlsOnly = [],
urlsWithIndices = FlowdockText.extractUrlsWithIndices(text);
for (var i = 0; i < urlsWithIndices.length; i++) {
urlsOnly.push(urlsWithIndices[i].url);
}
return urlsOnly;
};
FlowdockText.extractEmails = function(text) {
var emailsOnly = [],
emailsWithIndices = FlowdockText.extractEmailsWithIndices(text);
for (var i = 0; i < emailsWithIndices.length; i++){
emailsOnly.push(emailsWithIndices[i].email)
}
return emailsOnly;
}
FlowdockText.extractEmailsWithIndices = function(text){
if (!text) {
return [];
}
var tokens = tokenize(text);
tokens = tokens.filter(function (t) {
return t.type == "email";
});
var emails = [];
tokens.forEach(function (t) {
// TODO: refactor, copy paste
return t.match[0].replace(FlowdockText.regexen.email, function(subMatch) {
submatch = FlowdockText.htmlEscape(subMatch);
var endPosition = t.end + FlowdockText.regexen.extractEmails.lastIndex;
var startPosition = endPosition - submatch.length;
emails.push({
email: submatch,
indices: [startPosition, endPosition],
});
});
});
return emails;
}
FlowdockText.extractUrlsWithIndices = function(text) {
if (!text) {
return [];
}
var tokens = tokenize(text);
tokens = tokens.filter(function (t) {
return t.type == "url";
})
// tokens.length && console.error(tokens);
var urls = [];
tokens.forEach(function (t) {
var match = t.match;
var before = match[1],
url = match[2],
protocol = (match[3] || match[5]),
domain = (match[4] || match[6]),
path = match[8],
startPosition = t.start + before.length, // TODO: fix
endPosition = t.end;
// if protocol is missing and domain contains non-ASCII characters,
// extract ASCII-only domains.
if (!protocol) {
var lastUrl = null,
lastUrlInvalidMatch = false,
asciiEndPosition = 0;
domain.replace(FlowdockText.regexen.validAsciiDomain, function(asciiDomain) {
var asciiStartPosition = domain.indexOf(asciiDomain, asciiEndPosition);
asciiEndPosition = asciiStartPosition + asciiDomain.length
lastUrl = {
url: asciiDomain,
indices: [startPosition + asciiStartPosition, startPosition + asciiEndPosition]
}
urls.push(lastUrl);
});
// no ASCII-only domain found. Skip the entire URL.
if (lastUrl == null) {
return;
}
// lastUrl only contains domain. Need to add path and query if they exist.
if (path) {
if (lastUrlInvalidMatch) {
urls.push(lastUrl);
}
lastUrl.url = url.replace(domain, lastUrl.url);
lastUrl.indices[1] = endPosition;
}
} else {
// In the case of t.co URLs, don't allow additional path characters.
if (url.match(FlowdockText.regexen.validTcoUrl)) {
url = RegExp.lastMatch;
endPosition = startPosition + url.length;
}
urls.push({
url: url,
indices: [startPosition, endPosition]
});
}
});
return urls;
};
FlowdockText.extractHashtags = function(text) {
var hashtagsOnly = [],
hashtagsWithIndices = FlowdockText.extractHashtagsWithIndices(text);
for (var i = 0; i < hashtagsWithIndices.length; i++) {
hashtagsOnly.push(hashtagsWithIndices[i].tag);
}
return hashtagsOnly;
};
FlowdockText.extractHashtagsWithIndices = function(text) {
if (!text) {
return [];
}
var tokens = tokenize(text);
tokens = tokens.filter(function (t) {
return t.type == "hash";
})
var tags = [];
tokens.forEach(function (t) {
var match = t.match;
var hash = match[1];
var text = match[2];
var startPosition = t.start;
var endPosition = t.end;
tags.push({
tag: text,
indices: [startPosition, endPosition]
});
});
return tags;
};
FlowdockText.modifyIndicesFromUnicodeToUTF16 = function(text, entities) {
FlowdockText.shiftIndices(text, entities, 1);
};
FlowdockText.modifyIndicesFromUTF16ToUnicode = function(text, entities) {
FlowdockText.shiftIndices(text, entities, -1);
};
FlowdockText.shiftIndices = function(text, entities, diff) {
for (var i = 0; i < text.length - 1; i++) {
var c1 = text.charCodeAt(i);
var c2 = text.charCodeAt(i + 1);
if (0xD800 <= c1 && c1 <= 0xDBFF && 0xDC00 <= c2 && c2 <= 0xDFFF) {
// supplementary character
i++; // skip surrogate pair character
for (var j = 0; j < entities.length; j++) {
if (entities[j].indices[0] >= i) {
entities[j].indices[0] += diff;
entities[j].indices[1] += diff;
}
}
}
}
};
FlowdockText.extractMentions = function(text, userTags){
var mentionsOnly = [],
mentionsWithIndices = FlowdockText.extractMentionsWithIndices(text, userTags);
for (var i = 0; i < mentionsWithIndices.length; i++) {
mentionsOnly.push(mentionsWithIndices[i].tag);
}
if(userTags){
userTags = downCase(userTags.map(getUserTag));
return mentionsOnly.filter(function(tag){ return inArray(tag.toLowerCase(), userTags) });
}
return mentionsOnly;
};
FlowdockText.extractMentionsWithIndices = function(text, userTags) {
if (!text) {
return [];
}
var tokens = tokenize(text);
tokens = tokens.filter(function (t) {
return t.type == "mention";
})
var tags = [];
tokens.forEach(function (t) {
var match = t.match;
var hash = match[1];
var text = match[2];
var startPosition = t.start;
var endPosition = t.end;
tags.push({
tag: hash + text,
indices: [startPosition, endPosition]
});
});
if (userTags) {
userTags = downCase(userTags.map(getUserTag));
return tags.filter(function(tag){ return inArray(tag.tag.toLowerCase(), userTags) });
}
return tags;
};
FlowdockText.parseTags = function(message, users, me) {
var tags = [];
var users = users || [];
var me = me || {};
var tokens = tokenize(message);
var urls = FlowdockText.extractUrls(message);
var matchedTags = tokens
.filter(function (t) {
return t.type === "hash";
})
.map(function (t) {
return t.match[2];
});
var matchedMentions = FlowdockText.extractMentions(message);
if (matchedTags.length > 0) {
//Uniq the matchedTags
matchedTags.forEach(function(tag) {
if(!inArray(tag.toLowerCase(), tags)) tags.push(tag);
});
}
//Add the :url metatag if any urls in the message
if (urls.length > 0) tags.push(":url");
// Find @everyone-tags from messages and tag with :user:everyone
if (FlowdockText.mentionsAll(matchedMentions)) tags.push(":user:everyone");
users.forEach(function(user) {
if (!user.nick || user.nick.length == 0 || user.id == 0 || user.disabled) return;
// Find nicknames from messages sent by other users and tag with :highlight
if (user.id != me.id && message.match(FlowdockText.regexen.highlightRegex(user.nick))) {
tags.push(":highlight:" + user.id);
}
if (FlowdockText.mentionsUser(matchedMentions, user)) tags.push(":user:" + user.id);
if([":highlight:" + user.id, ":user:" + user.id, ":user:everyone"].some(function(tag){
return tags.indexOf(tag) !== -1;
}) && user.id !== me.id){
tags.push(":unread:" + user.id);
}
});
return tags.filter(function(tag){ return tag[0] !== "@"});
};
FlowdockText.mentionsAll = function(check){
if(isArray(check)){
return ["@everyone", "@everybody", "@all", "@anyone", "@anybody"].some(function(tag) {
return downCase(check).indexOf(tag) !== -1;
});
} else {
return FlowdockText.mentionsAll(FlowdockText.extractMentions(check));
}
};
FlowdockText.mentionsUser = function(check, user){
if(isArray(check)){
return downCase(check).indexOf(getUserTag(user).toLowerCase()) !== -1;
} else {
return FlowdockText.extractMentions(check, [getUserTag(user)]).length > 0;
}
};
FlowdockText.isValidUrl = function(url, unicodeDomains, requireProtocol) {
if (unicodeDomains == null) {
unicodeDomains = true;
}
if (requireProtocol == null) {
requireProtocol = true;
}
if (!url) {
return false;
}
var urlParts = url.match(FlowdockText.regexen.validateUrlUnencoded);
if (!urlParts || urlParts[0] !== url) {
return false;
}
var scheme = urlParts[1],
authority = urlParts[2],
path = urlParts[3],
query = urlParts[4],
fragment = urlParts[5];
if (!(
(!requireProtocol || (isValidMatch(scheme, FlowdockText.regexen.validateUrlScheme) && scheme.match(/^https?$/i))) &&
isValidMatch(path, FlowdockText.regexen.validateUrlPath) &&
isValidMatch(query, FlowdockText.regexen.validateUrlQuery, true) &&
isValidMatch(fragment, FlowdockText.regexen.validateUrlFragment, true)
)) {
return false;
}
return (unicodeDomains && isValidMatch(authority, FlowdockText.regexen.validateUrlUnicodeAuthority)) ||
(!unicodeDomains && isValidMatch(authority, FlowdockText.regexen.validateUrlAuthority));
};
function isValidMatch(string, regex, optional) {
if (!optional) {
// RegExp["$&"] is the text of the last match
// blank strings are ok, but are falsy, so we check stringiness instead of truthiness
return ((typeof string === "string") && string.match(regex) && RegExp["$&"] === string);
}
// RegExp["$&"] is the text of the last match
return (!string || (string.match(regex) && RegExp["$&"] === string));
}
function getUserTag(user){
if(typeof user === "string"){
return (user[0] === "@" ? user : "@" + user)
} else {
return "@" + user.nick;
}
}
function downCase(arr){
return arr.map(function(item){ return item.toLowerCase(); });
}
function inArray(needle, haystack){
return haystack.indexOf(needle) !== -1;
}
function isArray(thing){
return Object.prototype.toString.call(thing) === "[object Array]";
}
// Escape regex special chars
function regexEscape(text) {
return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
}
if (typeof module != 'undefined' && module.exports) {
module.exports = FlowdockText;
}
}());
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment