+
+Installation
+------------
+
+There are two options for installing nodeunit:
+
+1. Clone / download nodeunit from [github](https://github.com/caolan/nodeunit),
+ then:
+
+ make && sudo make install
+
+2. Install via npm:
+
+ npm install nodeunit
+
+API Documentation
+-----------------
+
+Nodeunit uses the functions available in the node.js
+[assert module](http://nodejs.org/docs/v0.4.2/api/assert.html):
+
+* __ok(value, [message])__ - Tests if value is a true value.
+* __equal(actual, expected, [message])__ - Tests shallow, coercive equality
+ with the equal comparison operator ( == ).
+* __notEqual(actual, expected, [message])__ - Tests shallow, coercive
+ non-equality with the not equal comparison operator ( != ).
+* __deepEqual(actual, expected, [message])__ - Tests for deep equality.
+* __notDeepEqual(actual, expected, [message])__ - Tests for any deep
+ inequality.
+* __strictEqual(actual, expected, [message])__ - Tests strict equality, as
+ determined by the strict equality operator ( === )
+* __notStrictEqual(actual, expected, [message])__ - Tests strict non-equality,
+ as determined by the strict not equal operator ( !== )
+* __throws(block, [error], [message])__ - Expects block to throw an error.
+* __doesNotThrow(block, [error], [message])__ - Expects block not to throw an
+ error.
+* __ifError(value)__ - Tests if value is not a false value, throws if it is a
+ true value. Useful when testing the first argument, error in callbacks.
+
+Nodeunit also provides the following functions within tests:
+
+* __expect(amount)__ - Specify how many assertions are expected to run within a
+ test. Very useful for ensuring that all your callbacks and assertions are
+ run.
+* __done()__ - Finish the current test function, and move on to the next. ALL
+ tests should call this!
+
+Nodeunit aims to be simple and easy to learn. This is achieved through using
+existing structures (such as node.js modules) to maximum effect, and reducing
+the API where possible, to make it easier to digest.
+
+Tests are simply exported from a module, but they are still run in the order
+they are defined.
+
+__Note:__ Users of old nodeunit versions may remember using ok, equals and same
+in the style of qunit, instead of the assert functions above. These functions
+still exist for backwards compatibility, and are simply aliases to their assert
+module counterparts.
+
+
+Asynchronous Testing
+--------------------
+
+When testing asynchronous code, there are a number of sharp edges to watch out
+for. Thankfully, nodeunit is designed to help you avoid as many of these
+pitfalls as possible. For the most part, testing asynchronous code in nodeunit
+_just works_.
+
+
+### Tests run in series
+
+While running tests in parallel seems like a good idea for speeding up your
+test suite, in practice I've found it means writing much more complicated
+tests. Because of node's module cache, running tests in parallel means mocking
+and stubbing is pretty much impossible. One of the nicest things about testing
+in javascript is the ease of doing stubs:
+
+ var _readFile = fs.readFile;
+ fs.readFile = function(path, callback){
+ // its a stub!
+ };
+ // test function that uses fs.readFile
+
+ // we're done
+ fs.readFile = _readFile;
+
+You cannot do this when running tests in parallel. In order to keep testing as
+simple as possible, nodeunit avoids it. Thankfully, most unit-test suites run
+fast anyway.
+
+
+### Explicit ending of tests
+
+When testing async code its important that tests end at the correct point, not
+just after a given number of assertions. Otherwise your tests can run short,
+ending before all assertions have completed. Its important to detect too
+many assertions as well as too few. Combining explicit ending of tests with
+an expected number of assertions helps to avoid false test passes, so be sure
+to use the test.expect() method at the start of your test functions, and
+test.done() when finished.
+
+
+Groups, setUp and tearDown
+--------------------------
+
+Nodeunit allows the nesting of test functions:
+
+ exports.test1 = function (test) {
+ ...
+ }
+
+ exports.group = {
+ test2: function (test) {
+ ...
+ },
+ test3: function (test) {
+ ...
+ }
+ }
+
+This would be run as:
+
+ test1
+ group - test2
+ group - test3
+
+Using these groups its possible to add setUp and tearDown functions to your
+tests. Nodeunit has a utility function called testCase which allows you to
+define a setUp function, which is run before each test, and a tearDown
+function, which is run after each test calls test.done():
+
+ var testCase = require('nodeunit').testCase;
+
+ module.exports = testCase({
+ setUp: function (callback) {
+ this.foo = 'bar';
+ callback();
+ },
+ tearDown: function (callback) {
+ // clean up
+ callback();
+ },
+ test1: function (test) {
+ test.equals(this.foo, 'bar');
+ test.done();
+ }
+ });
+
+In this way, its possible to have multiple groups of tests in a module, each
+group with its own setUp and tearDown functions.
+
+
+Running Tests
+-------------
+
+Nodeunit comes with a basic command-line test runner, which can be installed
+using 'sudo make install'. Example usage:
+
+ nodeunit testmodule1.js testfolder [...]
+
+The default test reporter uses color output, because I think that's more fun :) I
+intend to add a no-color option in future. To give you a feeling of the fun you'll
+be having writing tests, lets fix the example at the start of the README:
+
+
+
+Ahhh, Doesn't that feel better?
+
+When using the included test runner, it will exit using the failed number of
+assertions as the exit code. Exiting with 0 when all tests pass.
+
+
+### Command-line Options
+
+* __--reporter FILE__ - you can set the test reporter to a custom module or
+on of the modules in nodeunit/lib/reporters, when omitted, the default test runner
+is used.
+* __--list-reporters__ - list available build-in reporters.
+* __--config FILE__ - load config options from a JSON file, allows
+the customisation of color schemes for the default test reporter etc. See
+bin/nodeunit.json for current available options.
+* __--version__ or __-v__ - report nodeunit version
+* __--help__ - show nodeunit help
+
+
+Running tests in the browser
+----------------------------
+
+Nodeunit tests can also be run inside the browser. For example usage, see
+the examples/browser folder. The basic syntax is as follows:
+
+__test.html__
+
+
+
+ b ? 1 : 0;
+ };
+ callback(null, _map(results.sort(fn), function (x) {
+ return x.value;
+ }));
+ }
+ });
+ };
+
+ async.auto = function (tasks, callback) {
+ callback = callback || function () {};
+ var keys = _keys(tasks);
+ if (!keys.length) {
+ return callback(null);
+ }
+
+ var completed = [];
+
+ var listeners = [];
+ var addListener = function (fn) {
+ listeners.unshift(fn);
+ };
+ var removeListener = function (fn) {
+ for (var i = 0; i < listeners.length; i += 1) {
+ if (listeners[i] === fn) {
+ listeners.splice(i, 1);
+ return;
+ }
+ }
+ };
+ var taskComplete = function () {
+ _forEach(listeners, function (fn) {
+ fn();
+ });
+ };
+
+ addListener(function () {
+ if (completed.length === keys.length) {
+ callback(null);
+ }
+ });
+
+ _forEach(keys, function (k) {
+ var task = (tasks[k] instanceof Function) ? [tasks[k]]: tasks[k];
+ var taskCallback = function (err) {
+ if (err) {
+ callback(err);
+ // stop subsequent errors hitting callback multiple times
+ callback = function () {};
+ }
+ else {
+ completed.push(k);
+ taskComplete();
+ }
+ };
+ var requires = task.slice(0, Math.abs(task.length - 1)) || [];
+ var ready = function () {
+ return _reduce(requires, function (a, x) {
+ return (a && _indexOf(completed, x) !== -1);
+ }, true);
+ };
+ if (ready()) {
+ task[task.length - 1](taskCallback);
+ }
+ else {
+ var listener = function () {
+ if (ready()) {
+ removeListener(listener);
+ task[task.length - 1](taskCallback);
+ }
+ };
+ addListener(listener);
+ }
+ });
+ };
+
+ async.waterfall = function (tasks, callback) {
+ if (!tasks.length) {
+ return callback();
+ }
+ callback = callback || function () {};
+ var wrapIterator = function (iterator) {
+ return function (err) {
+ if (err) {
+ callback(err);
+ callback = function () {};
+ }
+ else {
+ var args = Array.prototype.slice.call(arguments, 1);
+ var next = iterator.next();
+ if (next) {
+ args.push(wrapIterator(next));
+ }
+ else {
+ args.push(callback);
+ }
+ async.nextTick(function () {
+ iterator.apply(null, args);
+ });
+ }
+ };
+ };
+ wrapIterator(async.iterator(tasks))();
+ };
+
+ async.parallel = function (tasks, callback) {
+ callback = callback || function () {};
+ if (tasks.constructor === Array) {
+ async.map(tasks, function (fn, callback) {
+ if (fn) {
+ fn(function (err) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ if (args.length <= 1) {
+ args = args[0];
+ }
+ callback.call(null, err, args || null);
+ });
+ }
+ }, callback);
+ }
+ else {
+ var results = {};
+ async.forEach(_keys(tasks), function (k, callback) {
+ tasks[k](function (err) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ if (args.length <= 1) {
+ args = args[0];
+ }
+ results[k] = args;
+ callback(err);
+ });
+ }, function (err) {
+ callback(err, results);
+ });
+ }
+ };
+
+ async.series = function (tasks, callback) {
+ callback = callback || function () {};
+ if (tasks.constructor === Array) {
+ async.mapSeries(tasks, function (fn, callback) {
+ if (fn) {
+ fn(function (err) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ if (args.length <= 1) {
+ args = args[0];
+ }
+ callback.call(null, err, args || null);
+ });
+ }
+ }, callback);
+ }
+ else {
+ var results = {};
+ async.forEachSeries(_keys(tasks), function (k, callback) {
+ tasks[k](function (err) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ if (args.length <= 1) {
+ args = args[0];
+ }
+ results[k] = args;
+ callback(err);
+ });
+ }, function (err) {
+ callback(err, results);
+ });
+ }
+ };
+
+ async.iterator = function (tasks) {
+ var makeCallback = function (index) {
+ var fn = function () {
+ if (tasks.length) {
+ tasks[index].apply(null, arguments);
+ }
+ return fn.next();
+ };
+ fn.next = function () {
+ return (index < tasks.length - 1) ? makeCallback(index + 1): null;
+ };
+ return fn;
+ };
+ return makeCallback(0);
+ };
+
+ async.apply = function (fn) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ return function () {
+ return fn.apply(
+ null, args.concat(Array.prototype.slice.call(arguments))
+ );
+ };
+ };
+
+ var _concat = function (eachfn, arr, fn, callback) {
+ var r = [];
+ eachfn(arr, function (x, cb) {
+ fn(x, function (err, y) {
+ r = r.concat(y || []);
+ cb(err);
+ });
+ }, function (err) {
+ callback(err, r);
+ });
+ };
+ async.concat = doParallel(_concat);
+ async.concatSeries = doSeries(_concat);
+
+ async.whilst = function (test, iterator, callback) {
+ if (test()) {
+ iterator(function (err) {
+ if (err) {
+ return callback(err);
+ }
+ async.whilst(test, iterator, callback);
+ });
+ }
+ else {
+ callback();
+ }
+ };
+
+ async.until = function (test, iterator, callback) {
+ if (!test()) {
+ iterator(function (err) {
+ if (err) {
+ return callback(err);
+ }
+ async.until(test, iterator, callback);
+ });
+ }
+ else {
+ callback();
+ }
+ };
+
+ async.queue = function (worker, concurrency) {
+ var workers = 0;
+ var tasks = [];
+ var q = {
+ concurrency: concurrency,
+ push: function (data, callback) {
+ tasks.push({data: data, callback: callback});
+ async.nextTick(q.process);
+ },
+ process: function () {
+ if (workers < q.concurrency && tasks.length) {
+ var task = tasks.splice(0, 1)[0];
+ workers += 1;
+ worker(task.data, function () {
+ workers -= 1;
+ if (task.callback) {
+ task.callback.apply(task, arguments);
+ }
+ q.process();
+ });
+ }
+ },
+ length: function () {
+ return tasks.length;
+ }
+ };
+ return q;
+ };
+
+ var _console_fn = function (name) {
+ return function (fn) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ fn.apply(null, args.concat([function (err) {
+ var args = Array.prototype.slice.call(arguments, 1);
+ if (typeof console !== 'undefined') {
+ if (err) {
+ if (console.error) {
+ console.error(err);
+ }
+ }
+ else if (console[name]) {
+ _forEach(args, function (x) {
+ console[name](x);
+ });
+ }
+ }
+ }]));
+ };
+ };
+ async.log = _console_fn('log');
+ async.dir = _console_fn('dir');
+ /*async.info = _console_fn('info');
+ async.warn = _console_fn('warn');
+ async.error = _console_fn('error');*/
+
+ async.memoize = function (fn, hasher) {
+ var memo = {};
+ hasher = hasher || function (x) {
+ return x;
+ };
+ return function () {
+ var args = Array.prototype.slice.call(arguments);
+ var callback = args.pop();
+ var key = hasher.apply(null, args);
+ if (key in memo) {
+ callback.apply(null, memo[key]);
+ }
+ else {
+ fn.apply(null, args.concat([function () {
+ memo[key] = arguments;
+ callback.apply(null, arguments);
+ }]));
+ }
+ };
+ };
+
+}());
diff --git a/bin/node_modules/nodeunit/deps/console.log.js b/bin/node_modules/nodeunit/deps/console.log.js
new file mode 100644
index 00000000..fe146c1e
--- /dev/null
+++ b/bin/node_modules/nodeunit/deps/console.log.js
@@ -0,0 +1,55 @@
+/*
+ A console.log that won't leave you hanging when node exits
+ 90% of this file was ripped from node.js
+
+ License: see: https://github.com/joyent/node/blob/master/lib/console.js
+ */
+
+ // console object
+var formatRegExp = /%[sdj]/g;
+function format(f) {
+ var util = require('util');
+
+ if (typeof f !== 'string') {
+ var objects = [];
+ for (var i = 0; i < arguments.length; i++) {
+ objects.push(util.inspect(arguments[i]));
+ }
+ return objects.join(' ');
+ }
+
+
+ var i = 1;
+ var args = arguments;
+ var str = String(f).replace(formatRegExp, function(x) {
+ switch (x) {
+ case '%s': return String(args[i++]);
+ case '%d': return Number(args[i++]);
+ case '%j': return JSON.stringify(args[i++]);
+ default:
+ return x;
+ }
+ });
+ for (var len = args.length, x = args[i]; i < len; x = args[++i]) {
+ if (x === null || typeof x !== 'object') {
+ str += ' ' + x;
+ } else {
+ str += ' ' + util.inspect(x);
+ }
+ }
+ return str;
+}
+
+console.log = function() {
+ var res = process.stdout.write(format.apply(this, arguments) + '\n');
+
+ // this is the first time stdout got backed up
+ if (!res && !process.stdout.pendingWrite) {
+ process.stdout.pendingWrite = true;
+
+ // magic sauce: keep node alive until stdout has flushed
+ process.stdout.once('drain', function () {
+ process.stdout.draining = false;
+ });
+ }
+};
diff --git a/bin/node_modules/nodeunit/deps/ejs.js b/bin/node_modules/nodeunit/deps/ejs.js
new file mode 100644
index 00000000..f6abf29f
--- /dev/null
+++ b/bin/node_modules/nodeunit/deps/ejs.js
@@ -0,0 +1,125 @@
+
+/*!
+ * EJS
+ * Copyright(c) 2010 TJ Holowaychuk
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies.
+ */
+
+var sys = require('sys');
+
+/**
+ * Library version.
+ */
+
+exports.version = '0.0.3';
+
+/**
+ * Intermediate js cache.
+ *
+ * @type Object
+ */
+
+var cache = {};
+
+/**
+ * Clear intermediate js cache.
+ *
+ * @api public
+ */
+
+exports.clearCache = function(){
+ cache = {};
+};
+
+/**
+ * Escape the given string of `html`.
+ *
+ * @param {String} html
+ * @return {String}
+ * @api private
+ */
+
+function escape(html){
+ return String(html)
+ .replace(/&(?!\w+;)/g, '&')
+ .replace(//g, '>')
+ .replace(/"/g, '"');
+}
+
+/**
+ * Parse the given `str` of ejs, returning the function body.
+ *
+ * @param {String} str
+ * @return {String}
+ * @api public
+ */
+
+var parse = exports.parse = function(str){
+ return 'var buf = [];\n'
+ + "with (locals) {\nbuf.push('"
+ + String(str)
+ .replace(/[\r\t]/g, " ")
+ .replace(/\n/g, "\\n")
+ .split("<%").join("\t")
+ .replace(/((^|%>)[^\t]*)'/g, "$1\r")
+ .replace(/\t=(.*?)%>/g, "', escape($1) ,'")
+ .replace(/\t-(.*?)%>/g, "', $1 ,'")
+ .split("\t").join("');")
+ .split("%>").join("buf.push('")
+ .split("\r").join("\\'")
+ + "');\n}\nreturn buf.join('');";
+};
+
+/**
+ * Compile the given `str` of ejs into a `Function`.
+ *
+ * @param {String} str
+ * @param {Object} options
+ * @return {Function}
+ * @api public
+ */
+
+var compile = exports.compile = function(str, options){
+ if (options.debug) sys.puts(parse(str));
+ return new Function('locals, escape', parse(str));
+};
+
+/**
+ * Render the given `str` of ejs.
+ *
+ * Options:
+ *
+ * - `locals` Local variables object
+ * - `cache` Compiled functions are cached, requires `filename`
+ * - `filename` Used by `cache` to key caches
+ * - `context|scope` Function execution context
+ * - `debug` Output generated function body
+ *
+ * @param {String} str
+ * @param {Object} options
+ * @return {String}
+ * @api public
+ */
+
+exports.render = function(str, options){
+ var fn,
+ options = options || {};
+ if (options.cache) {
+ if (options.filename) {
+ fn = cache[options.filename] = compile(str, options);
+ } else {
+ throw new Error('"cache" option requires "filename".');
+ }
+ } else {
+ fn = compile(str, options);
+ }
+ return fn.call(
+ options.context || options.scope,
+ options.locals || {},
+ escape);
+};
\ No newline at end of file
diff --git a/bin/node_modules/nodeunit/deps/json2.js b/bin/node_modules/nodeunit/deps/json2.js
new file mode 100644
index 00000000..22b44d96
--- /dev/null
+++ b/bin/node_modules/nodeunit/deps/json2.js
@@ -0,0 +1,483 @@
+/*
+ http://www.JSON.org/json2.js
+ 2010-11-17
+
+ Public Domain.
+
+ NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+
+ See http://www.JSON.org/js.html
+
+
+ This code should be minified before deployment.
+ See http://javascript.crockford.com/jsmin.html
+
+ USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
+ NOT CONTROL.
+
+
+ This file creates a global JSON object containing two methods: stringify
+ and parse.
+
+ JSON.stringify(value, replacer, space)
+ value any JavaScript value, usually an object or array.
+
+ replacer an optional parameter that determines how object
+ values are stringified for objects. It can be a
+ function or an array of strings.
+
+ space an optional parameter that specifies the indentation
+ of nested structures. If it is omitted, the text will
+ be packed without extra whitespace. If it is a number,
+ it will specify the number of spaces to indent at each
+ level. If it is a string (such as '\t' or ' '),
+ it contains the characters used to indent at each level.
+
+ This method produces a JSON text from a JavaScript value.
+
+ When an object value is found, if the object contains a toJSON
+ method, its toJSON method will be called and the result will be
+ stringified. A toJSON method does not serialize: it returns the
+ value represented by the name/value pair that should be serialized,
+ or undefined if nothing should be serialized. The toJSON method
+ will be passed the key associated with the value, and this will be
+ bound to the value
+
+ For example, this would serialize Dates as ISO strings.
+
+ Date.prototype.toJSON = function (key) {
+ function f(n) {
+ // Format integers to have at least two digits.
+ return n < 10 ? '0' + n : n;
+ }
+
+ return this.getUTCFullYear() + '-' +
+ f(this.getUTCMonth() + 1) + '-' +
+ f(this.getUTCDate()) + 'T' +
+ f(this.getUTCHours()) + ':' +
+ f(this.getUTCMinutes()) + ':' +
+ f(this.getUTCSeconds()) + 'Z';
+ };
+
+ You can provide an optional replacer method. It will be passed the
+ key and value of each member, with this bound to the containing
+ object. The value that is returned from your method will be
+ serialized. If your method returns undefined, then the member will
+ be excluded from the serialization.
+
+ If the replacer parameter is an array of strings, then it will be
+ used to select the members to be serialized. It filters the results
+ such that only members with keys listed in the replacer array are
+ stringified.
+
+ Values that do not have JSON representations, such as undefined or
+ functions, will not be serialized. Such values in objects will be
+ dropped; in arrays they will be replaced with null. You can use
+ a replacer function to replace those with JSON values.
+ JSON.stringify(undefined) returns undefined.
+
+ The optional space parameter produces a stringification of the
+ value that is filled with line breaks and indentation to make it
+ easier to read.
+
+ If the space parameter is a non-empty string, then that string will
+ be used for indentation. If the space parameter is a number, then
+ the indentation will be that many spaces.
+
+ Example:
+
+ text = JSON.stringify(['e', {pluribus: 'unum'}]);
+ // text is '["e",{"pluribus":"unum"}]'
+
+
+ text = JSON.stringify(['e', {pluribus: 'unum'}], null, '\t');
+ // text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'
+
+ text = JSON.stringify([new Date()], function (key, value) {
+ return this[key] instanceof Date ?
+ 'Date(' + this[key] + ')' : value;
+ });
+ // text is '["Date(---current time---)"]'
+
+
+ JSON.parse(text, reviver)
+ This method parses a JSON text to produce an object or array.
+ It can throw a SyntaxError exception.
+
+ The optional reviver parameter is a function that can filter and
+ transform the results. It receives each of the keys and values,
+ and its return value is used instead of the original value.
+ If it returns what it received, then the structure is not modified.
+ If it returns undefined then the member is deleted.
+
+ Example:
+
+ // Parse the text. Values that look like ISO date strings will
+ // be converted to Date objects.
+
+ myData = JSON.parse(text, function (key, value) {
+ var a;
+ if (typeof value === 'string') {
+ a =
+/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
+ if (a) {
+ return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
+ +a[5], +a[6]));
+ }
+ }
+ return value;
+ });
+
+ myData = JSON.parse('["Date(09/09/2001)"]', function (key, value) {
+ var d;
+ if (typeof value === 'string' &&
+ value.slice(0, 5) === 'Date(' &&
+ value.slice(-1) === ')') {
+ d = new Date(value.slice(5, -1));
+ if (d) {
+ return d;
+ }
+ }
+ return value;
+ });
+
+
+ This is a reference implementation. You are free to copy, modify, or
+ redistribute.
+*/
+
+/*jslint evil: true, strict: false, regexp: false */
+
+/*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply,
+ call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
+ getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join,
+ lastIndex, length, parse, prototype, push, replace, slice, stringify,
+ test, toJSON, toString, valueOf
+*/
+
+
+// Create a JSON object only if one does not already exist. We create the
+// methods in a closure to avoid creating global variables.
+
+if (!this.JSON) {
+ this.JSON = {};
+}
+
+(function () {
+ "use strict";
+
+ function f(n) {
+ // Format integers to have at least two digits.
+ return n < 10 ? '0' + n : n;
+ }
+
+ if (typeof Date.prototype.toJSON !== 'function') {
+
+ Date.prototype.toJSON = function (key) {
+
+ return isFinite(this.valueOf()) ?
+ this.getUTCFullYear() + '-' +
+ f(this.getUTCMonth() + 1) + '-' +
+ f(this.getUTCDate()) + 'T' +
+ f(this.getUTCHours()) + ':' +
+ f(this.getUTCMinutes()) + ':' +
+ f(this.getUTCSeconds()) + 'Z' : null;
+ };
+
+ String.prototype.toJSON =
+ Number.prototype.toJSON =
+ Boolean.prototype.toJSON = function (key) {
+ return this.valueOf();
+ };
+ }
+
+ var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+ escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+ gap,
+ indent,
+ meta = { // table of character substitutions
+ '\b': '\\b',
+ '\t': '\\t',
+ '\n': '\\n',
+ '\f': '\\f',
+ '\r': '\\r',
+ '"' : '\\"',
+ '\\': '\\\\'
+ },
+ rep;
+
+
+ function quote(string) {
+
+// If the string contains no control characters, no quote characters, and no
+// backslash characters, then we can safely slap some quotes around it.
+// Otherwise we must also replace the offending characters with safe escape
+// sequences.
+
+ escapable.lastIndex = 0;
+ return escapable.test(string) ?
+ '"' + string.replace(escapable, function (a) {
+ var c = meta[a];
+ return typeof c === 'string' ? c :
+ '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+ }) + '"' :
+ '"' + string + '"';
+ }
+
+
+ function str(key, holder) {
+
+// Produce a string from holder[key].
+
+ var i, // The loop counter.
+ k, // The member key.
+ v, // The member value.
+ length,
+ mind = gap,
+ partial,
+ value = holder[key];
+
+// If the value has a toJSON method, call it to obtain a replacement value.
+
+ if (value && typeof value === 'object' &&
+ typeof value.toJSON === 'function') {
+ value = value.toJSON(key);
+ }
+
+// If we were called with a replacer function, then call the replacer to
+// obtain a replacement value.
+
+ if (typeof rep === 'function') {
+ value = rep.call(holder, key, value);
+ }
+
+// What happens next depends on the value's type.
+
+ switch (typeof value) {
+ case 'string':
+ return quote(value);
+
+ case 'number':
+
+// JSON numbers must be finite. Encode non-finite numbers as null.
+
+ return isFinite(value) ? String(value) : 'null';
+
+ case 'boolean':
+ case 'null':
+
+// If the value is a boolean or null, convert it to a string. Note:
+// typeof null does not produce 'null'. The case is included here in
+// the remote chance that this gets fixed someday.
+
+ return String(value);
+
+// If the type is 'object', we might be dealing with an object or an array or
+// null.
+
+ case 'object':
+
+// Due to a specification blunder in ECMAScript, typeof null is 'object',
+// so watch out for that case.
+
+ if (!value) {
+ return 'null';
+ }
+
+// Make an array to hold the partial results of stringifying this object value.
+
+ gap += indent;
+ partial = [];
+
+// Is the value an array?
+
+ if (Object.prototype.toString.apply(value) === '[object Array]') {
+
+// The value is an array. Stringify every element. Use null as a placeholder
+// for non-JSON values.
+
+ length = value.length;
+ for (i = 0; i < length; i += 1) {
+ partial[i] = str(i, value) || 'null';
+ }
+
+// Join all of the elements together, separated with commas, and wrap them in
+// brackets.
+
+ v = partial.length === 0 ? '[]' :
+ gap ? '[\n' + gap +
+ partial.join(',\n' + gap) + '\n' +
+ mind + ']' :
+ '[' + partial.join(',') + ']';
+ gap = mind;
+ return v;
+ }
+
+// If the replacer is an array, use it to select the members to be stringified.
+
+ if (rep && typeof rep === 'object') {
+ length = rep.length;
+ for (i = 0; i < length; i += 1) {
+ k = rep[i];
+ if (typeof k === 'string') {
+ v = str(k, value);
+ if (v) {
+ partial.push(quote(k) + (gap ? ': ' : ':') + v);
+ }
+ }
+ }
+ } else {
+
+// Otherwise, iterate through all of the keys in the object.
+
+ for (k in value) {
+ if (Object.hasOwnProperty.call(value, k)) {
+ v = str(k, value);
+ if (v) {
+ partial.push(quote(k) + (gap ? ': ' : ':') + v);
+ }
+ }
+ }
+ }
+
+// Join all of the member texts together, separated with commas,
+// and wrap them in braces.
+
+ v = partial.length === 0 ? '{}' :
+ gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' +
+ mind + '}' : '{' + partial.join(',') + '}';
+ gap = mind;
+ return v;
+ }
+ }
+
+// If the JSON object does not yet have a stringify method, give it one.
+
+ if (typeof JSON.stringify !== 'function') {
+ JSON.stringify = function (value, replacer, space) {
+
+// The stringify method takes a value and an optional replacer, and an optional
+// space parameter, and returns a JSON text. The replacer can be a function
+// that can replace values, or an array of strings that will select the keys.
+// A default replacer method can be provided. Use of the space parameter can
+// produce text that is more easily readable.
+
+ var i;
+ gap = '';
+ indent = '';
+
+// If the space parameter is a number, make an indent string containing that
+// many spaces.
+
+ if (typeof space === 'number') {
+ for (i = 0; i < space; i += 1) {
+ indent += ' ';
+ }
+
+// If the space parameter is a string, it will be used as the indent string.
+
+ } else if (typeof space === 'string') {
+ indent = space;
+ }
+
+// If there is a replacer, it must be a function or an array.
+// Otherwise, throw an error.
+
+ rep = replacer;
+ if (replacer && typeof replacer !== 'function' &&
+ (typeof replacer !== 'object' ||
+ typeof replacer.length !== 'number')) {
+ throw new Error('JSON.stringify');
+ }
+
+// Make a fake root object containing our value under the key of ''.
+// Return the result of stringifying the value.
+
+ return str('', {'': value});
+ };
+ }
+
+
+// If the JSON object does not yet have a parse method, give it one.
+
+ if (typeof JSON.parse !== 'function') {
+ JSON.parse = function (text, reviver) {
+
+// The parse method takes a text and an optional reviver function, and returns
+// a JavaScript value if the text is a valid JSON text.
+
+ var j;
+
+ function walk(holder, key) {
+
+// The walk method is used to recursively walk the resulting structure so
+// that modifications can be made.
+
+ var k, v, value = holder[key];
+ if (value && typeof value === 'object') {
+ for (k in value) {
+ if (Object.hasOwnProperty.call(value, k)) {
+ v = walk(value, k);
+ if (v !== undefined) {
+ value[k] = v;
+ } else {
+ delete value[k];
+ }
+ }
+ }
+ }
+ return reviver.call(holder, key, value);
+ }
+
+
+// Parsing happens in four stages. In the first stage, we replace certain
+// Unicode characters with escape sequences. JavaScript handles many characters
+// incorrectly, either silently deleting them, or treating them as line endings.
+
+ text = String(text);
+ cx.lastIndex = 0;
+ if (cx.test(text)) {
+ text = text.replace(cx, function (a) {
+ return '\\u' +
+ ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+ });
+ }
+
+// In the second stage, we run the text against regular expressions that look
+// for non-JSON patterns. We are especially concerned with '()' and 'new'
+// because they can cause invocation, and '=' because it can cause mutation.
+// But just to be safe, we want to reject all unexpected forms.
+
+// We split the second stage into 4 regexp operations in order to work around
+// crippling inefficiencies in IE's and Safari's regexp engines. First we
+// replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
+// replace all simple value tokens with ']' characters. Third, we delete all
+// open brackets that follow a colon or comma or that begin the text. Finally,
+// we look to see that the remaining characters are only whitespace or ']' or
+// ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
+
+ if (/^[\],:{}\s]*$/
+.test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
+.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
+.replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+
+// In the third stage we use the eval function to compile the text into a
+// JavaScript structure. The '{' operator is subject to a syntactic ambiguity
+// in JavaScript: it can begin a block or an object literal. We wrap the text
+// in parens to eliminate the ambiguity.
+
+ j = eval('(' + text + ')');
+
+// In the optional fourth stage, we recursively walk the new structure, passing
+// each name/value pair to a reviver function for possible transformation.
+
+ return typeof reviver === 'function' ?
+ walk({'': j}, '') : j;
+ }
+
+// If the text is not JSON parseable, then a SyntaxError is thrown.
+
+ throw new SyntaxError('JSON.parse');
+ };
+ }
+}());
diff --git a/bin/node_modules/nodeunit/doc/nodeunit.md b/bin/node_modules/nodeunit/doc/nodeunit.md
new file mode 100644
index 00000000..efde75cd
--- /dev/null
+++ b/bin/node_modules/nodeunit/doc/nodeunit.md
@@ -0,0 +1,60 @@
+nodeunit(1) -- simple node.js unit testing tool
+===============================================
+
+## SYNOPSIS
+
+ nodeunit [options] [ ...]
+
+## DESCRIPTION
+
+Nodeunit is a simple unit testing tool based on the node.js assert module.
+
+* Simple to use
+* Just export the tests from a module
+* Helps you avoid common pitfalls when testing asynchronous code
+* Easy to add test cases with setUp and tearDown functions if you wish
+* Allows the use of mocks and stubs
+
+## OPTIONS
+
+ __--config FILE__:
+ Load config options from a JSON file, allows the customisation
+ of color schemes for the default test reporter etc.
+ See bin/nodeunit.json for current available options.
+
+ __--reporter FILE__:
+ You can set the test reporter to a custom module or on of the modules
+ in nodeunit/lib/reporters, when omitted, the default test runner is used.
+
+ __--list-reporters__:
+ List available build-in reporters.
+
+ __-h__, __--help__:
+ Display the help and exit.
+
+ __-v__, __--version__:
+ Output version information and exit.
+
+ ____:
+ You can run nodeunit on specific files or on all *\*.js* files inside
+ a directory.
+
+## AUTHORS
+
+Written by Caolan McMahon and other nodeunit contributors.
+Contributors list: .
+
+## REPORTING BUGS
+
+Report nodeunit bugs to .
+
+## COPYRIGHT
+
+Copyright © 2010 Caolan McMahon.
+Nodeunit has been released under the MIT license:
+.
+
+## SEE ALSO
+
+node(1)
+
diff --git a/bin/node_modules/nodeunit/examples/browser/nodeunit.js b/bin/node_modules/nodeunit/examples/browser/nodeunit.js
new file mode 100644
index 00000000..8c12b0f8
--- /dev/null
+++ b/bin/node_modules/nodeunit/examples/browser/nodeunit.js
@@ -0,0 +1,1757 @@
+/*!
+ * Nodeunit
+ * https://github.com/caolan/nodeunit
+ * Copyright (c) 2010 Caolan McMahon
+ * MIT Licensed
+ *
+ * json2.js
+ * http://www.JSON.org/json2.js
+ * Public Domain.
+ * NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+ */
+nodeunit = (function(){
+/*
+ http://www.JSON.org/json2.js
+ 2010-11-17
+
+ Public Domain.
+
+ NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+
+ See http://www.JSON.org/js.html
+
+
+ This code should be minified before deployment.
+ See http://javascript.crockford.com/jsmin.html
+
+ USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO
+ NOT CONTROL.
+
+
+ This file creates a global JSON object containing two methods: stringify
+ and parse.
+
+ JSON.stringify(value, replacer, space)
+ value any JavaScript value, usually an object or array.
+
+ replacer an optional parameter that determines how object
+ values are stringified for objects. It can be a
+ function or an array of strings.
+
+ space an optional parameter that specifies the indentation
+ of nested structures. If it is omitted, the text will
+ be packed without extra whitespace. If it is a number,
+ it will specify the number of spaces to indent at each
+ level. If it is a string (such as '\t' or ' '),
+ it contains the characters used to indent at each level.
+
+ This method produces a JSON text from a JavaScript value.
+
+ When an object value is found, if the object contains a toJSON
+ method, its toJSON method will be called and the result will be
+ stringified. A toJSON method does not serialize: it returns the
+ value represented by the name/value pair that should be serialized,
+ or undefined if nothing should be serialized. The toJSON method
+ will be passed the key associated with the value, and this will be
+ bound to the value
+
+ For example, this would serialize Dates as ISO strings.
+
+ Date.prototype.toJSON = function (key) {
+ function f(n) {
+ // Format integers to have at least two digits.
+ return n < 10 ? '0' + n : n;
+ }
+
+ return this.getUTCFullYear() + '-' +
+ f(this.getUTCMonth() + 1) + '-' +
+ f(this.getUTCDate()) + 'T' +
+ f(this.getUTCHours()) + ':' +
+ f(this.getUTCMinutes()) + ':' +
+ f(this.getUTCSeconds()) + 'Z';
+ };
+
+ You can provide an optional replacer method. It will be passed the
+ key and value of each member, with this bound to the containing
+ object. The value that is returned from your method will be
+ serialized. If your method returns undefined, then the member will
+ be excluded from the serialization.
+
+ If the replacer parameter is an array of strings, then it will be
+ used to select the members to be serialized. It filters the results
+ such that only members with keys listed in the replacer array are
+ stringified.
+
+ Values that do not have JSON representations, such as undefined or
+ functions, will not be serialized. Such values in objects will be
+ dropped; in arrays they will be replaced with null. You can use
+ a replacer function to replace those with JSON values.
+ JSON.stringify(undefined) returns undefined.
+
+ The optional space parameter produces a stringification of the
+ value that is filled with line breaks and indentation to make it
+ easier to read.
+
+ If the space parameter is a non-empty string, then that string will
+ be used for indentation. If the space parameter is a number, then
+ the indentation will be that many spaces.
+
+ Example:
+
+ text = JSON.stringify(['e', {pluribus: 'unum'}]);
+ // text is '["e",{"pluribus":"unum"}]'
+
+
+ text = JSON.stringify(['e', {pluribus: 'unum'}], null, '\t');
+ // text is '[\n\t"e",\n\t{\n\t\t"pluribus": "unum"\n\t}\n]'
+
+ text = JSON.stringify([new Date()], function (key, value) {
+ return this[key] instanceof Date ?
+ 'Date(' + this[key] + ')' : value;
+ });
+ // text is '["Date(---current time---)"]'
+
+
+ JSON.parse(text, reviver)
+ This method parses a JSON text to produce an object or array.
+ It can throw a SyntaxError exception.
+
+ The optional reviver parameter is a function that can filter and
+ transform the results. It receives each of the keys and values,
+ and its return value is used instead of the original value.
+ If it returns what it received, then the structure is not modified.
+ If it returns undefined then the member is deleted.
+
+ Example:
+
+ // Parse the text. Values that look like ISO date strings will
+ // be converted to Date objects.
+
+ myData = JSON.parse(text, function (key, value) {
+ var a;
+ if (typeof value === 'string') {
+ a =
+/^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
+ if (a) {
+ return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4],
+ +a[5], +a[6]));
+ }
+ }
+ return value;
+ });
+
+ myData = JSON.parse('["Date(09/09/2001)"]', function (key, value) {
+ var d;
+ if (typeof value === 'string' &&
+ value.slice(0, 5) === 'Date(' &&
+ value.slice(-1) === ')') {
+ d = new Date(value.slice(5, -1));
+ if (d) {
+ return d;
+ }
+ }
+ return value;
+ });
+
+
+ This is a reference implementation. You are free to copy, modify, or
+ redistribute.
+*/
+
+/*jslint evil: true, strict: false, regexp: false */
+
+/*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply,
+ call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours,
+ getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join,
+ lastIndex, length, parse, prototype, push, replace, slice, stringify,
+ test, toJSON, toString, valueOf
+*/
+
+
+// Create a JSON object only if one does not already exist. We create the
+// methods in a closure to avoid creating global variables.
+
+if (!this.JSON) {
+ this.JSON = {};
+}
+
+(function () {
+ "use strict";
+
+ function f(n) {
+ // Format integers to have at least two digits.
+ return n < 10 ? '0' + n : n;
+ }
+
+ if (typeof Date.prototype.toJSON !== 'function') {
+
+ Date.prototype.toJSON = function (key) {
+
+ return isFinite(this.valueOf()) ?
+ this.getUTCFullYear() + '-' +
+ f(this.getUTCMonth() + 1) + '-' +
+ f(this.getUTCDate()) + 'T' +
+ f(this.getUTCHours()) + ':' +
+ f(this.getUTCMinutes()) + ':' +
+ f(this.getUTCSeconds()) + 'Z' : null;
+ };
+
+ String.prototype.toJSON =
+ Number.prototype.toJSON =
+ Boolean.prototype.toJSON = function (key) {
+ return this.valueOf();
+ };
+ }
+
+ var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+ escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+ gap,
+ indent,
+ meta = { // table of character substitutions
+ '\b': '\\b',
+ '\t': '\\t',
+ '\n': '\\n',
+ '\f': '\\f',
+ '\r': '\\r',
+ '"' : '\\"',
+ '\\': '\\\\'
+ },
+ rep;
+
+
+ function quote(string) {
+
+// If the string contains no control characters, no quote characters, and no
+// backslash characters, then we can safely slap some quotes around it.
+// Otherwise we must also replace the offending characters with safe escape
+// sequences.
+
+ escapable.lastIndex = 0;
+ return escapable.test(string) ?
+ '"' + string.replace(escapable, function (a) {
+ var c = meta[a];
+ return typeof c === 'string' ? c :
+ '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+ }) + '"' :
+ '"' + string + '"';
+ }
+
+
+ function str(key, holder) {
+
+// Produce a string from holder[key].
+
+ var i, // The loop counter.
+ k, // The member key.
+ v, // The member value.
+ length,
+ mind = gap,
+ partial,
+ value = holder[key];
+
+// If the value has a toJSON method, call it to obtain a replacement value.
+
+ if (value && typeof value === 'object' &&
+ typeof value.toJSON === 'function') {
+ value = value.toJSON(key);
+ }
+
+// If we were called with a replacer function, then call the replacer to
+// obtain a replacement value.
+
+ if (typeof rep === 'function') {
+ value = rep.call(holder, key, value);
+ }
+
+// What happens next depends on the value's type.
+
+ switch (typeof value) {
+ case 'string':
+ return quote(value);
+
+ case 'number':
+
+// JSON numbers must be finite. Encode non-finite numbers as null.
+
+ return isFinite(value) ? String(value) : 'null';
+
+ case 'boolean':
+ case 'null':
+
+// If the value is a boolean or null, convert it to a string. Note:
+// typeof null does not produce 'null'. The case is included here in
+// the remote chance that this gets fixed someday.
+
+ return String(value);
+
+// If the type is 'object', we might be dealing with an object or an array or
+// null.
+
+ case 'object':
+
+// Due to a specification blunder in ECMAScript, typeof null is 'object',
+// so watch out for that case.
+
+ if (!value) {
+ return 'null';
+ }
+
+// Make an array to hold the partial results of stringifying this object value.
+
+ gap += indent;
+ partial = [];
+
+// Is the value an array?
+
+ if (Object.prototype.toString.apply(value) === '[object Array]') {
+
+// The value is an array. Stringify every element. Use null as a placeholder
+// for non-JSON values.
+
+ length = value.length;
+ for (i = 0; i < length; i += 1) {
+ partial[i] = str(i, value) || 'null';
+ }
+
+// Join all of the elements together, separated with commas, and wrap them in
+// brackets.
+
+ v = partial.length === 0 ? '[]' :
+ gap ? '[\n' + gap +
+ partial.join(',\n' + gap) + '\n' +
+ mind + ']' :
+ '[' + partial.join(',') + ']';
+ gap = mind;
+ return v;
+ }
+
+// If the replacer is an array, use it to select the members to be stringified.
+
+ if (rep && typeof rep === 'object') {
+ length = rep.length;
+ for (i = 0; i < length; i += 1) {
+ k = rep[i];
+ if (typeof k === 'string') {
+ v = str(k, value);
+ if (v) {
+ partial.push(quote(k) + (gap ? ': ' : ':') + v);
+ }
+ }
+ }
+ } else {
+
+// Otherwise, iterate through all of the keys in the object.
+
+ for (k in value) {
+ if (Object.hasOwnProperty.call(value, k)) {
+ v = str(k, value);
+ if (v) {
+ partial.push(quote(k) + (gap ? ': ' : ':') + v);
+ }
+ }
+ }
+ }
+
+// Join all of the member texts together, separated with commas,
+// and wrap them in braces.
+
+ v = partial.length === 0 ? '{}' :
+ gap ? '{\n' + gap + partial.join(',\n' + gap) + '\n' +
+ mind + '}' : '{' + partial.join(',') + '}';
+ gap = mind;
+ return v;
+ }
+ }
+
+// If the JSON object does not yet have a stringify method, give it one.
+
+ if (typeof JSON.stringify !== 'function') {
+ JSON.stringify = function (value, replacer, space) {
+
+// The stringify method takes a value and an optional replacer, and an optional
+// space parameter, and returns a JSON text. The replacer can be a function
+// that can replace values, or an array of strings that will select the keys.
+// A default replacer method can be provided. Use of the space parameter can
+// produce text that is more easily readable.
+
+ var i;
+ gap = '';
+ indent = '';
+
+// If the space parameter is a number, make an indent string containing that
+// many spaces.
+
+ if (typeof space === 'number') {
+ for (i = 0; i < space; i += 1) {
+ indent += ' ';
+ }
+
+// If the space parameter is a string, it will be used as the indent string.
+
+ } else if (typeof space === 'string') {
+ indent = space;
+ }
+
+// If there is a replacer, it must be a function or an array.
+// Otherwise, throw an error.
+
+ rep = replacer;
+ if (replacer && typeof replacer !== 'function' &&
+ (typeof replacer !== 'object' ||
+ typeof replacer.length !== 'number')) {
+ throw new Error('JSON.stringify');
+ }
+
+// Make a fake root object containing our value under the key of ''.
+// Return the result of stringifying the value.
+
+ return str('', {'': value});
+ };
+ }
+
+
+// If the JSON object does not yet have a parse method, give it one.
+
+ if (typeof JSON.parse !== 'function') {
+ JSON.parse = function (text, reviver) {
+
+// The parse method takes a text and an optional reviver function, and returns
+// a JavaScript value if the text is a valid JSON text.
+
+ var j;
+
+ function walk(holder, key) {
+
+// The walk method is used to recursively walk the resulting structure so
+// that modifications can be made.
+
+ var k, v, value = holder[key];
+ if (value && typeof value === 'object') {
+ for (k in value) {
+ if (Object.hasOwnProperty.call(value, k)) {
+ v = walk(value, k);
+ if (v !== undefined) {
+ value[k] = v;
+ } else {
+ delete value[k];
+ }
+ }
+ }
+ }
+ return reviver.call(holder, key, value);
+ }
+
+
+// Parsing happens in four stages. In the first stage, we replace certain
+// Unicode characters with escape sequences. JavaScript handles many characters
+// incorrectly, either silently deleting them, or treating them as line endings.
+
+ text = String(text);
+ cx.lastIndex = 0;
+ if (cx.test(text)) {
+ text = text.replace(cx, function (a) {
+ return '\\u' +
+ ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+ });
+ }
+
+// In the second stage, we run the text against regular expressions that look
+// for non-JSON patterns. We are especially concerned with '()' and 'new'
+// because they can cause invocation, and '=' because it can cause mutation.
+// But just to be safe, we want to reject all unexpected forms.
+
+// We split the second stage into 4 regexp operations in order to work around
+// crippling inefficiencies in IE's and Safari's regexp engines. First we
+// replace the JSON backslash pairs with '@' (a non-JSON character). Second, we
+// replace all simple value tokens with ']' characters. Third, we delete all
+// open brackets that follow a colon or comma or that begin the text. Finally,
+// we look to see that the remaining characters are only whitespace or ']' or
+// ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.
+
+ if (/^[\],:{}\s]*$/
+.test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
+.replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
+.replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+
+// In the third stage we use the eval function to compile the text into a
+// JavaScript structure. The '{' operator is subject to a syntactic ambiguity
+// in JavaScript: it can begin a block or an object literal. We wrap the text
+// in parens to eliminate the ambiguity.
+
+ j = eval('(' + text + ')');
+
+// In the optional fourth stage, we recursively walk the new structure, passing
+// each name/value pair to a reviver function for possible transformation.
+
+ return typeof reviver === 'function' ?
+ walk({'': j}, '') : j;
+ }
+
+// If the text is not JSON parseable, then a SyntaxError is thrown.
+
+ throw new SyntaxError('JSON.parse');
+ };
+ }
+}());
+var assert = {};
+var types = {};
+var core = {};
+var nodeunit = {};
+var reporter = {};
+(function(){
+
+ var async = {};
+
+ // global on the server, window in the browser
+ var root = this;
+ var previous_async = root.async;
+
+ if(typeof module !== 'undefined' && module.exports) module.exports = async;
+ else root.async = async;
+
+ async.noConflict = function(){
+ root.async = previous_async;
+ return async;
+ };
+
+ //// cross-browser compatiblity functions ////
+
+ var _forEach = function(arr, iterator){
+ if(arr.forEach) return arr.forEach(iterator);
+ for(var i=0; i b ? 1 : 0;
+ }), function(x){return x.value;}));
+ })
+ };
+
+ async.auto = function(tasks, callback){
+ callback = callback || function(){};
+ var keys = _keys(tasks);
+ if(!keys.length) return callback(null);
+
+ var completed = [];
+
+ var listeners = [];
+ var addListener = function(fn){
+ listeners.unshift(fn);
+ };
+ var removeListener = function(fn){
+ for(var i=0; i
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the 'Software'), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+var pSlice = Array.prototype.slice;
+
+// 1. The assert module provides functions that throw
+// AssertionError's when particular conditions are not met. The
+// assert module must conform to the following interface.
+
+var assert = exports;
+
+// 2. The AssertionError is defined in assert.
+// new assert.AssertionError({message: message, actual: actual, expected: expected})
+
+assert.AssertionError = function AssertionError (options) {
+ this.name = "AssertionError";
+ this.message = options.message;
+ this.actual = options.actual;
+ this.expected = options.expected;
+ this.operator = options.operator;
+ var stackStartFunction = options.stackStartFunction || fail;
+
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, stackStartFunction);
+ }
+};
+// code from util.inherits in node
+assert.AssertionError.super_ = Error;
+
+
+// EDITED FOR BROWSER COMPATIBILITY: replaced Object.create call
+// TODO: test what effect this may have
+var ctor = function () { this.constructor = assert.AssertionError; };
+ctor.prototype = Error.prototype;
+assert.AssertionError.prototype = new ctor();
+
+
+assert.AssertionError.prototype.toString = function() {
+ if (this.message) {
+ return [this.name+":", this.message].join(' ');
+ } else {
+ return [ this.name+":"
+ , JSON.stringify(this.expected )
+ , this.operator
+ , JSON.stringify(this.actual)
+ ].join(" ");
+ }
+};
+
+// assert.AssertionError instanceof Error
+
+assert.AssertionError.__proto__ = Error.prototype;
+
+// At present only the three keys mentioned above are used and
+// understood by the spec. Implementations or sub modules can pass
+// other keys to the AssertionError's constructor - they will be
+// ignored.
+
+// 3. All of the following functions must throw an AssertionError
+// when a corresponding condition is not met, with a message that
+// may be undefined if not provided. All assertion methods provide
+// both the actual and expected values to the assertion error for
+// display purposes.
+
+function fail(actual, expected, message, operator, stackStartFunction) {
+ throw new assert.AssertionError({
+ message: message,
+ actual: actual,
+ expected: expected,
+ operator: operator,
+ stackStartFunction: stackStartFunction
+ });
+}
+
+// EXTENSION! allows for well behaved errors defined elsewhere.
+assert.fail = fail;
+
+// 4. Pure assertion tests whether a value is truthy, as determined
+// by !!guard.
+// assert.ok(guard, message_opt);
+// This statement is equivalent to assert.equal(true, guard,
+// message_opt);. To test strictly for the value true, use
+// assert.strictEqual(true, guard, message_opt);.
+
+assert.ok = function ok(value, message) {
+ if (!!!value) fail(value, true, message, "==", assert.ok);
+};
+
+// 5. The equality assertion tests shallow, coercive equality with
+// ==.
+// assert.equal(actual, expected, message_opt);
+
+assert.equal = function equal(actual, expected, message) {
+ if (actual != expected) fail(actual, expected, message, "==", assert.equal);
+};
+
+// 6. The non-equality assertion tests for whether two objects are not equal
+// with != assert.notEqual(actual, expected, message_opt);
+
+assert.notEqual = function notEqual(actual, expected, message) {
+ if (actual == expected) {
+ fail(actual, expected, message, "!=", assert.notEqual);
+ }
+};
+
+// 7. The equivalence assertion tests a deep equality relation.
+// assert.deepEqual(actual, expected, message_opt);
+
+assert.deepEqual = function deepEqual(actual, expected, message) {
+ if (!_deepEqual(actual, expected)) {
+ fail(actual, expected, message, "deepEqual", assert.deepEqual);
+ }
+};
+
+function _deepEqual(actual, expected) {
+ // 7.1. All identical values are equivalent, as determined by ===.
+ if (actual === expected) {
+ return true;
+
+ } else if (Buffer.isBuffer(actual) && Buffer.isBuffer(expected)) {
+ if (actual.length != expected.length) return false;
+
+ for (var i = 0; i < actual.length; i++) {
+ if (actual[i] !== expected[i]) return false;
+ }
+
+ return true;
+
+ // 7.2. If the expected value is a Date object, the actual value is
+ // equivalent if it is also a Date object that refers to the same time.
+ } else if (actual instanceof Date && expected instanceof Date) {
+ return actual.getTime() === expected.getTime();
+
+ // 7.3. Other pairs that do not both pass typeof value == "object",
+ // equivalence is determined by ==.
+ } else if (typeof actual != 'object' && typeof expected != 'object') {
+ return actual == expected;
+
+ // 7.4. For all other Object pairs, including Array objects, equivalence is
+ // determined by having the same number of owned properties (as verified
+ // with Object.prototype.hasOwnProperty.call), the same set of keys
+ // (although not necessarily the same order), equivalent values for every
+ // corresponding key, and an identical "prototype" property. Note: this
+ // accounts for both named and indexed properties on Arrays.
+ } else {
+ return objEquiv(actual, expected);
+ }
+}
+
+function isUndefinedOrNull (value) {
+ return value === null || value === undefined;
+}
+
+function isArguments (object) {
+ return Object.prototype.toString.call(object) == '[object Arguments]';
+}
+
+function objEquiv (a, b) {
+ if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
+ return false;
+ // an identical "prototype" property.
+ if (a.prototype !== b.prototype) return false;
+ //~~~I've managed to break Object.keys through screwy arguments passing.
+ // Converting to array solves the problem.
+ if (isArguments(a)) {
+ if (!isArguments(b)) {
+ return false;
+ }
+ a = pSlice.call(a);
+ b = pSlice.call(b);
+ return _deepEqual(a, b);
+ }
+ try{
+ var ka = _keys(a),
+ kb = _keys(b),
+ key, i;
+ } catch (e) {//happens when one is a string literal and the other isn't
+ return false;
+ }
+ // having the same number of owned properties (keys incorporates hasOwnProperty)
+ if (ka.length != kb.length)
+ return false;
+ //the same set of keys (although not necessarily the same order),
+ ka.sort();
+ kb.sort();
+ //~~~cheap key test
+ for (i = ka.length - 1; i >= 0; i--) {
+ if (ka[i] != kb[i])
+ return false;
+ }
+ //equivalent values for every corresponding key, and
+ //~~~possibly expensive deep test
+ for (i = ka.length - 1; i >= 0; i--) {
+ key = ka[i];
+ if (!_deepEqual(a[key], b[key] ))
+ return false;
+ }
+ return true;
+}
+
+// 8. The non-equivalence assertion tests for any deep inequality.
+// assert.notDeepEqual(actual, expected, message_opt);
+
+assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+ if (_deepEqual(actual, expected)) {
+ fail(actual, expected, message, "notDeepEqual", assert.notDeepEqual);
+ }
+};
+
+// 9. The strict equality assertion tests strict equality, as determined by ===.
+// assert.strictEqual(actual, expected, message_opt);
+
+assert.strictEqual = function strictEqual(actual, expected, message) {
+ if (actual !== expected) {
+ fail(actual, expected, message, "===", assert.strictEqual);
+ }
+};
+
+// 10. The strict non-equality assertion tests for strict inequality, as determined by !==.
+// assert.notStrictEqual(actual, expected, message_opt);
+
+assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+ if (actual === expected) {
+ fail(actual, expected, message, "!==", assert.notStrictEqual);
+ }
+};
+
+function _throws (shouldThrow, block, err, message) {
+ var exception = null,
+ threw = false,
+ typematters = true;
+
+ message = message || "";
+
+ //handle optional arguments
+ if (arguments.length == 3) {
+ if (typeof(err) == "string") {
+ message = err;
+ typematters = false;
+ }
+ } else if (arguments.length == 2) {
+ typematters = false;
+ }
+
+ try {
+ block();
+ } catch (e) {
+ threw = true;
+ exception = e;
+ }
+
+ if (shouldThrow && !threw) {
+ fail( "Missing expected exception"
+ + (err && err.name ? " ("+err.name+")." : '.')
+ + (message ? " " + message : "")
+ );
+ }
+ if (!shouldThrow && threw && typematters && exception instanceof err) {
+ fail( "Got unwanted exception"
+ + (err && err.name ? " ("+err.name+")." : '.')
+ + (message ? " " + message : "")
+ );
+ }
+ if ((shouldThrow && threw && typematters && !(exception instanceof err)) ||
+ (!shouldThrow && threw)) {
+ throw exception;
+ }
+};
+
+// 11. Expected to throw an error:
+// assert.throws(block, Error_opt, message_opt);
+
+assert.throws = function(block, /*optional*/error, /*optional*/message) {
+ _throws.apply(this, [true].concat(pSlice.call(arguments)));
+};
+
+// EXTENSION! This is annoying to write outside this module.
+assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {
+ _throws.apply(this, [false].concat(pSlice.call(arguments)));
+};
+
+assert.ifError = function (err) { if (err) {throw err;}};
+})(assert);
+(function(exports){
+/*!
+ * Nodeunit
+ * Copyright (c) 2010 Caolan McMahon
+ * MIT Licensed
+ *
+ * THIS FILE SHOULD BE BROWSER-COMPATIBLE JS!
+ * Only code on that line will be removed, its mostly to avoid requiring code
+ * that is node specific
+ */
+
+/**
+ * Module dependencies
+ */
+
+
+
+/**
+ * Creates assertion objects representing the result of an assert call.
+ * Accepts an object or AssertionError as its argument.
+ *
+ * @param {object} obj
+ * @api public
+ */
+
+exports.assertion = function (obj) {
+ return {
+ method: obj.method || '',
+ message: obj.message || (obj.error && obj.error.message) || '',
+ error: obj.error,
+ passed: function () {
+ return !this.error;
+ },
+ failed: function () {
+ return Boolean(this.error);
+ }
+ };
+};
+
+/**
+ * Creates an assertion list object representing a group of assertions.
+ * Accepts an array of assertion objects.
+ *
+ * @param {Array} arr
+ * @param {Number} duration
+ * @api public
+ */
+
+exports.assertionList = function (arr, duration) {
+ var that = arr || [];
+ that.failures = function () {
+ var failures = 0;
+ for (var i=0; i';
+};
+
+
+/**
+ * Run all tests within each module, reporting the results
+ *
+ * @param {Array} files
+ * @api public
+ */
+
+exports.run = function (modules, options) {
+ var start = new Date().getTime();
+ exports.addStyles();
+
+ var html = '';
+ nodeunit.runModules(modules, {
+ moduleStart: function (name) {
+ html += '' + name + '
';
+ html += '';
+ },
+ testDone: function (name, assertions) {
+ if (!assertions.failures()) {
+ html += '- ' + name + '
';
+ }
+ else {
+ html += '- ' + name;
+ for (var i=0; i
';
+ }
+ html += '';
+ html += a.error.stack || a.error;
+ html += '
';
+ }
+ };
+ html += ' ';
+ }
+ },
+ moduleDone: function () {
+ html += '
';
+ },
+ done: function (assertions) {
+ var end = new Date().getTime();
+ var duration = end - start;
+ if (assertions.failures()) {
+ html += 'FAILURES: ' + assertions.failures() +
+ '/' + assertions.length + ' assertions failed (' +
+ assertions.duration + 'ms)
';
+ }
+ else {
+ html += 'OK: ' + assertions.length +
+ ' assertions (' + assertions.duration + 'ms)
';
+ }
+ document.body.innerHTML += html;
+ }
+ });
+};
+})(reporter);
+nodeunit = core;
+nodeunit.assert = assert;
+nodeunit.reporter = reporter;
+nodeunit.run = reporter.run;
+return nodeunit; })();
diff --git a/bin/node_modules/nodeunit/examples/browser/suite1.js b/bin/node_modules/nodeunit/examples/browser/suite1.js
new file mode 100644
index 00000000..0d5fc90e
--- /dev/null
+++ b/bin/node_modules/nodeunit/examples/browser/suite1.js
@@ -0,0 +1,12 @@
+this.suite1 = {
+ 'test one': function (test) {
+ test.ok(true, 'everythings ok');
+ setTimeout(function () {
+ test.done();
+ }, 10);
+ },
+ 'apples and oranges': function (test) {
+ test.equal('apples', 'oranges', 'comparing apples and oranges');
+ test.done();
+ }
+};
diff --git a/bin/node_modules/nodeunit/examples/browser/suite2.js b/bin/node_modules/nodeunit/examples/browser/suite2.js
new file mode 100644
index 00000000..c7288e8d
--- /dev/null
+++ b/bin/node_modules/nodeunit/examples/browser/suite2.js
@@ -0,0 +1,13 @@
+this.suite2 = {
+ 'another test': function (test) {
+ setTimeout(function () {
+ // lots of assertions
+ test.ok(true, 'everythings ok');
+ test.ok(true, 'everythings ok');
+ test.ok(true, 'everythings ok');
+ test.ok(true, 'everythings ok');
+ test.ok(true, 'everythings ok');
+ test.done();
+ }, 10);
+ }
+};
diff --git a/bin/node_modules/nodeunit/examples/browser/test.html b/bin/node_modules/nodeunit/examples/browser/test.html
new file mode 100644
index 00000000..e9f8180f
--- /dev/null
+++ b/bin/node_modules/nodeunit/examples/browser/test.html
@@ -0,0 +1,16 @@
+
+
+ Example tests
+
+
+
+
+
+
+
+
diff --git a/bin/node_modules/nodeunit/img/example_fail.png b/bin/node_modules/nodeunit/img/example_fail.png
new file mode 100644
index 00000000..78ff4258
Binary files /dev/null and b/bin/node_modules/nodeunit/img/example_fail.png differ
diff --git a/bin/node_modules/nodeunit/img/example_pass.png b/bin/node_modules/nodeunit/img/example_pass.png
new file mode 100644
index 00000000..069d7169
Binary files /dev/null and b/bin/node_modules/nodeunit/img/example_pass.png differ
diff --git a/bin/node_modules/nodeunit/index.js b/bin/node_modules/nodeunit/index.js
new file mode 100644
index 00000000..07867d01
--- /dev/null
+++ b/bin/node_modules/nodeunit/index.js
@@ -0,0 +1,3 @@
+// This file is just added for convenience so this repository can be
+// directly checked out into a project's deps folder
+module.exports = require('./lib/nodeunit');
diff --git a/bin/node_modules/nodeunit/lib/assert.js b/bin/node_modules/nodeunit/lib/assert.js
new file mode 100644
index 00000000..8d9e0e3c
--- /dev/null
+++ b/bin/node_modules/nodeunit/lib/assert.js
@@ -0,0 +1,316 @@
+/**
+ * This file is based on the node.js assert module, but with some small
+ * changes for browser-compatibility
+ * THIS FILE SHOULD BE BROWSER-COMPATIBLE JS!
+ */
+
+
+/**
+ * Added for browser compatibility
+ */
+
+var _keys = function(obj){
+ if(Object.keys) return Object.keys(obj);
+ var keys = [];
+ for(var k in obj){
+ if(obj.hasOwnProperty(k)) keys.push(k);
+ }
+ return keys;
+};
+
+
+
+// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
+//
+// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
+//
+// Originally from narwhal.js (http://narwhaljs.org)
+// Copyright (c) 2009 Thomas Robinson <280north.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the 'Software'), to
+// deal in the Software without restriction, including without limitation the
+// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+// sell copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+var pSlice = Array.prototype.slice;
+
+// 1. The assert module provides functions that throw
+// AssertionError's when particular conditions are not met. The
+// assert module must conform to the following interface.
+
+var assert = exports;
+
+// 2. The AssertionError is defined in assert.
+// new assert.AssertionError({message: message, actual: actual, expected: expected})
+
+assert.AssertionError = function AssertionError (options) {
+ this.name = "AssertionError";
+ this.message = options.message;
+ this.actual = options.actual;
+ this.expected = options.expected;
+ this.operator = options.operator;
+ var stackStartFunction = options.stackStartFunction || fail;
+
+ if (Error.captureStackTrace) {
+ Error.captureStackTrace(this, stackStartFunction);
+ }
+};
+// code from util.inherits in node
+assert.AssertionError.super_ = Error;
+
+
+// EDITED FOR BROWSER COMPATIBILITY: replaced Object.create call
+// TODO: test what effect this may have
+var ctor = function () { this.constructor = assert.AssertionError; };
+ctor.prototype = Error.prototype;
+assert.AssertionError.prototype = new ctor();
+
+
+assert.AssertionError.prototype.toString = function() {
+ if (this.message) {
+ return [this.name+":", this.message].join(' ');
+ } else {
+ return [ this.name+":"
+ , JSON.stringify(this.expected )
+ , this.operator
+ , JSON.stringify(this.actual)
+ ].join(" ");
+ }
+};
+
+// assert.AssertionError instanceof Error
+
+assert.AssertionError.__proto__ = Error.prototype;
+
+// At present only the three keys mentioned above are used and
+// understood by the spec. Implementations or sub modules can pass
+// other keys to the AssertionError's constructor - they will be
+// ignored.
+
+// 3. All of the following functions must throw an AssertionError
+// when a corresponding condition is not met, with a message that
+// may be undefined if not provided. All assertion methods provide
+// both the actual and expected values to the assertion error for
+// display purposes.
+
+function fail(actual, expected, message, operator, stackStartFunction) {
+ throw new assert.AssertionError({
+ message: message,
+ actual: actual,
+ expected: expected,
+ operator: operator,
+ stackStartFunction: stackStartFunction
+ });
+}
+
+// EXTENSION! allows for well behaved errors defined elsewhere.
+assert.fail = fail;
+
+// 4. Pure assertion tests whether a value is truthy, as determined
+// by !!guard.
+// assert.ok(guard, message_opt);
+// This statement is equivalent to assert.equal(true, guard,
+// message_opt);. To test strictly for the value true, use
+// assert.strictEqual(true, guard, message_opt);.
+
+assert.ok = function ok(value, message) {
+ if (!!!value) fail(value, true, message, "==", assert.ok);
+};
+
+// 5. The equality assertion tests shallow, coercive equality with
+// ==.
+// assert.equal(actual, expected, message_opt);
+
+assert.equal = function equal(actual, expected, message) {
+ if (actual != expected) fail(actual, expected, message, "==", assert.equal);
+};
+
+// 6. The non-equality assertion tests for whether two objects are not equal
+// with != assert.notEqual(actual, expected, message_opt);
+
+assert.notEqual = function notEqual(actual, expected, message) {
+ if (actual == expected) {
+ fail(actual, expected, message, "!=", assert.notEqual);
+ }
+};
+
+// 7. The equivalence assertion tests a deep equality relation.
+// assert.deepEqual(actual, expected, message_opt);
+
+assert.deepEqual = function deepEqual(actual, expected, message) {
+ if (!_deepEqual(actual, expected)) {
+ fail(actual, expected, message, "deepEqual", assert.deepEqual);
+ }
+};
+
+function _deepEqual(actual, expected) {
+ // 7.1. All identical values are equivalent, as determined by ===.
+ if (actual === expected) {
+ return true;
+ // 7.2. If the expected value is a Date object, the actual value is
+ // equivalent if it is also a Date object that refers to the same time.
+ } else if (actual instanceof Date && expected instanceof Date) {
+ return actual.getTime() === expected.getTime();
+
+ // 7.3. Other pairs that do not both pass typeof value == "object",
+ // equivalence is determined by ==.
+ } else if (typeof actual != 'object' && typeof expected != 'object') {
+ return actual == expected;
+
+ // 7.4. For all other Object pairs, including Array objects, equivalence is
+ // determined by having the same number of owned properties (as verified
+ // with Object.prototype.hasOwnProperty.call), the same set of keys
+ // (although not necessarily the same order), equivalent values for every
+ // corresponding key, and an identical "prototype" property. Note: this
+ // accounts for both named and indexed properties on Arrays.
+ } else {
+ return objEquiv(actual, expected);
+ }
+}
+
+function isUndefinedOrNull (value) {
+ return value === null || value === undefined;
+}
+
+function isArguments (object) {
+ return Object.prototype.toString.call(object) == '[object Arguments]';
+}
+
+function objEquiv (a, b) {
+ if (isUndefinedOrNull(a) || isUndefinedOrNull(b))
+ return false;
+ // an identical "prototype" property.
+ if (a.prototype !== b.prototype) return false;
+ //~~~I've managed to break Object.keys through screwy arguments passing.
+ // Converting to array solves the problem.
+ if (isArguments(a)) {
+ if (!isArguments(b)) {
+ return false;
+ }
+ a = pSlice.call(a);
+ b = pSlice.call(b);
+ return _deepEqual(a, b);
+ }
+ try{
+ var ka = _keys(a),
+ kb = _keys(b),
+ key, i;
+ } catch (e) {//happens when one is a string literal and the other isn't
+ return false;
+ }
+ // having the same number of owned properties (keys incorporates hasOwnProperty)
+ if (ka.length != kb.length)
+ return false;
+ //the same set of keys (although not necessarily the same order),
+ ka.sort();
+ kb.sort();
+ //~~~cheap key test
+ for (i = ka.length - 1; i >= 0; i--) {
+ if (ka[i] != kb[i])
+ return false;
+ }
+ //equivalent values for every corresponding key, and
+ //~~~possibly expensive deep test
+ for (i = ka.length - 1; i >= 0; i--) {
+ key = ka[i];
+ if (!_deepEqual(a[key], b[key] ))
+ return false;
+ }
+ return true;
+}
+
+// 8. The non-equivalence assertion tests for any deep inequality.
+// assert.notDeepEqual(actual, expected, message_opt);
+
+assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+ if (_deepEqual(actual, expected)) {
+ fail(actual, expected, message, "notDeepEqual", assert.notDeepEqual);
+ }
+};
+
+// 9. The strict equality assertion tests strict equality, as determined by ===.
+// assert.strictEqual(actual, expected, message_opt);
+
+assert.strictEqual = function strictEqual(actual, expected, message) {
+ if (actual !== expected) {
+ fail(actual, expected, message, "===", assert.strictEqual);
+ }
+};
+
+// 10. The strict non-equality assertion tests for strict inequality, as determined by !==.
+// assert.notStrictEqual(actual, expected, message_opt);
+
+assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+ if (actual === expected) {
+ fail(actual, expected, message, "!==", assert.notStrictEqual);
+ }
+};
+
+function _throws (shouldThrow, block, err, message) {
+ var exception = null,
+ threw = false,
+ typematters = true;
+
+ message = message || "";
+
+ //handle optional arguments
+ if (arguments.length == 3) {
+ if (typeof(err) == "string") {
+ message = err;
+ typematters = false;
+ }
+ } else if (arguments.length == 2) {
+ typematters = false;
+ }
+
+ try {
+ block();
+ } catch (e) {
+ threw = true;
+ exception = e;
+ }
+
+ if (shouldThrow && !threw) {
+ fail( "Missing expected exception"
+ + (err && err.name ? " ("+err.name+")." : '.')
+ + (message ? " " + message : "")
+ );
+ }
+ if (!shouldThrow && threw && typematters && exception instanceof err) {
+ fail( "Got unwanted exception"
+ + (err && err.name ? " ("+err.name+")." : '.')
+ + (message ? " " + message : "")
+ );
+ }
+ if ((shouldThrow && threw && typematters && !(exception instanceof err)) ||
+ (!shouldThrow && threw)) {
+ throw exception;
+ }
+};
+
+// 11. Expected to throw an error:
+// assert.throws(block, Error_opt, message_opt);
+
+assert.throws = function(block, /*optional*/error, /*optional*/message) {
+ _throws.apply(this, [true].concat(pSlice.call(arguments)));
+};
+
+// EXTENSION! This is annoying to write outside this module.
+assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {
+ _throws.apply(this, [false].concat(pSlice.call(arguments)));
+};
+
+assert.ifError = function (err) { if (err) {throw err;}};
diff --git a/bin/node_modules/nodeunit/lib/core.js b/bin/node_modules/nodeunit/lib/core.js
new file mode 100644
index 00000000..5be8e8f1
--- /dev/null
+++ b/bin/node_modules/nodeunit/lib/core.js
@@ -0,0 +1,260 @@
+/*!
+ * Nodeunit
+ * Copyright (c) 2010 Caolan McMahon
+ * MIT Licensed
+ *
+ * THIS FILE SHOULD BE BROWSER-COMPATIBLE JS!
+ * You can use @REMOVE_LINE_FOR_BROWSER to remove code from the browser build.
+ * Only code on that line will be removed, its mostly to avoid requiring code
+ * that is node specific
+ */
+
+/**
+ * Module dependencies
+ */
+
+var async = require('../deps/async'), //@REMOVE_LINE_FOR_BROWSER
+ types = require('./types'); //@REMOVE_LINE_FOR_BROWSER
+
+
+/**
+ * Added for browser compatibility
+ */
+
+var _keys = function(obj){
+ if(Object.keys) return Object.keys(obj);
+ var keys = [];
+ for(var k in obj){
+ if(obj.hasOwnProperty(k)) keys.push(k);
+ }
+ return keys;
+};
+
+
+var _copy = function(obj){
+ var nobj = Object();
+ var keys = _keys(obj);
+ for (var i = 0; i < keys.length; i++){
+ nobj[keys[i]] = obj[keys[i]];
+ }
+ return nobj;
+}
+
+
+/**
+ * Runs a test function (fn) from a loaded module. After the test function
+ * calls test.done(), the callback is executed with an assertionList as its
+ * second argument.
+ *
+ * @param {String} name
+ * @param {Function} fn
+ * @param {Object} opt
+ * @param {Function} callback
+ * @api public
+ */
+
+exports.runTest = function (name, fn, opt, callback) {
+ var options = types.options(opt);
+
+ options.testStart(name);
+ var start = new Date().getTime();
+ var test = types.test(name, start, options, callback);
+
+ try {
+ fn(test);
+ }
+ catch (e) {
+ test.done(e);
+ }
+};
+
+/**
+ * Takes an object containing test functions or other test suites as properties
+ * and runs each in series. After all tests have completed, the callback is
+ * called with a list of all assertions as the second argument.
+ *
+ * If a name is passed to this function it is prepended to all test and suite
+ * names that run within it.
+ *
+ * @param {String} name
+ * @param {Object} suite
+ * @param {Object} opt
+ * @param {Function} callback
+ * @api public
+ */
+
+exports.runSuite = function (name, suite, opt, callback) {
+ var keys = _keys(suite);
+
+ async.concatSeries(keys, function (k, cb) {
+ var prop = suite[k], _name;
+
+ _name = name ? [].concat(name, k) : [k];
+
+ _name.toString = function () {
+ // fallback for old one
+ return this.join(' - ');
+ };
+
+ if (typeof prop === 'function') {
+ if (!opt.testspec || _name.indexOf(opt.testspec) != -1){
+ if (opt.moduleStart)
+ opt.moduleStart();
+ exports.runTest(_name, suite[k], opt, cb);
+ } else
+ return cb();
+ }
+ else {
+ exports.runSuite(_name, suite[k], opt, cb);
+ }
+ }, callback);
+};
+
+/**
+ * Run each exported test function or test suite from a loaded module.
+ *
+ * @param {String} name
+ * @param {Object} mod
+ * @param {Object} opt
+ * @param {Function} callback
+ * @api public
+ */
+
+exports.runModule = function (name, mod, opt, callback) {
+ var options = _copy(types.options(opt));
+
+ var _run = false;
+ var _moduleStart = options.moduleStart;
+ function run_once(){
+ if (!_run){
+ _run = true;
+ _moduleStart(name);
+ }
+ }
+ options.moduleStart = run_once;
+
+ var start = new Date().getTime();
+
+ exports.runSuite(null, mod, options, function (err, a_list) {
+ var end = new Date().getTime();
+ var assertion_list = types.assertionList(a_list, end - start);
+ options.moduleDone(name, assertion_list);
+ callback(null, a_list);
+ });
+};
+
+/**
+ * Treats an object literal as a list of modules keyed by name. Runs each
+ * module and finished with calling 'done'. You can think of this as a browser
+ * safe alternative to runFiles in the nodeunit module.
+ *
+ * @param {Object} modules
+ * @param {Object} opt
+ * @api public
+ */
+
+// TODO: add proper unit tests for this function
+exports.runModules = function (modules, opt) {
+ var all_assertions = [];
+ var options = types.options(opt);
+ var start = new Date().getTime();
+
+ async.concatSeries(_keys(modules), function (k, cb) {
+ exports.runModule(k, modules[k], options, cb);
+ },
+ function (err, all_assertions) {
+ var end = new Date().getTime();
+ options.done(types.assertionList(all_assertions, end - start));
+ });
+};
+
+
+/**
+ * Wraps a test function with setUp and tearDown functions.
+ * Used by testCase.
+ *
+ * @param {Function} setUp
+ * @param {Function} tearDown
+ * @param {Function} fn
+ * @api private
+ */
+
+var wrapTest = function (setUp, tearDown, fn) {
+ return function (test) {
+ var context = {};
+ if (tearDown) {
+ var done = test.done;
+ test.done = function (err) {
+ try {
+ tearDown.call(context, function (err2) {
+ if (err && err2) {
+ test._assertion_list.push(
+ types.assertion({error: err})
+ );
+ return done(err2);
+ }
+ done(err || err2);
+ });
+ }
+ catch (e) {
+ done(e);
+ }
+ };
+ }
+ if (setUp) {
+ setUp.call(context, function (err) {
+ if (err) {
+ return test.done(err);
+ }
+ fn.call(context, test);
+ });
+ }
+ else {
+ fn.call(context, test);
+ }
+ }
+};
+
+
+/**
+ * Wraps a group of tests with setUp and tearDown functions.
+ * Used by testCase.
+ *
+ * @param {Function} setUp
+ * @param {Function} tearDown
+ * @param {Object} group
+ * @api private
+ */
+
+var wrapGroup = function (setUp, tearDown, group) {
+ var tests = {};
+ var keys = _keys(group);
+ for (var i=0; i(' +
+ '' + assertions.failures() + ', ' +
+ '' + assertions.passes() + ', ' +
+ assertions.length +
+ ')';
+ test.className = assertions.failures() ? 'fail': 'pass';
+ test.appendChild(strong);
+
+ var aList = document.createElement('ol');
+ aList.style.display = 'none';
+ test.onclick = function () {
+ var d = aList.style.display;
+ aList.style.display = (d == 'none') ? 'block': 'none';
+ };
+ for (var i=0; i' + (a.error.stack || a.error) + '';
+ li.className = 'fail';
+ }
+ else {
+ li.innerHTML = a.message || a.method || 'no message';
+ li.className = 'pass';
+ }
+ aList.appendChild(li);
+ }
+ test.appendChild(aList);
+ tests.appendChild(test);
+ },
+ done: function (assertions) {
+ var end = new Date().getTime();
+ var duration = end - start;
+
+ var failures = assertions.failures();
+ banner.className = failures ? 'fail': 'pass';
+
+ result.innerHTML = 'Tests completed in ' + duration +
+ ' milliseconds.
' +
+ assertions.passes() + ' assertions of ' +
+ '' + assertions.length + ' passed, ' +
+ assertions.failures() + ' failed.';
+ }
+ });
+};
diff --git a/bin/node_modules/nodeunit/lib/reporters/default.js b/bin/node_modules/nodeunit/lib/reporters/default.js
new file mode 100644
index 00000000..279f5607
--- /dev/null
+++ b/bin/node_modules/nodeunit/lib/reporters/default.js
@@ -0,0 +1,123 @@
+/*!
+ * Nodeunit
+ * Copyright (c) 2010 Caolan McMahon
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies
+ */
+
+var nodeunit = require('../nodeunit'),
+ utils = require('../utils'),
+ fs = require('fs'),
+ track = require('../track'),
+ path = require('path');
+ AssertionError = require('../assert').AssertionError;
+
+/**
+ * Reporter info string
+ */
+
+exports.info = "Default tests reporter";
+
+
+/**
+ * Run all tests within each module, reporting the results to the command-line.
+ *
+ * @param {Array} files
+ * @api public
+ */
+
+exports.run = function (files, options) {
+
+ if (!options) {
+ // load default options
+ var content = fs.readFileSync(
+ __dirname + '/../../bin/nodeunit.json', 'utf8'
+ );
+ options = JSON.parse(content);
+ }
+
+ var error = function (str) {
+ return options.error_prefix + str + options.error_suffix;
+ };
+ var ok = function (str) {
+ return options.ok_prefix + str + options.ok_suffix;
+ };
+ var bold = function (str) {
+ return options.bold_prefix + str + options.bold_suffix;
+ };
+ var assertion_message = function (str) {
+ return options.assertion_prefix + str + options.assertion_suffix;
+ };
+
+ var start = new Date().getTime();
+ var paths = files.map(function (p) {
+ return path.join(process.cwd(), p);
+ });
+ var tracker = track.createTracker(function (tracker) {
+ if (tracker.unfinished()) {
+ console.log('');
+ console.log(error(bold(
+ 'FAILURES: Undone tests (or their setups/teardowns): '
+ )));
+ var names = tracker.names();
+ for (var i = 0; i < names.length; i += 1) {
+ console.log('- ' + names[i]);
+ }
+ console.log('');
+ console.log('To fix this, make sure all tests call test.done()');
+ process.reallyExit(tracker.unfinished());
+ }
+ });
+
+ nodeunit.runFiles(paths, {
+ testspec: options.testspec,
+ moduleStart: function (name) {
+ console.log('\n' + bold(name));
+ },
+ testDone: function (name, assertions) {
+ tracker.remove(name);
+
+ if (!assertions.failures()) {
+ console.log('✔ ' + name);
+ }
+ else {
+ console.log(error('✖ ' + name) + '\n');
+ assertions.forEach(function (a) {
+ if (a.failed()) {
+ a = utils.betterErrors(a);
+ if (a.error instanceof AssertionError && a.message) {
+ console.log(
+ 'Assertion Message: ' +
+ assertion_message(a.message)
+ );
+ }
+ console.log(a.error.stack + '\n');
+ }
+ });
+ }
+ },
+ done: function (assertions, end) {
+ var end = end || new Date().getTime();
+ var duration = end - start;
+ if (assertions.failures()) {
+ console.log(
+ '\n' + bold(error('FAILURES: ')) + assertions.failures() +
+ '/' + assertions.length + ' assertions failed (' +
+ assertions.duration + 'ms)'
+ );
+ }
+ else {
+ console.log(
+ '\n' + bold(ok('OK: ')) + assertions.length +
+ ' assertions (' + assertions.duration + 'ms)'
+ );
+ }
+ },
+ testStart: function(name) {
+ tracker.put(name);
+ }
+ });
+};
diff --git a/bin/node_modules/nodeunit/lib/reporters/html.js b/bin/node_modules/nodeunit/lib/reporters/html.js
new file mode 100644
index 00000000..05fb4036
--- /dev/null
+++ b/bin/node_modules/nodeunit/lib/reporters/html.js
@@ -0,0 +1,107 @@
+/*!
+ * Nodeunit
+ * Copyright (c) 2010 Caolan McMahon
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies
+ */
+
+var nodeunit = require('../nodeunit'),
+ utils = require('../utils'),
+ fs = require('fs'),
+ path = require('path'),
+ AssertionError = require('assert').AssertionError;
+
+/**
+ * Reporter info string
+ */
+
+exports.info = "Report tests result as HTML";
+
+/**
+ * Run all tests within each module, reporting the results to the command-line.
+ *
+ * @param {Array} files
+ * @api public
+ */
+
+exports.run = function (files, options) {
+
+ var start = new Date().getTime();
+ var paths = files.map(function (p) {
+ return path.join(process.cwd(), p);
+ });
+
+ console.log('');
+ console.log('');
+ console.log('' + name + '
');
+ console.log('');
+ },
+ testDone: function (name, assertions) {
+ if (!assertions.failures()) {
+ console.log('- ' + name + '
');
+ }
+ else {
+ console.log('- ' + name);
+ assertions.forEach(function (a) {
+ if (a.failed()) {
+ a = utils.betterErrors(a);
+ if (a.error instanceof AssertionError && a.message) {
+ console.log('');
+ }
+ console.log('
');
+ console.log(a.error.stack);
+ console.log('');
+ }
+ });
+ console.log(' ');
+ }
+ },
+ moduleDone: function () {
+ console.log('
');
+ },
+ done: function (assertions) {
+ var end = new Date().getTime();
+ var duration = end - start;
+ if (assertions.failures()) {
+ console.log(
+ 'FAILURES: ' + assertions.failures() +
+ '/' + assertions.length + ' assertions failed (' +
+ assertions.duration + 'ms)
'
+ );
+ }
+ else {
+ console.log(
+ 'OK: ' + assertions.length +
+ ' assertions (' + assertions.duration + 'ms)
'
+ );
+ }
+ console.log('');
+ }
+ });
+
+};
diff --git a/bin/node_modules/nodeunit/lib/reporters/index.js b/bin/node_modules/nodeunit/lib/reporters/index.js
new file mode 100644
index 00000000..bbaf800d
--- /dev/null
+++ b/bin/node_modules/nodeunit/lib/reporters/index.js
@@ -0,0 +1,9 @@
+module.exports = {
+ 'junit': require('./junit'),
+ 'default': require('./default'),
+ 'skip_passed': require('./skip_passed'),
+ 'minimal': require('./minimal'),
+ 'html': require('./html')
+ // browser test reporter is not listed because it cannot be used
+ // with the command line tool, only inside a browser.
+};
diff --git a/bin/node_modules/nodeunit/lib/reporters/junit.js b/bin/node_modules/nodeunit/lib/reporters/junit.js
new file mode 100644
index 00000000..a542c695
--- /dev/null
+++ b/bin/node_modules/nodeunit/lib/reporters/junit.js
@@ -0,0 +1,183 @@
+/*!
+ * Nodeunit
+ * Copyright (c) 2010 Caolan McMahon
+ * MIT Licensed
+ */
+
+/**
+ * Module dependencies
+ */
+
+var nodeunit = require('../nodeunit'),
+ utils = require('../utils'),
+ fs = require('fs'),
+ path = require('path'),
+ async = require('../../deps/async'),
+ AssertionError = require('assert').AssertionError,
+ child_process = require('child_process'),
+ ejs = require('../../deps/ejs');
+
+
+/**
+ * Reporter info string
+ */
+
+exports.info = "jUnit XML test reports";
+
+
+/**
+ * Ensures a directory exists using mkdir -p.
+ *
+ * @param {String} path
+ * @param {Function} callback
+ * @api private
+ */
+
+var ensureDir = function (path, callback) {
+ var mkdir = child_process.spawn('mkdir', ['-p', path]);
+ mkdir.on('error', function (err) {
+ callback(err);
+ callback = function(){};
+ });
+ mkdir.on('exit', function (code) {
+ if (code === 0) callback();
+ else callback(new Error('mkdir exited with code: ' + code));
+ });
+};
+
+
+/**
+ * Returns absolute version of a path. Relative paths are interpreted
+ * relative to process.cwd() or the cwd parameter. Paths that are already
+ * absolute are returned unaltered.
+ *
+ * @param {String} p
+ * @param {String} cwd
+ * @return {String}
+ * @api public
+ */
+
+var abspath = function (p, /*optional*/cwd) {
+ if (p[0] === '/') return p;
+ cwd = cwd || process.cwd();
+ return path.normalize(path.join(cwd, p));
+};
+
+
+/**
+ * Run all tests within each module, reporting the results to the command-line,
+ * then writes out junit-compatible xml documents.
+ *
+ * @param {Array} files
+ * @api public
+ */
+
+exports.run = function (files, opts, callback) {
+ if (!opts.output) {
+ console.error(
+ 'Error: No output directory defined.\n' +
+ '\tEither add an "output" property to your nodeunit.json config ' +
+ 'file, or\n\tuse the --output command line option.'
+ );
+ return;
+ }
+ opts.output = abspath(opts.output);
+ var error = function (str) {
+ return opts.error_prefix + str + opts.error_suffix;
+ };
+ var ok = function (str) {
+ return opts.ok_prefix + str + opts.ok_suffix;
+ };
+ var bold = function (str) {
+ return opts.bold_prefix + str + opts.bold_suffix;
+ };
+
+ var start = new Date().getTime();
+ var paths = files.map(function (p) {
+ return path.join(process.cwd(), p);
+ });
+
+ var modules = {}
+ var curModule;
+
+ nodeunit.runFiles(paths, {
+ testspec: opts.testspec,
+ moduleStart: function (name) {
+ curModule = {
+ errorCount: 0,
+ failureCount: 0,
+ tests: 0,
+ testcases: [],
+ name: name
+ };
+ modules[name] = curModule;
+ },
+ testDone: function (name, assertions) {
+ var testcase = {name: name};
+ for (var i=0; i [ \.\.\.]
+.
+.fi
+.
+.SH "DESCRIPTION"
+Nodeunit is a simple unit testing tool based on the node\.js assert module\.
+.
+.IP "\(bu" 4
+Simple to use
+.
+.IP "\(bu" 4
+Just export the tests from a module
+.
+.IP "\(bu" 4
+Helps you avoid common pitfalls when testing asynchronous code
+.
+.IP "\(bu" 4
+Easy to add test cases with setUp and tearDown functions if you wish
+.
+.IP "\(bu" 4
+Allows the use of mocks and stubs
+.
+.IP "" 0
+.
+.SH "OPTIONS"
+ \fB\-\-config FILE\fR:
+.
+.br
+ Load config options from a JSON file, allows the customisation
+ of color schemes for the default test reporter etc\.
+ See bin/nodeunit\.json for current available options\.
+.
+.P
+ \fB\-\-reporter FILE\fR:
+.
+.br
+ You can set the test reporter to a custom module or on of the modules
+ in nodeunit/lib/reporters, when omitted, the default test runner is used\.
+.
+.P
+ \fB\-\-list\-reporters\fR:
+.
+.br
+ List available build\-in reporters\.
+.
+.P
+ \fB\-h\fR, \fB\-\-help\fR:
+.
+.br
+ Display the help and exit\.
+.
+.P
+ \fB\-v\fR, \fB\-\-version\fR:
+.
+.br
+ Output version information and exit\.
+.
+.P
+ \fB\fR:
+ You can run nodeunit on specific files or on all \fI*\.js\fR files inside
+.
+.br
+ a directory\.
+.
+.SH "AUTHORS"
+Written by Caolan McMahon and other nodeunit contributors\.
+.
+.br
+Contributors list: \fIhttp://github\.com/caolan/nodeunit/contributors\fR\|\.
+.
+.SH "REPORTING BUGS"
+Report nodeunit bugs to \fIhttp://github\.com/caolan/nodeunit/issues\fR\|\.
+.
+.SH "COPYRIGHT"
+Copyright © 2010 Caolan McMahon\.
+.
+.br
+Nodeunit has been released under the MIT license:
+.
+.br
+\fIhttp://github\.com/caolan/nodeunit/raw/master/LICENSE\fR\|\.
+.
+.SH "SEE ALSO"
+node(1)
diff --git a/bin/node_modules/nodeunit/nodelint.cfg b/bin/node_modules/nodeunit/nodelint.cfg
new file mode 100644
index 00000000..457a967e
--- /dev/null
+++ b/bin/node_modules/nodeunit/nodelint.cfg
@@ -0,0 +1,4 @@
+var options = {
+ indent: 4,
+ onevar: false
+};
diff --git a/bin/node_modules/nodeunit/package.json b/bin/node_modules/nodeunit/package.json
new file mode 100644
index 00000000..63d723f8
--- /dev/null
+++ b/bin/node_modules/nodeunit/package.json
@@ -0,0 +1,56 @@
+{ "name": "nodeunit"
+, "description": "Easy unit testing for node.js and the browser."
+, "maintainers":
+ [ { "name": "Caolan McMahon"
+ , "web": "https://github.com/caolan"
+ }
+ ]
+, "contributors" :
+ [ { "name": "Alex Gorbatchev"
+ , "web": "https://github.com/alexgorbatchev"
+ }
+ , { "name": "Alex Wolfe"
+ , "web": "https://github.com/alexkwolfe"
+ }
+ , { "name": "Carl Fürstenberg"
+ , "web": "https://github.com/azatoth"
+ }
+ , { "name": "Gerad Suyderhoud"
+ , "web": "https://github.com/gerad"
+ }
+ , { "name": "Kadir Pekel"
+ , "web": "https://github.com/coffeemate"
+ }
+ , { "name": "Oleg Efimov"
+ , "web": "https://github.com/Sannis"
+ }
+ , { "name": "Orlando Vazquez"
+ , "web": "https://github.com/orlandov"
+ }
+ , { "name": "Ryan Dahl"
+ , "web": "https://github.com/ry"
+ }
+ , { "name": "Sam Stephenson"
+ , "web": "https://github.com/sstephenson"
+ }
+ , { "name": "Thomas Mayfield"
+ , "web": "https://github.com/thegreatape"
+ }
+ , { "name": "Elijah Insua ",
+ "web": "http://tmpvar.com"
+ }
+ ]
+, "version": "0.5.3"
+, "repository" :
+ { "type" : "git"
+ , "url" : "http://github.com/caolan/nodeunit.git"
+ }
+, "bugs" : { "web" : "http://github.com/caolan/nodeunit/issues" }
+, "licenses" :
+ [ { "type" : "MIT"
+ , "url" : "http://github.com/caolan/nodeunit/raw/master/LICENSE"
+ }
+ ]
+, "directories" : { "lib": "./lib", "doc" : "./doc", "man" : "./man1" }
+, "bin" : { "nodeunit" : "./bin/nodeunit" }
+}
diff --git a/bin/node_modules/nodeunit/share/junit.xml.ejs b/bin/node_modules/nodeunit/share/junit.xml.ejs
new file mode 100644
index 00000000..c1db5bbe
--- /dev/null
+++ b/bin/node_modules/nodeunit/share/junit.xml.ejs
@@ -0,0 +1,19 @@
+
+<% for (var i=0; i < suites.length; i++) { %>
+ <% var suite=suites[i]; %>
+
+ <% for (var j=0; j < suite.testcases.length; j++) { %>
+ <% var testcase=suites[i].testcases[j]; %>
+
+ <% if (testcase.failure) { %>
+
+ <% if (testcase.failure.backtrace) { %><%= testcase.failure.backtrace %><% } %>
+
+ <% } %>
+
+ <% } %>
+
+<% } %>
diff --git a/bin/node_modules/nodeunit/share/license.js b/bin/node_modules/nodeunit/share/license.js
new file mode 100644
index 00000000..f0f326f3
--- /dev/null
+++ b/bin/node_modules/nodeunit/share/license.js
@@ -0,0 +1,11 @@
+/*!
+ * Nodeunit
+ * https://github.com/caolan/nodeunit
+ * Copyright (c) 2010 Caolan McMahon
+ * MIT Licensed
+ *
+ * json2.js
+ * http://www.JSON.org/json2.js
+ * Public Domain.
+ * NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK.
+ */
diff --git a/bin/node_modules/nodeunit/share/nodeunit.css b/bin/node_modules/nodeunit/share/nodeunit.css
new file mode 100644
index 00000000..274434a4
--- /dev/null
+++ b/bin/node_modules/nodeunit/share/nodeunit.css
@@ -0,0 +1,70 @@
+/*!
+ * Styles taken from qunit.css
+ */
+
+h1#nodeunit-header, h1.nodeunit-header {
+ padding: 15px;
+ font-size: large;
+ background-color: #06b;
+ color: white;
+ font-family: 'trebuchet ms', verdana, arial;
+ margin: 0;
+}
+
+h1#nodeunit-header a {
+ color: white;
+}
+
+h2#nodeunit-banner {
+ height: 2em;
+ border-bottom: 1px solid white;
+ background-color: #eee;
+ margin: 0;
+ font-family: 'trebuchet ms', verdana, arial;
+}
+h2#nodeunit-banner.pass {
+ background-color: green;
+}
+h2#nodeunit-banner.fail {
+ background-color: red;
+}
+
+h2#nodeunit-userAgent, h2.nodeunit-userAgent {
+ padding: 10px;
+ background-color: #eee;
+ color: black;
+ margin: 0;
+ font-size: small;
+ font-weight: normal;
+ font-family: 'trebuchet ms', verdana, arial;
+ font-size: 10pt;
+}
+
+div#nodeunit-testrunner-toolbar {
+ background: #eee;
+ border-top: 1px solid black;
+ padding: 10px;
+ font-family: 'trebuchet ms', verdana, arial;
+ margin: 0;
+ font-size: 10pt;
+}
+
+ol#nodeunit-tests {
+ font-family: 'trebuchet ms', verdana, arial;
+ font-size: 10pt;
+}
+ol#nodeunit-tests li strong {
+ cursor:pointer;
+}
+ol#nodeunit-tests .pass {
+ color: green;
+}
+ol#nodeunit-tests .fail {
+ color: red;
+}
+
+p#nodeunit-testresult {
+ margin-left: 1em;
+ font-size: 10pt;
+ font-family: 'trebuchet ms', verdana, arial;
+}
diff --git a/bin/templates/project/.phonegap/android/readme.md b/bin/templates/project/.phonegap/android/readme.md
new file mode 100644
index 00000000..152f5a5f
--- /dev/null
+++ b/bin/templates/project/.phonegap/android/readme.md
@@ -0,0 +1 @@
+ok...
diff --git a/bin/templates/project/.phonegap/readme.md b/bin/templates/project/.phonegap/readme.md
new file mode 100644
index 00000000..7028aab8
--- /dev/null
+++ b/bin/templates/project/.phonegap/readme.md
@@ -0,0 +1,3 @@
+this is local config for phonegap stuff to be eventually moved to
+config.xml ...we think. feedback to @davejohnson/@brianleroux
+appreciated here!
diff --git a/bin/templates/project/phonegap/create b/bin/templates/project/phonegap/create
new file mode 100755
index 00000000..553a5b55
--- /dev/null
+++ b/bin/templates/project/phonegap/create
@@ -0,0 +1,36 @@
+#! /bin/sh
+#
+# create a phonegap/android project
+#
+# USAGE
+# ./create [path package activity]
+#
+
+# load up the config
+. ./.phonegap/config
+
+PACKAGE_AS_PATH=$(echo $PACKAGE | sed 's/\./\//g')
+ACTIVITY_PATH=./src/$PACKAGE_AS_PATH/$ACTIVITY.java
+MANIFEST_PATH=./AndroidManifest.xml
+
+# create the project
+android create project --target $TARGET --path . --package $PACKAGE --activity $ACTIVITY
+
+# copy all the phonegap scripts etc in there
+cp -R ./phonegap/templates/project/ .
+
+# copy in phonegap.js
+cp ./.phonegap/android/phonegap-$VERSION.js ./assets/www
+
+# copy in phonegap.jar
+cp ./.phonegap/android/phonegap-$VERSION.jar ./libs
+
+# copy in default activity
+cat ./phonegap/templates/Activity.java > $ACTIVITY_PATH
+
+# interpolate the acivity name and package
+find "$ACTIVITY_PATH" | xargs grep '__ACTIVITY__' -sl | xargs -L1 sed -i "" "s/__ACTIVITY__/${ACTIVITY}/g"
+find "$ACTIVITY_PATH" | xargs grep '__ID__' -sl | xargs -L1 sed -i "" "s/__ID__/${PACKAGE}/g"
+
+find "$MANIFEST_PATH" | xargs grep '__ACTIVITY__' -sl | xargs -L1 sed -i "" "s/__ACTIVITY__/${ACTIVITY}/g"
+find "$MANIFEST_PATH" | xargs grep '__PACKAGE__' -sl | xargs -L1 sed -i "" "s/__PACKAGE__/${PACKAGE}/g"
diff --git a/bin/templates/project/phonegap/debug b/bin/templates/project/phonegap/debug
new file mode 100755
index 00000000..bfa3df1c
--- /dev/null
+++ b/bin/templates/project/phonegap/debug
@@ -0,0 +1,9 @@
+#! /bin/sh
+
+. ./.phonegap/config
+
+# if there are no devices listed then emulate
+
+
+ant debug install
+adb shell am start -n $PACKAGE/$PACKAGE.$ACTIVITY
diff --git a/bin/templates/project/phonegap/emulate b/bin/templates/project/phonegap/emulate
new file mode 100755
index 00000000..21d7b9c4
--- /dev/null
+++ b/bin/templates/project/phonegap/emulate
@@ -0,0 +1,12 @@
+#! /bin/sh
+
+#Available Android Virtual Devices:
+# Name: default
+# Path: /Users/davejohnson/.android/avd/default.avd
+# Target: Android 2.2 (API level 8)
+# Skin: WVGA800
+# Sdcard: 100M
+
+# get the name of the first virtual device or use command line arg or use "default"
+
+emulator -cpu-delay 0 -no-boot-anim -cache ./tmp/cache -avd default > /dev/null 2>&1 & # put the avd's chatty ass in the background
\ No newline at end of file
diff --git a/bin/templates/project/phonegap/log b/bin/templates/project/phonegap/log
new file mode 100755
index 00000000..2ff1e3ab
--- /dev/null
+++ b/bin/templates/project/phonegap/log
@@ -0,0 +1,3 @@
+#! /bin/sh
+
+adb logcat
diff --git a/bin/templates/project/phonegap/templates/Activity.java b/bin/templates/project/phonegap/templates/Activity.java
new file mode 100644
index 00000000..54e27070
--- /dev/null
+++ b/bin/templates/project/phonegap/templates/Activity.java
@@ -0,0 +1,16 @@
+package __ID__;
+
+import android.app.Activity;
+import android.os.Bundle;
+import com.phonegap.*;
+
+public class __ACTIVITY__ extends DroidGap
+{
+ @Override
+ public void onCreate(Bundle savedInstanceState)
+ {
+ super.onCreate(savedInstanceState);
+ super.loadUrl("file:///android_asset/www/index.html");
+ }
+}
+
diff --git a/bin/templates/project/phonegap/templates/project/AndroidManifest.xml b/bin/templates/project/phonegap/templates/project/AndroidManifest.xml
new file mode 100644
index 00000000..2269f379
--- /dev/null
+++ b/bin/templates/project/phonegap/templates/project/AndroidManifest.xml
@@ -0,0 +1,50 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/example/index.html b/bin/templates/project/phonegap/templates/project/assets/www/index.html
similarity index 100%
rename from example/index.html
rename to bin/templates/project/phonegap/templates/project/assets/www/index.html
diff --git a/example/main.js b/bin/templates/project/phonegap/templates/project/assets/www/main.js
similarity index 100%
rename from example/main.js
rename to bin/templates/project/phonegap/templates/project/assets/www/main.js
diff --git a/example/master.css b/bin/templates/project/phonegap/templates/project/assets/www/master.css
similarity index 100%
rename from example/master.css
rename to bin/templates/project/phonegap/templates/project/assets/www/master.css
diff --git a/bin/templates/project/phonegap/templates/project/res/xml/plugins.xml b/bin/templates/project/phonegap/templates/project/res/xml/plugins.xml
new file mode 100644
index 00000000..3d8d48d8
--- /dev/null
+++ b/bin/templates/project/phonegap/templates/project/res/xml/plugins.xml
@@ -0,0 +1,19 @@
+
+
+
\ No newline at end of file
diff --git a/bin/test b/bin/test
new file mode 100755
index 00000000..185a90db
--- /dev/null
+++ b/bin/test
@@ -0,0 +1,23 @@
+#! /bin/sh
+set -e
+
+VERSION=$(cat ./VERSION)
+
+# get the latest mobile-spec
+git clone git@github.com:phonegap/mobile-spec.git
+
+# clobber test if it exists
+if [ -e ./test ]
+then
+ rm -rf ./test
+fi
+
+# generate a working proj
+./bin/create ./test com.phonegap.test PhoneGapTest
+
+# kill the default app and replace it w/ mobile-spec
+rm -rf ./test/assets/www
+mv ./mobile-spec ./test/assets/www
+
+# build it, launch it and start logging on stdout
+cd ./test && ./bin/debug && ./bin/log
diff --git a/bin/tests/autotest.coffee b/bin/tests/autotest.coffee
new file mode 100644
index 00000000..28479653
--- /dev/null
+++ b/bin/tests/autotest.coffee
@@ -0,0 +1,4 @@
+exports['you are sane'] = (test) ->
+ test.expect 1
+ test.ok true, "this assertion should always pass"
+ test.done()
diff --git a/bin/tests/create.coffee b/bin/tests/create.coffee
new file mode 100644
index 00000000..746e07b2
--- /dev/null
+++ b/bin/tests/create.coffee
@@ -0,0 +1,21 @@
+util = require 'util'
+exec = require('child_process').exec
+path = require 'path'
+
+exports['default example project is generated'] = (test) ->
+ test.expect 1
+ exec './bin/create', (error, stdout, stderr) ->
+ test.ok true, "this assertion should pass" unless error?
+ test.done()
+
+exports['default example project has a ./.phonegap folder'] = (test) ->
+ test.expect 1
+ path.exists './example/.phonegap', (exists) ->
+ test.ok exists, 'the phonegap folder exists'
+ test.done()
+
+exports['default example project has a /phonegap folder'] = (test) ->
+ test.expect 1
+ path.exists './example/phonegap', (exists) ->
+ test.ok exists, 'the other phonegap folder exists'
+ test.done()
diff --git a/bin/tests/debug.coffee b/bin/tests/debug.coffee
new file mode 100644
index 00000000..e69de29b
diff --git a/bin/tests/test.coffee b/bin/tests/test.coffee
new file mode 100644
index 00000000..e69de29b
diff --git a/framework/AndroidManifest.xml b/framework/AndroidManifest.xml
index 4bae9257..c0c6e090 100644
--- a/framework/AndroidManifest.xml
+++ b/framework/AndroidManifest.xml
@@ -5,10 +5,10 @@
android:largeScreens="true"
android:normalScreens="true"
android:smallScreens="true"
- android:xlargeScreens="true"
android:resizeable="true"
android:anyDensity="true"
/>
+
-
@@ -119,15 +119,15 @@
-
-
.", line, character);
- }
- character += 3;
- s = s.slice(i + 3);
- break;
- case '#':
- if (xmode === 'html' || xmode === 'styleproperty') {
- for (;;) {
- c = s.charAt(0);
- if ((c < '0' || c > '9') &&
- (c < 'a' || c > 'f') &&
- (c < 'A' || c > 'F')) {
- break;
- }
- character += 1;
- s = s.substr(1);
- t += c;
- }
- if (t.length !== 4 && t.length !== 7) {
- warningAt("Bad hex color '{a}'.", line,
- from + l, t);
- }
- return it('(color)', t);
- }
- return it('(punctuator)', t);
- default:
- if (xmode === 'outer' && c === '&') {
- character += 1;
- s = s.substr(1);
- for (;;) {
- c = s.charAt(0);
- character += 1;
- s = s.substr(1);
- if (c === ';') {
- break;
- }
- if (!((c >= '0' && c <= '9') ||
- (c >= 'a' && c <= 'z') ||
- c === '#')) {
- errorAt("Bad entity", line, from + l,
- character);
- }
- }
- break;
- }
- return it('(punctuator)', t);
- }
- }
- }
- }
- };
- }());
-
-
- function addlabel(t, type) {
-
- if (option.safe && funct['(global)'] && typeof predefined[t] !== 'boolean') {
- warning('ADsafe global: ' + t + '.', token);
- } else if (t === 'hasOwnProperty') {
- warning("'hasOwnProperty' is a really bad name.");
- }
-
-// Define t in the current function in the current scope.
-
- if (is_own(funct, t) && !funct['(global)']) {
- warning(funct[t] === true ?
- "'{a}' was used before it was defined." :
- "'{a}' is already defined.",
- nexttoken, t);
- }
- funct[t] = type;
- if (funct['(global)']) {
- global[t] = funct;
- if (is_own(implied, t)) {
- warning("'{a}' was used before it was defined.", nexttoken, t);
- delete implied[t];
- }
- } else {
- scope[t] = funct;
- }
- }
-
-
- function doOption() {
- var b, obj, filter, o = nexttoken.value, t, v;
- switch (o) {
- case '*/':
- error("Unbegun comment.");
- break;
- case '/*members':
- case '/*member':
- o = '/*members';
- if (!membersOnly) {
- membersOnly = {};
- }
- obj = membersOnly;
- break;
- case '/*jslint':
- if (option.safe) {
- warning("ADsafe restriction.");
- }
- obj = option;
- filter = boolOptions;
- break;
- case '/*global':
- if (option.safe) {
- warning("ADsafe restriction.");
- }
- obj = predefined;
- break;
- default:
- }
- t = lex.token();
-loop: for (;;) {
- for (;;) {
- if (t.type === 'special' && t.value === '*/') {
- break loop;
- }
- if (t.id !== '(endline)' && t.id !== ',') {
- break;
- }
- t = lex.token();
- }
- if (t.type !== '(string)' && t.type !== '(identifier)' &&
- o !== '/*members') {
- error("Bad option.", t);
- }
- v = lex.token();
- if (v.id === ':') {
- v = lex.token();
- if (obj === membersOnly) {
- error("Expected '{a}' and instead saw '{b}'.",
- t, '*/', ':');
- }
- if (t.value === 'indent' && o === '/*jslint') {
- b = +v.value;
- if (typeof b !== 'number' || !isFinite(b) || b <= 0 ||
- Math.floor(b) !== b) {
- error("Expected a small integer and instead saw '{a}'.",
- v, v.value);
- }
- obj.white = true;
- obj.indent = b;
- } else if (t.value === 'maxerr' && o === '/*jslint') {
- b = +v.value;
- if (typeof b !== 'number' || !isFinite(b) || b <= 0 ||
- Math.floor(b) !== b) {
- error("Expected a small integer and instead saw '{a}'.",
- v, v.value);
- }
- obj.maxerr = b;
- } else if (t.value === 'maxlen' && o === '/*jslint') {
- b = +v.value;
- if (typeof b !== 'number' || !isFinite(b) || b <= 0 ||
- Math.floor(b) !== b) {
- error("Expected a small integer and instead saw '{a}'.",
- v, v.value);
- }
- obj.maxlen = b;
- } else if (v.value === 'true') {
- obj[t.value] = true;
- } else if (v.value === 'false') {
- obj[t.value] = false;
- } else {
- error("Bad option value.", v);
- }
- t = lex.token();
- } else {
- if (o === '/*jslint') {
- error("Missing option value.", t);
- }
- obj[t.value] = false;
- t = v;
- }
- }
- if (filter) {
- assume();
- }
- }
-
-
-// We need a peek function. If it has an argument, it peeks that much farther
-// ahead. It is used to distinguish
-// for ( var i in ...
-// from
-// for ( var i = ...
-
- function peek(p) {
- var i = p || 0, j = 0, t;
-
- while (j <= i) {
- t = lookahead[j];
- if (!t) {
- t = lookahead[j] = lex.token();
- }
- j += 1;
- }
- return t;
- }
-
-
-
-// Produce the next token. It looks for programming errors.
-
- function advance(id, t) {
- switch (token.id) {
- case '(number)':
- if (nexttoken.id === '.') {
- warning(
-"A dot following a number can be confused with a decimal point.", token);
- }
- break;
- case '-':
- if (nexttoken.id === '-' || nexttoken.id === '--') {
- warning("Confusing minusses.");
- }
- break;
- case '+':
- if (nexttoken.id === '+' || nexttoken.id === '++') {
- warning("Confusing plusses.");
- }
- break;
- }
- if (token.type === '(string)' || token.identifier) {
- anonname = token.value;
- }
-
- if (id && nexttoken.id !== id) {
- if (t) {
- if (nexttoken.id === '(end)') {
- warning("Unmatched '{a}'.", t, t.id);
- } else {
- warning("Expected '{a}' to match '{b}' from line {c} and instead saw '{d}'.",
- nexttoken, id, t.id, t.line, nexttoken.value);
- }
- } else if (nexttoken.type !== '(identifier)' ||
- nexttoken.value !== id) {
- warning("Expected '{a}' and instead saw '{b}'.",
- nexttoken, id, nexttoken.value);
- }
- }
- prevtoken = token;
- token = nexttoken;
- for (;;) {
- nexttoken = lookahead.shift() || lex.token();
- if (nexttoken.id === '(end)' || nexttoken.id === '(error)') {
- return;
- }
- if (nexttoken.type === 'special') {
- doOption();
- } else {
- if (nexttoken.id !== '(endline)') {
- break;
- }
- }
- }
- }
-
-
-// This is the heart of JSLINT, the Pratt parser. In addition to parsing, it
-// is looking for ad hoc lint patterns. We add to Pratt's model .fud, which is
-// like nud except that it is only used on the first token of a statement.
-// Having .fud makes it much easier to define JavaScript. I retained Pratt's
-// nomenclature.
-
-// .nud Null denotation
-// .fud First null denotation
-// .led Left denotation
-// lbp Left binding power
-// rbp Right binding power
-
-// They are key to the parsing method called Top Down Operator Precedence.
-
- function parse(rbp, initial) {
- var left;
- if (nexttoken.id === '(end)') {
- error("Unexpected early end of program.", token);
- }
- advance();
- if (option.safe && typeof predefined[token.value] === 'boolean' &&
- (nexttoken.id !== '(' && nexttoken.id !== '.')) {
- warning('ADsafe violation.', token);
- }
- if (initial) {
- anonname = 'anonymous';
- funct['(verb)'] = token.value;
- }
- if (initial === true && token.fud) {
- left = token.fud();
- } else {
- if (token.nud) {
- left = token.nud();
- } else {
- if (nexttoken.type === '(number)' && token.id === '.') {
- warning(
-"A leading decimal point can be confused with a dot: '.{a}'.",
- token, nexttoken.value);
- advance();
- return token;
- } else {
- error("Expected an identifier and instead saw '{a}'.",
- token, token.id);
- }
- }
- while (rbp < nexttoken.lbp) {
- advance();
- if (token.led) {
- left = token.led(left);
- } else {
- error("Expected an operator and instead saw '{a}'.",
- token, token.id);
- }
- }
- }
- return left;
- }
-
-
-// Functions for conformance of style.
-
- function adjacent(left, right) {
- left = left || token;
- right = right || nexttoken;
- if (option.white || xmode === 'styleproperty' || xmode === 'style') {
- if (left.character !== right.from && left.line === right.line) {
- warning("Unexpected space after '{a}'.", right, left.value);
- }
- }
- }
-
- function nospace(left, right) {
- left = left || token;
- right = right || nexttoken;
- if (option.white && !left.comment) {
- if (left.line === right.line) {
- adjacent(left, right);
- }
- }
- }
-
-
- function nonadjacent(left, right) {
- if (option.white) {
- left = left || token;
- right = right || nexttoken;
- if (left.line === right.line && left.character === right.from) {
- warning("Missing space after '{a}'.",
- nexttoken, left.value);
- }
- }
- }
-
- function nobreaknonadjacent(left, right) {
- left = left || token;
- right = right || nexttoken;
- if (!option.laxbreak && left.line !== right.line) {
- warning("Bad line breaking before '{a}'.", right, right.id);
- } else if (option.white) {
- left = left || token;
- right = right || nexttoken;
- if (left.character === right.from) {
- warning("Missing space after '{a}'.",
- nexttoken, left.value);
- }
- }
- }
-
- function indentation(bias) {
- var i;
- if (option.white && nexttoken.id !== '(end)') {
- i = indent + (bias || 0);
- if (nexttoken.from !== i) {
- warning("Expected '{a}' to have an indentation at {b} instead at {c}.",
- nexttoken, nexttoken.value, i, nexttoken.from);
- }
- }
- }
-
- function nolinebreak(t) {
- t = t || token;
- if (t.line !== nexttoken.line) {
- warning("Line breaking error '{a}'.", t, t.value);
- }
- }
-
-
- function comma() {
- if (token.line !== nexttoken.line) {
- if (!option.laxbreak) {
- warning("Bad line breaking before '{a}'.", token, nexttoken.id);
- }
- } else if (token.character !== nexttoken.from && option.white) {
- warning("Unexpected space after '{a}'.", nexttoken, token.value);
- }
- advance(',');
- nonadjacent(token, nexttoken);
- }
-
-
-// Functional constructors for making the symbols that will be inherited by
-// tokens.
-
- function symbol(s, p) {
- var x = syntax[s];
- if (!x || typeof x !== 'object') {
- syntax[s] = x = {
- id: s,
- lbp: p,
- value: s
- };
- }
- return x;
- }
-
-
- function delim(s) {
- return symbol(s, 0);
- }
-
-
- function stmt(s, f) {
- var x = delim(s);
- x.identifier = x.reserved = true;
- x.fud = f;
- return x;
- }
-
-
- function blockstmt(s, f) {
- var x = stmt(s, f);
- x.block = true;
- return x;
- }
-
-
- function reserveName(x) {
- var c = x.id.charAt(0);
- if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')) {
- x.identifier = x.reserved = true;
- }
- return x;
- }
-
-
- function prefix(s, f) {
- var x = symbol(s, 150);
- reserveName(x);
- x.nud = (typeof f === 'function') ? f : function () {
- this.right = parse(150);
- this.arity = 'unary';
- if (this.id === '++' || this.id === '--') {
- if (option.plusplus) {
- warning("Unexpected use of '{a}'.", this, this.id);
- } else if ((!this.right.identifier || this.right.reserved) &&
- this.right.id !== '.' && this.right.id !== '[') {
- warning("Bad operand.", this);
- }
- }
- return this;
- };
- return x;
- }
-
-
- function type(s, f) {
- var x = delim(s);
- x.type = s;
- x.nud = f;
- return x;
- }
-
-
- function reserve(s, f) {
- var x = type(s, f);
- x.identifier = x.reserved = true;
- return x;
- }
-
-
- function reservevar(s, v) {
- return reserve(s, function () {
- if (this.id === 'this' || this.id === 'arguments' ||
- this.id === 'eval') {
- if (strict_mode && funct['(global)']) {
- warning("Strict violation.", this);
- } else if (option.safe) {
- warning("ADsafe violation.", this);
- }
- }
- return this;
- });
- }
-
-
- function infix(s, f, p, w) {
- var x = symbol(s, p);
- reserveName(x);
- x.led = function (left) {
- if (!w) {
- nobreaknonadjacent(prevtoken, token);
- nonadjacent(token, nexttoken);
- }
- if (typeof f === 'function') {
- return f(left, this);
- } else {
- this.left = left;
- this.right = parse(p);
- return this;
- }
- };
- return x;
- }
-
-
- function relation(s, f) {
- var x = symbol(s, 100);
- x.led = function (left) {
- nobreaknonadjacent(prevtoken, token);
- nonadjacent(token, nexttoken);
- var right = parse(100);
- if ((left && left.id === 'NaN') || (right && right.id === 'NaN')) {
- warning("Use the isNaN function to compare with NaN.", this);
- } else if (f) {
- f.apply(this, [left, right]);
- }
- if (left.id === '!') {
- warning("Confusing use of '{a}'.", left, '!');
- }
- if (right.id === '!') {
- warning("Confusing use of '{a}'.", left, '!');
- }
- this.left = left;
- this.right = right;
- return this;
- };
- return x;
- }
-
-
- function isPoorRelation(node) {
- return node &&
- ((node.type === '(number)' && +node.value === 0) ||
- (node.type === '(string)' && node.value === ' ') ||
- node.type === 'true' ||
- node.type === 'false' ||
- node.type === 'undefined' ||
- node.type === 'null');
- }
-
-
- function assignop(s, f) {
- symbol(s, 20).exps = true;
- return infix(s, function (left, that) {
- var l;
- that.left = left;
- if (predefined[left.value] === false &&
- scope[left.value]['(global)'] === true) {
- warning('Read only.', left);
- }
- if (option.safe) {
- l = left;
- do {
- if (typeof predefined[l.value] === 'boolean') {
- warning('ADsafe violation.', l);
- }
- l = l.left;
- } while (l);
- }
- if (left) {
- if (left.id === '.' || left.id === '[') {
- if (!left.left || left.left.value === 'arguments') {
- warning('Bad assignment.', that);
- }
- that.right = parse(19);
- return that;
- } else if (left.identifier && !left.reserved) {
- if (funct[left.value] === 'exception') {
- warning("Do not assign to the exception parameter.", left);
- }
- that.right = parse(19);
- return that;
- }
- if (left === syntax['function']) {
- warning(
-"Expected an identifier in an assignment and instead saw a function invocation.",
- token);
- }
- }
- error("Bad assignment.", that);
- }, 20);
- }
-
- function bitwise(s, f, p) {
- var x = symbol(s, p);
- reserveName(x);
- x.led = (typeof f === 'function') ? f : function (left) {
- if (option.bitwise) {
- warning("Unexpected use of '{a}'.", this, this.id);
- }
- this.left = left;
- this.right = parse(p);
- return this;
- };
- return x;
- }
-
- function bitwiseassignop(s) {
- symbol(s, 20).exps = true;
- return infix(s, function (left, that) {
- if (option.bitwise) {
- warning("Unexpected use of '{a}'.", that, that.id);
- }
- nonadjacent(prevtoken, token);
- nonadjacent(token, nexttoken);
- if (left) {
- if (left.id === '.' || left.id === '[' ||
- (left.identifier && !left.reserved)) {
- parse(19);
- return that;
- }
- if (left === syntax['function']) {
- warning(
-"Expected an identifier in an assignment, and instead saw a function invocation.",
- token);
- }
- return that;
- }
- error("Bad assignment.", that);
- }, 20);
- }
-
-
- function suffix(s, f) {
- var x = symbol(s, 150);
- x.led = function (left) {
- if (option.plusplus) {
- warning("Unexpected use of '{a}'.", this, this.id);
- } else if ((!left.identifier || left.reserved) && left.id !== '.' && left.id !== '[') {
- warning("Bad operand.", this);
- }
- this.left = left;
- return this;
- };
- return x;
- }
-
-
- function optionalidentifier() {
- if (nexttoken.reserved) {
- warning("Expected an identifier and instead saw '{a}' (a reserved word).",
- nexttoken, nexttoken.id);
- }
- if (nexttoken.identifier) {
- advance();
- return token.value;
- }
- }
-
-
- function identifier() {
- var i = optionalidentifier();
- if (i) {
- return i;
- }
- if (token.id === 'function' && nexttoken.id === '(') {
- warning("Missing name in function statement.");
- } else {
- error("Expected an identifier and instead saw '{a}'.",
- nexttoken, nexttoken.value);
- }
- }
-
- function reachable(s) {
- var i = 0, t;
- if (nexttoken.id !== ';' || noreach) {
- return;
- }
- for (;;) {
- t = peek(i);
- if (t.reach) {
- return;
- }
- if (t.id !== '(endline)') {
- if (t.id === 'function') {
- warning(
-"Inner functions should be listed at the top of the outer function.", t);
- break;
- }
- warning("Unreachable '{a}' after '{b}'.", t, t.value, s);
- break;
- }
- i += 1;
- }
- }
-
-
- function statement(noindent) {
- var i = indent, r, s = scope, t = nexttoken;
-
-// We don't like the empty statement.
-
- if (t.id === ';') {
- warning("Unnecessary semicolon.", t);
- advance(';');
- return;
- }
-
-// Is this a labelled statement?
-
- if (t.identifier && !t.reserved && peek().id === ':') {
- advance();
- advance(':');
- scope = Object.create(s);
- addlabel(t.value, 'label');
- if (!nexttoken.labelled) {
- warning("Label '{a}' on {b} statement.",
- nexttoken, t.value, nexttoken.value);
- }
- if (jx.test(t.value + ':')) {
- warning("Label '{a}' looks like a javascript url.",
- t, t.value);
- }
- nexttoken.label = t.value;
- t = nexttoken;
- }
-
-// Parse the statement.
-
- if (!noindent) {
- indentation();
- }
- r = parse(0, true);
-
-// Look for the final semicolon.
-
- if (!t.block) {
- if (!r || !r.exps) {
- warning(
-"Expected an assignment or function call and instead saw an expression.",
- token);
- } else if (r.id === '(' && r.left.id === 'new') {
- warning("Do not use 'new' for side effects.");
- }
- if (nexttoken.id !== ';') {
- warningAt("Missing semicolon.", token.line,
- token.from + token.value.length);
- } else {
- adjacent(token, nexttoken);
- advance(';');
- nonadjacent(token, nexttoken);
- }
- }
-
-// Restore the indentation.
-
- indent = i;
- scope = s;
- return r;
- }
-
-
- function use_strict() {
- if (nexttoken.value === 'use strict') {
- advance();
- advance(';');
- strict_mode = true;
- return true;
- } else {
- return false;
- }
- }
-
-
- function statements(begin) {
- var a = [], f, p;
- if (begin && !use_strict() && option.strict) {
- warning('Missing "use strict" statement.', nexttoken);
- }
- if (option.adsafe) {
- switch (begin) {
- case 'script':
- if (!adsafe_may) {
- if (nexttoken.value !== 'ADSAFE' ||
- peek(0).id !== '.' ||
- (peek(1).value !== 'id' &&
- peek(1).value !== 'go')) {
- error('ADsafe violation: Missing ADSAFE.id or ADSAFE.go.',
- nexttoken);
- }
- }
- if (nexttoken.value === 'ADSAFE' &&
- peek(0).id === '.' &&
- peek(1).value === 'id') {
- if (adsafe_may) {
- error('ADsafe violation.', nexttoken);
- }
- advance('ADSAFE');
- advance('.');
- advance('id');
- advance('(');
- if (nexttoken.value !== adsafe_id) {
- error('ADsafe violation: id does not match.', nexttoken);
- }
- advance('(string)');
- advance(')');
- advance(';');
- adsafe_may = true;
- }
- break;
- case 'lib':
- if (nexttoken.value === 'ADSAFE') {
- advance('ADSAFE');
- advance('.');
- advance('lib');
- advance('(');
- advance('(string)');
- comma();
- f = parse(0);
- if (f.id !== 'function') {
- error('The second argument to lib must be a function.', f);
- }
- p = f.funct['(params)'];
- p = p && p.join(', ');
- if (p && p !== 'lib') {
- error("Expected '{a}' and instead saw '{b}'.",
- f, '(lib)', '(' + p + ')');
- }
- advance(')');
- advance(';');
- return a;
- } else {
- error("ADsafe lib violation.");
- }
- }
- }
- while (!nexttoken.reach && nexttoken.id !== '(end)') {
- if (nexttoken.id === ';') {
- warning("Unnecessary semicolon.");
- advance(';');
- } else {
- a.push(statement());
- }
- }
- return a;
- }
-
-
- function block(f) {
- var a, b = inblock, old_indent = indent, s = scope, t;
- inblock = f;
- scope = Object.create(scope);
- nonadjacent(token, nexttoken);
- t = nexttoken;
- if (nexttoken.id === '{') {
- advance('{');
- if (nexttoken.id !== '}' || token.line !== nexttoken.line) {
- indent += option.indent;
- while (!f && nexttoken.from > indent) {
- indent += option.indent;
- }
- if (!f) {
- use_strict();
- }
- a = statements();
- indent -= option.indent;
- indentation();
- }
- advance('}', t);
- indent = old_indent;
- } else {
- warning("Expected '{a}' and instead saw '{b}'.",
- nexttoken, '{', nexttoken.value);
- noreach = true;
- a = [statement()];
- noreach = false;
- }
- funct['(verb)'] = null;
- scope = s;
- inblock = b;
- return a;
- }
-
-
-// An identity function, used by string and number tokens.
-
- function idValue() {
- return this;
- }
-
-
- function countMember(m) {
- if (membersOnly && typeof membersOnly[m] !== 'boolean') {
- warning("Unexpected /*member '{a}'.", token, m);
- }
- if (typeof member[m] === 'number') {
- member[m] += 1;
- } else {
- member[m] = 1;
- }
- }
-
-
- function note_implied(token) {
- var name = token.value, line = token.line, a = implied[name];
- if (typeof a === 'function') {
- a = false;
- }
- if (!a) {
- a = [line];
- implied[name] = a;
- } else if (a[a.length - 1] !== line) {
- a.push(line);
- }
- }
-
-// CSS parsing.
-
-
- function cssName() {
- if (nexttoken.identifier) {
- advance();
- return true;
- }
- }
-
- function cssNumber() {
- if (nexttoken.id === '-') {
- advance('-');
- adjacent();
- nolinebreak();
- }
- if (nexttoken.type === '(number)') {
- advance('(number)');
- return true;
- }
- }
-
- function cssString() {
- if (nexttoken.type === '(string)') {
- advance();
- return true;
- }
- }
-
- function cssColor() {
- var i, number, value;
- if (nexttoken.identifier) {
- value = nexttoken.value;
- if (value === 'rgb' || value === 'rgba') {
- advance();
- advance('(');
- for (i = 0; i < 3; i += 1) {
- if (i) {
- advance(',');
- }
- number = nexttoken.value;
- if (nexttoken.type !== '(number)' || number < 0) {
- warning("Expected a positive number and instead saw '{a}'",
- nexttoken, number);
- advance();
- } else {
- advance();
- if (nexttoken.id === '%') {
- advance('%');
- if (number > 100) {
- warning("Expected a percentage and instead saw '{a}'",
- token, number);
- }
- } else {
- if (number > 255) {
- warning("Expected a small number and instead saw '{a}'",
- token, number);
- }
- }
- }
- }
- if (value === 'rgba') {
- advance(',');
- number = +nexttoken.value;
- if (nexttoken.type !== '(number)' || number < 0 || number > 1) {
- warning("Expected a number between 0 and 1 and instead saw '{a}'",
- nexttoken, number);
- }
- advance();
- if (nexttoken.id === '%') {
- warning("Unexpected '%'.");
- advance('%');
- }
- }
- advance(')');
- return true;
- } else if (cssColorData[nexttoken.value] === true) {
- advance();
- return true;
- }
- } else if (nexttoken.type === '(color)') {
- advance();
- return true;
- }
- return false;
- }
-
- function cssLength() {
- if (nexttoken.id === '-') {
- advance('-');
- adjacent();
- nolinebreak();
- }
- if (nexttoken.type === '(number)') {
- advance();
- if (nexttoken.type !== '(string)' &&
- cssLengthData[nexttoken.value] === true) {
- adjacent();
- advance();
- } else if (+token.value !== 0) {
- warning("Expected a linear unit and instead saw '{a}'.",
- nexttoken, nexttoken.value);
- }
- return true;
- }
- return false;
- }
-
- function cssLineHeight() {
- if (nexttoken.id === '-') {
- advance('-');
- adjacent();
- }
- if (nexttoken.type === '(number)') {
- advance();
- if (nexttoken.type !== '(string)' &&
- cssLengthData[nexttoken.value] === true) {
- adjacent();
- advance();
- }
- return true;
- }
- return false;
- }
-
- function cssWidth() {
- if (nexttoken.identifier) {
- switch (nexttoken.value) {
- case 'thin':
- case 'medium':
- case 'thick':
- advance();
- return true;
- }
- } else {
- return cssLength();
- }
- }
-
- function cssMargin() {
- if (nexttoken.identifier) {
- if (nexttoken.value === 'auto') {
- advance();
- return true;
- }
- } else {
- return cssLength();
- }
- }
-
- function cssAttr() {
- if (nexttoken.identifier && nexttoken.value === 'attr') {
- advance();
- advance('(');
- if (!nexttoken.identifier) {
- warning("Expected a name and instead saw '{a}'.",
- nexttoken, nexttoken.value);
- }
- advance();
- advance(')');
- return true;
- }
- return false;
- }
-
- function cssCommaList() {
- while (nexttoken.id !== ';') {
- if (!cssName() && !cssString()) {
- warning("Expected a name and instead saw '{a}'.",
- nexttoken, nexttoken.value);
- }
- if (nexttoken.id !== ',') {
- return true;
- }
- comma();
- }
- }
-
- function cssCounter() {
- if (nexttoken.identifier && nexttoken.value === 'counter') {
- advance();
- advance('(');
- if (!nexttoken.identifier) {
- }
- advance();
- if (nexttoken.id === ',') {
- comma();
- if (nexttoken.type !== '(string)') {
- warning("Expected a string and instead saw '{a}'.",
- nexttoken, nexttoken.value);
- }
- advance();
- }
- advance(')');
- return true;
- }
- if (nexttoken.identifier && nexttoken.value === 'counters') {
- advance();
- advance('(');
- if (!nexttoken.identifier) {
- warning("Expected a name and instead saw '{a}'.",
- nexttoken, nexttoken.value);
- }
- advance();
- if (nexttoken.id === ',') {
- comma();
- if (nexttoken.type !== '(string)') {
- warning("Expected a string and instead saw '{a}'.",
- nexttoken, nexttoken.value);
- }
- advance();
- }
- if (nexttoken.id === ',') {
- comma();
- if (nexttoken.type !== '(string)') {
- warning("Expected a string and instead saw '{a}'.",
- nexttoken, nexttoken.value);
- }
- advance();
- }
- advance(')');
- return true;
- }
- return false;
- }
-
-
- function cssShape() {
- var i;
- if (nexttoken.identifier && nexttoken.value === 'rect') {
- advance();
- advance('(');
- for (i = 0; i < 4; i += 1) {
- if (!cssLength()) {
- warning("Expected a number and instead saw '{a}'.",
- nexttoken, nexttoken.value);
- break;
- }
- }
- advance(')');
- return true;
- }
- return false;
- }
-
- function cssUrl() {
- var c, url;
- if (nexttoken.identifier && nexttoken.value === 'url') {
- nexttoken = lex.range('(', ')');
- url = nexttoken.value;
- c = url.charAt(0);
- if (c === '"' || c === '\'') {
- if (url.slice(-1) !== c) {
- warning("Bad url string.");
- } else {
- url = url.slice(1, -1);
- if (url.indexOf(c) >= 0) {
- warning("Bad url string.");
- }
- }
- }
- if (!url) {
- warning("Missing url.");
- }
- advance();
- if (option.safe && ux.test(url)) {
- error("ADsafe URL violation.");
- }
- urls.push(url);
- return true;
- }
- return false;
- }
-
- cssAny = [cssUrl, function () {
- for (;;) {
- if (nexttoken.identifier) {
- switch (nexttoken.value.toLowerCase()) {
- case 'url':
- cssUrl();
- break;
- case 'expression':
- warning("Unexpected expression '{a}'.",
- nexttoken, nexttoken.value);
- advance();
- break;
- default:
- advance();
- }
- } else {
- if (nexttoken.id === ';' || nexttoken.id === '!' ||
- nexttoken.id === '(end)' || nexttoken.id === '}') {
- return true;
- }
- advance();
- }
- }
- }];
-
- cssBorderStyle = [
- 'none', 'hidden', 'dotted', 'dashed', 'solid', 'double', 'ridge',
- 'inset', 'outset'
- ];
-
- cssBreak = [
- 'auto', 'always', 'avoid', 'left', 'right'
- ];
-
- cssOverflow = [
- 'auto', 'hidden', 'scroll', 'visible'
- ];
-
- cssAttributeData = {
- background: [
- true, 'background-attachment', 'background-color',
- 'background-image', 'background-position', 'background-repeat'
- ],
- 'background-attachment': ['scroll', 'fixed'],
- 'background-color': ['transparent', cssColor],
- 'background-image': ['none', cssUrl],
- 'background-position': [
- 2, [cssLength, 'top', 'bottom', 'left', 'right', 'center']
- ],
- 'background-repeat': [
- 'repeat', 'repeat-x', 'repeat-y', 'no-repeat'
- ],
- 'border': [true, 'border-color', 'border-style', 'border-width'],
- 'border-bottom': [
- true, 'border-bottom-color', 'border-bottom-style',
- 'border-bottom-width'
- ],
- 'border-bottom-color': cssColor,
- 'border-bottom-style': cssBorderStyle,
- 'border-bottom-width': cssWidth,
- 'border-collapse': ['collapse', 'separate'],
- 'border-color': ['transparent', 4, cssColor],
- 'border-left': [
- true, 'border-left-color', 'border-left-style', 'border-left-width'
- ],
- 'border-left-color': cssColor,
- 'border-left-style': cssBorderStyle,
- 'border-left-width': cssWidth,
- 'border-right': [
- true, 'border-right-color', 'border-right-style',
- 'border-right-width'
- ],
- 'border-right-color': cssColor,
- 'border-right-style': cssBorderStyle,
- 'border-right-width': cssWidth,
- 'border-spacing': [2, cssLength],
- 'border-style': [4, cssBorderStyle],
- 'border-top': [
- true, 'border-top-color', 'border-top-style', 'border-top-width'
- ],
- 'border-top-color': cssColor,
- 'border-top-style': cssBorderStyle,
- 'border-top-width': cssWidth,
- 'border-width': [4, cssWidth],
- bottom: [cssLength, 'auto'],
- 'caption-side' : ['bottom', 'left', 'right', 'top'],
- clear: ['both', 'left', 'none', 'right'],
- clip: [cssShape, 'auto'],
- color: cssColor,
- content: [
- 'open-quote', 'close-quote', 'no-open-quote', 'no-close-quote',
- cssString, cssUrl, cssCounter, cssAttr
- ],
- 'counter-increment': [
- cssName, 'none'
- ],
- 'counter-reset': [
- cssName, 'none'
- ],
- cursor: [
- cssUrl, 'auto', 'crosshair', 'default', 'e-resize', 'help', 'move',
- 'n-resize', 'ne-resize', 'nw-resize', 'pointer', 's-resize',
- 'se-resize', 'sw-resize', 'w-resize', 'text', 'wait'
- ],
- direction: ['ltr', 'rtl'],
- display: [
- 'block', 'compact', 'inline', 'inline-block', 'inline-table',
- 'list-item', 'marker', 'none', 'run-in', 'table', 'table-caption',
- 'table-cell', 'table-column', 'table-column-group',
- 'table-footer-group', 'table-header-group', 'table-row',
- 'table-row-group'
- ],
- 'empty-cells': ['show', 'hide'],
- 'float': ['left', 'none', 'right'],
- font: [
- 'caption', 'icon', 'menu', 'message-box', 'small-caption',
- 'status-bar', true, 'font-size', 'font-style', 'font-weight',
- 'font-family'
- ],
- 'font-family': cssCommaList,
- 'font-size': [
- 'xx-small', 'x-small', 'small', 'medium', 'large', 'x-large',
- 'xx-large', 'larger', 'smaller', cssLength
- ],
- 'font-size-adjust': ['none', cssNumber],
- 'font-stretch': [
- 'normal', 'wider', 'narrower', 'ultra-condensed',
- 'extra-condensed', 'condensed', 'semi-condensed',
- 'semi-expanded', 'expanded', 'extra-expanded'
- ],
- 'font-style': [
- 'normal', 'italic', 'oblique'
- ],
- 'font-variant': [
- 'normal', 'small-caps'
- ],
- 'font-weight': [
- 'normal', 'bold', 'bolder', 'lighter', cssNumber
- ],
- height: [cssLength, 'auto'],
- left: [cssLength, 'auto'],
- 'letter-spacing': ['normal', cssLength],
- 'line-height': ['normal', cssLineHeight],
- 'list-style': [
- true, 'list-style-image', 'list-style-position', 'list-style-type'
- ],
- 'list-style-image': ['none', cssUrl],
- 'list-style-position': ['inside', 'outside'],
- 'list-style-type': [
- 'circle', 'disc', 'square', 'decimal', 'decimal-leading-zero',
- 'lower-roman', 'upper-roman', 'lower-greek', 'lower-alpha',
- 'lower-latin', 'upper-alpha', 'upper-latin', 'hebrew', 'katakana',
- 'hiragana-iroha', 'katakana-oroha', 'none'
- ],
- margin: [4, cssMargin],
- 'margin-bottom': cssMargin,
- 'margin-left': cssMargin,
- 'margin-right': cssMargin,
- 'margin-top': cssMargin,
- 'marker-offset': [cssLength, 'auto'],
- 'max-height': [cssLength, 'none'],
- 'max-width': [cssLength, 'none'],
- 'min-height': cssLength,
- 'min-width': cssLength,
- opacity: cssNumber,
- outline: [true, 'outline-color', 'outline-style', 'outline-width'],
- 'outline-color': ['invert', cssColor],
- 'outline-style': [
- 'dashed', 'dotted', 'double', 'groove', 'inset', 'none',
- 'outset', 'ridge', 'solid'
- ],
- 'outline-width': cssWidth,
- overflow: cssOverflow,
- 'overflow-x': cssOverflow,
- 'overflow-y': cssOverflow,
- padding: [4, cssLength],
- 'padding-bottom': cssLength,
- 'padding-left': cssLength,
- 'padding-right': cssLength,
- 'padding-top': cssLength,
- 'page-break-after': cssBreak,
- 'page-break-before': cssBreak,
- position: ['absolute', 'fixed', 'relative', 'static'],
- quotes: [8, cssString],
- right: [cssLength, 'auto'],
- 'table-layout': ['auto', 'fixed'],
- 'text-align': ['center', 'justify', 'left', 'right'],
- 'text-decoration': [
- 'none', 'underline', 'overline', 'line-through', 'blink'
- ],
- 'text-indent': cssLength,
- 'text-shadow': ['none', 4, [cssColor, cssLength]],
- 'text-transform': ['capitalize', 'uppercase', 'lowercase', 'none'],
- top: [cssLength, 'auto'],
- 'unicode-bidi': ['normal', 'embed', 'bidi-override'],
- 'vertical-align': [
- 'baseline', 'bottom', 'sub', 'super', 'top', 'text-top', 'middle',
- 'text-bottom', cssLength
- ],
- visibility: ['visible', 'hidden', 'collapse'],
- 'white-space': [
- 'normal', 'nowrap', 'pre', 'pre-line', 'pre-wrap', 'inherit'
- ],
- width: [cssLength, 'auto'],
- 'word-spacing': ['normal', cssLength],
- 'word-wrap': ['break-word', 'normal'],
- 'z-index': ['auto', cssNumber]
- };
-
- function styleAttribute() {
- var v;
- while (nexttoken.id === '*' || nexttoken.id === '#' ||
- nexttoken.value === '_') {
- if (!option.css) {
- warning("Unexpected '{a}'.", nexttoken, nexttoken.value);
- }
- advance();
- }
- if (nexttoken.id === '-') {
- if (!option.css) {
- warning("Unexpected '{a}'.", nexttoken, nexttoken.value);
- }
- advance('-');
- if (!nexttoken.identifier) {
- warning(
-"Expected a non-standard style attribute and instead saw '{a}'.",
- nexttoken, nexttoken.value);
- }
- advance();
- return cssAny;
- } else {
- if (!nexttoken.identifier) {
- warning("Excepted a style attribute, and instead saw '{a}'.",
- nexttoken, nexttoken.value);
- } else {
- if (is_own(cssAttributeData, nexttoken.value)) {
- v = cssAttributeData[nexttoken.value];
- } else {
- v = cssAny;
- if (!option.css) {
- warning("Unrecognized style attribute '{a}'.",
- nexttoken, nexttoken.value);
- }
- }
- }
- advance();
- return v;
- }
- }
-
- function styleValue(v) {
- var i = 0,
- n,
- once,
- match,
- round,
- start = 0,
- vi;
- switch (typeof v) {
- case 'function':
- return v();
- case 'string':
- if (nexttoken.identifier && nexttoken.value === v) {
- advance();
- return true;
- }
- return false;
- }
- for (;;) {
- if (i >= v.length) {
- return false;
- }
- vi = v[i];
- i += 1;
- if (vi === true) {
- break;
- } else if (typeof vi === 'number') {
- n = vi;
- vi = v[i];
- i += 1;
- } else {
- n = 1;
- }
- match = false;
- while (n > 0) {
- if (styleValue(vi)) {
- match = true;
- n -= 1;
- } else {
- break;
- }
- }
- if (match) {
- return true;
- }
- }
- start = i;
- once = [];
- for (;;) {
- round = false;
- for (i = start; i < v.length; i += 1) {
- if (!once[i]) {
- if (styleValue(cssAttributeData[v[i]])) {
- match = true;
- round = true;
- once[i] = true;
- break;
- }
- }
- }
- if (!round) {
- return match;
- }
- }
- }
-
- function styleChild() {
- if (nexttoken.id === '(number)') {
- advance();
- if (nexttoken.value === 'n' && nexttoken.identifier) {
- adjacent();
- advance();
- if (nexttoken.id === '+') {
- adjacent();
- advance('+');
- adjacent();
- advance('(number)');
- }
- }
- return;
- } else {
- switch (nexttoken.value) {
- case 'odd':
- case 'even':
- if (nexttoken.identifier) {
- advance();
- return;
- }
- }
- }
- warning("Unexpected token '{a}'.", nexttoken, nexttoken.value);
- }
-
- function substyle() {
- var v;
- for (;;) {
- if (nexttoken.id === '}' || nexttoken.id === '(end)' ||
- xquote && nexttoken.id === xquote) {
- return;
- }
- while (nexttoken.id === ';') {
- warning("Misplaced ';'.");
- advance(';');
- }
- v = styleAttribute();
- advance(':');
- if (nexttoken.identifier && nexttoken.value === 'inherit') {
- advance();
- } else {
- if (!styleValue(v)) {
- warning("Unexpected token '{a}'.", nexttoken,
- nexttoken.value);
- advance();
- }
- }
- if (nexttoken.id === '!') {
- advance('!');
- adjacent();
- if (nexttoken.identifier && nexttoken.value === 'important') {
- advance();
- } else {
- warning("Expected '{a}' and instead saw '{b}'.",
- nexttoken, 'important', nexttoken.value);
- }
- }
- if (nexttoken.id === '}' || nexttoken.id === xquote) {
- warning("Missing '{a}'.", nexttoken, ';');
- } else {
- advance(';');
- }
- }
- }
-
- function styleSelector() {
- if (nexttoken.identifier) {
- if (!is_own(htmltag, nexttoken.value)) {
- warning("Expected a tagName, and instead saw {a}.",
- nexttoken, nexttoken.value);
- }
- advance();
- } else {
- switch (nexttoken.id) {
- case '>':
- case '+':
- advance();
- styleSelector();
- break;
- case ':':
- advance(':');
- switch (nexttoken.value) {
- case 'active':
- case 'after':
- case 'before':
- case 'checked':
- case 'disabled':
- case 'empty':
- case 'enabled':
- case 'first-child':
- case 'first-letter':
- case 'first-line':
- case 'first-of-type':
- case 'focus':
- case 'hover':
- case 'last-of-type':
- case 'link':
- case 'only-of-type':
- case 'root':
- case 'target':
- case 'visited':
- advance();
- break;
- case 'lang':
- advance();
- advance('(');
- if (!nexttoken.identifier) {
- warning("Expected a lang code, and instead saw :{a}.",
- nexttoken, nexttoken.value);
- }
- advance(')');
- break;
- case 'nth-child':
- case 'nth-last-child':
- case 'nth-last-of-type':
- case 'nth-of-type':
- advance();
- advance('(');
- styleChild();
- advance(')');
- break;
- case 'not':
- advance();
- advance('(');
- if (nexttoken.id === ':' && peek(0).value === 'not') {
- warning("Nested not.");
- }
- styleSelector();
- advance(')');
- break;
- default:
- warning("Expected a pseudo, and instead saw :{a}.",
- nexttoken, nexttoken.value);
- }
- break;
- case '#':
- advance('#');
- if (!nexttoken.identifier) {
- warning("Expected an id, and instead saw #{a}.",
- nexttoken, nexttoken.value);
- }
- advance();
- break;
- case '*':
- advance('*');
- break;
- case '.':
- advance('.');
- if (!nexttoken.identifier) {
- warning("Expected a class, and instead saw #.{a}.",
- nexttoken, nexttoken.value);
- }
- advance();
- break;
- case '[':
- advance('[');
- if (!nexttoken.identifier) {
- warning("Expected an attribute, and instead saw [{a}].",
- nexttoken, nexttoken.value);
- }
- advance();
- if (nexttoken.id === '=' || nexttoken.value === '~=' ||
- nexttoken.value === '$=' ||
- nexttoken.value === '|=' ||
- nexttoken.id === '*=' ||
- nexttoken.id === '^=') {
- advance();
- if (nexttoken.type !== '(string)') {
- warning("Expected a string, and instead saw {a}.",
- nexttoken, nexttoken.value);
- }
- advance();
- }
- advance(']');
- break;
- default:
- error("Expected a CSS selector, and instead saw {a}.",
- nexttoken, nexttoken.value);
- }
- }
- }
-
- function stylePattern() {
- var name;
- if (nexttoken.id === '{') {
- warning("Expected a style pattern, and instead saw '{a}'.", nexttoken,
- nexttoken.id);
- } else if (nexttoken.id === '@') {
- advance('@');
- name = nexttoken.value;
- if (nexttoken.identifier && atrule[name] === true) {
- advance();
- return name;
- }
- warning("Expected an at-rule, and instead saw @{a}.", nexttoken, name);
- }
- for (;;) {
- styleSelector();
- if (nexttoken.id === ' fragments and .js files.", token);
- }
- if (option.fragment) {
- if (n !== 'div') {
- error("ADsafe violation: Wrap the widget in a div.", token);
- }
- } else {
- error("Use the fragment option.", token);
- }
- }
- option.browser = true;
- assume();
- }
-
- function doAttribute(n, a, v) {
- var u, x;
- if (a === 'id') {
- u = typeof v === 'string' ? v.toUpperCase() : '';
- if (ids[u] === true) {
- warning("Duplicate id='{a}'.", nexttoken, v);
- }
- if (!/^[A-Za-z][A-Za-z0-9._:\-]*$/.test(v)) {
- warning("Bad id: '{a}'.", nexttoken, v);
- } else if (option.adsafe) {
- if (adsafe_id) {
- if (v.slice(0, adsafe_id.length) !== adsafe_id) {
- warning("ADsafe violation: An id must have a '{a}' prefix",
- nexttoken, adsafe_id);
- } else if (!/^[A-Z]+_[A-Z]+$/.test(v)) {
- warning("ADSAFE violation: bad id.");
- }
- } else {
- adsafe_id = v;
- if (!/^[A-Z]+_$/.test(v)) {
- warning("ADSAFE violation: bad id.");
- }
- }
- }
- x = v.search(dx);
- if (x >= 0) {
- warning("Unexpected character '{a}' in {b}.", token, v.charAt(x), a);
- }
- ids[u] = true;
- } else if (a === 'class' || a === 'type' || a === 'name') {
- x = v.search(qx);
- if (x >= 0) {
- warning("Unexpected character '{a}' in {b}.", token, v.charAt(x), a);
- }
- ids[u] = true;
- } else if (a === 'href' || a === 'background' ||
- a === 'content' || a === 'data' ||
- a.indexOf('src') >= 0 || a.indexOf('url') >= 0) {
- if (option.safe && ux.test(v)) {
- error("ADsafe URL violation.");
- }
- urls.push(v);
- } else if (a === 'for') {
- if (option.adsafe) {
- if (adsafe_id) {
- if (v.slice(0, adsafe_id.length) !== adsafe_id) {
- warning("ADsafe violation: An id must have a '{a}' prefix",
- nexttoken, adsafe_id);
- } else if (!/^[A-Z]+_[A-Z]+$/.test(v)) {
- warning("ADSAFE violation: bad id.");
- }
- } else {
- warning("ADSAFE violation: bad id.");
- }
- }
- } else if (a === 'name') {
- if (option.adsafe && v.indexOf('_') >= 0) {
- warning("ADsafe name violation.");
- }
- }
- }
-
- function doTag(n, a) {
- var i, t = htmltag[n], x;
- src = false;
- if (!t) {
- error("Unrecognized tag '<{a}>'.",
- nexttoken,
- n === n.toLowerCase() ? n :
- n + ' (capitalization error)');
- }
- if (stack.length > 0) {
- if (n === 'html') {
- error("Too many tags.", token);
- }
- x = t.parent;
- if (x) {
- if (x.indexOf(' ' + stack[stack.length - 1].name + ' ') < 0) {
- error("A '<{a}>' must be within '<{b}>'.",
- token, n, x);
- }
- } else if (!option.adsafe && !option.fragment) {
- i = stack.length;
- do {
- if (i <= 0) {
- error("A '<{a}>' must be within '<{b}>'.",
- token, n, 'body');
- }
- i -= 1;
- } while (stack[i].name !== 'body');
- }
- }
- switch (n) {
- case 'div':
- if (option.adsafe && stack.length === 1 && !adsafe_id) {
- warning("ADSAFE violation: missing ID_.");
- }
- break;
- case 'script':
- xmode = 'script';
- advance('>');
- indent = nexttoken.from;
- if (a.lang) {
- warning("lang is deprecated.", token);
- }
- if (option.adsafe && stack.length !== 1) {
- warning("ADsafe script placement violation.", token);
- }
- if (a.src) {
- if (option.adsafe && (!adsafe_may || !approved[a.src])) {
- warning("ADsafe unapproved script source.", token);
- }
- if (a.type) {
- warning("type is unnecessary.", token);
- }
- } else {
- if (adsafe_went) {
- error("ADsafe script violation.", token);
- }
- statements('script');
- }
- xmode = 'html';
- advance('');
- styles();
- xmode = 'html';
- advance('';
- }
-
- function html() {
- var a, attributes, e, n, q, t, v, w = option.white, wmode;
- xmode = 'html';
- xquote = '';
- stack = null;
- for (;;) {
- switch (nexttoken.value) {
- case '<':
- xmode = 'html';
- advance('<');
- attributes = {};
- t = nexttoken;
- if (!t.identifier) {
- warning("Bad identifier {a}.", t, t.value);
- }
- n = t.value;
- if (option.cap) {
- n = n.toLowerCase();
- }
- t.name = n;
- advance();
- if (!stack) {
- stack = [];
- doBegin(n);
- }
- v = htmltag[n];
- if (typeof v !== 'object') {
- error("Unrecognized tag '<{a}>'.", t, n);
- }
- e = v.empty;
- t.type = n;
- for (;;) {
- if (nexttoken.id === '/') {
- advance('/');
- if (nexttoken.id !== '>') {
- warning("Expected '{a}' and instead saw '{b}'.",
- nexttoken, '>', nexttoken.value);
- }
- break;
- }
- if (nexttoken.id && nexttoken.id.substr(0, 1) === '>') {
- break;
- }
- if (!nexttoken.identifier) {
- if (nexttoken.id === '(end)' || nexttoken.id === '(error)') {
- error("Missing '>'.", nexttoken);
- }
- warning("Bad identifier.");
- }
- option.white = true;
- nonadjacent(token, nexttoken);
- a = nexttoken.value;
- option.white = w;
- advance();
- if (!option.cap && a !== a.toLowerCase()) {
- warning("Attribute '{a}' not all lower case.", nexttoken, a);
- }
- a = a.toLowerCase();
- xquote = '';
- if (is_own(attributes, a)) {
- warning("Attribute '{a}' repeated.", nexttoken, a);
- }
- if (a.slice(0, 2) === 'on') {
- if (!option.on) {
- warning("Avoid HTML event handlers.");
- }
- xmode = 'scriptstring';
- advance('=');
- q = nexttoken.id;
- if (q !== '"' && q !== "'") {
- error("Missing quote.");
- }
- xquote = q;
- wmode = option.white;
- option.white = false;
- advance(q);
- statements('on');
- option.white = wmode;
- if (nexttoken.id !== q) {
- error("Missing close quote on script attribute.");
- }
- xmode = 'html';
- xquote = '';
- advance(q);
- v = false;
- } else if (a === 'style') {
- xmode = 'scriptstring';
- advance('=');
- q = nexttoken.id;
- if (q !== '"' && q !== "'") {
- error("Missing quote.");
- }
- xmode = 'styleproperty';
- xquote = q;
- advance(q);
- substyle();
- xmode = 'html';
- xquote = '';
- advance(q);
- v = false;
- } else {
- if (nexttoken.id === '=') {
- advance('=');
- v = nexttoken.value;
- if (!nexttoken.identifier &&
- nexttoken.id !== '"' &&
- nexttoken.id !== '\'' &&
- nexttoken.type !== '(string)' &&
- nexttoken.type !== '(number)' &&
- nexttoken.type !== '(color)') {
- warning("Expected an attribute value and instead saw '{a}'.", token, a);
- }
- advance();
- } else {
- v = true;
- }
- }
- attributes[a] = v;
- doAttribute(n, a, v);
- }
- doTag(n, attributes);
- if (!e) {
- stack.push(t);
- }
- xmode = 'outer';
- advance('>');
- break;
- case '') {
- error("Missing '{a}'.", nexttoken, '>');
- }
- xmode = 'outer';
- advance('>');
- break;
- case '' || nexttoken.id === '(end)') {
- break;
- }
- if (nexttoken.value.indexOf('--') >= 0) {
- warning("Unexpected --.");
- }
- if (nexttoken.value.indexOf('<') >= 0) {
- warning("Unexpected <.");
- }
- if (nexttoken.value.indexOf('>') >= 0) {
- warning("Unexpected >.");
- }
- }
- xmode = 'outer';
- advance('>');
- break;
- case '(end)':
- return;
- default:
- if (nexttoken.id === '(end)') {
- error("Missing '{a}'.", nexttoken,
- '');
- } else {
- advance();
- }
- }
- if (stack && stack.length === 0 && (option.adsafe ||
- !option.fragment || nexttoken.id === '(end)')) {
- break;
- }
- }
- if (nexttoken.id !== '(end)') {
- error("Unexpected material after the end.");
- }
- }
-
-
-// Build the syntax table by declaring the syntactic elements of the language.
-
- type('(number)', idValue);
- type('(string)', idValue);
-
- syntax['(identifier)'] = {
- type: '(identifier)',
- lbp: 0,
- identifier: true,
- nud: function () {
- var v = this.value,
- s = scope[v],
- f;
- if (typeof s === 'function') {
- s = undefined;
- } else if (typeof s === 'boolean') {
- f = funct;
- funct = functions[0];
- addlabel(v, 'var');
- s = funct;
- funct = f;
- }
-
-// The name is in scope and defined in the current function.
-
- if (funct === s) {
-
-// Change 'unused' to 'var', and reject labels.
-
- switch (funct[v]) {
- case 'unused':
- funct[v] = 'var';
- break;
- case 'label':
- warning("'{a}' is a statement label.", token, v);
- break;
- }
-
-// The name is not defined in the function. If we are in the global scope,
-// then we have an undefined variable.
-
- } else if (funct['(global)']) {
- if (option.undef && predefined[v] !== 'boolean') {
- warning("'{a}' is not defined.", token, v);
- }
- note_implied(token);
-
-// If the name is already defined in the current
-// function, but not as outer, then there is a scope error.
-
- } else {
- switch (funct[v]) {
- case 'closure':
- case 'function':
- case 'var':
- case 'unused':
- warning("'{a}' used out of scope.", token, v);
- break;
- case 'label':
- warning("'{a}' is a statement label.", token, v);
- break;
- case 'outer':
- case 'global':
- break;
- default:
-
-// If the name is defined in an outer function, make an outer entry, and if
-// it was unused, make it var.
-
- if (s === true) {
- funct[v] = true;
- } else if (s === null) {
- warning("'{a}' is not allowed.", token, v);
- note_implied(token);
- } else if (typeof s !== 'object') {
- if (option.undef) {
- warning("'{a}' is not defined.", token, v);
- } else {
- funct[v] = true;
- }
- note_implied(token);
- } else {
- switch (s[v]) {
- case 'function':
- case 'var':
- case 'unused':
- s[v] = 'closure';
- funct[v] = s['(global)'] ? 'global' : 'outer';
- break;
- case 'closure':
- case 'parameter':
- funct[v] = s['(global)'] ? 'global' : 'outer';
- break;
- case 'label':
- warning("'{a}' is a statement label.", token, v);
- }
- }
- }
- }
- return this;
- },
- led: function () {
- error("Expected an operator and instead saw '{a}'.",
- nexttoken, nexttoken.value);
- }
- };
-
- type('(regexp)', function () {
- return this;
- });
-
- delim('(endline)');
- delim('(begin)');
- delim('(end)').reach = true;
- delim('');
- delim('(error)').reach = true;
- delim('}').reach = true;
- delim(')');
- delim(']');
- delim('"').reach = true;
- delim("'").reach = true;
- delim(';');
- delim(':').reach = true;
- delim(',');
- delim('#');
- delim('@');
- reserve('else');
- reserve('case').reach = true;
- reserve('catch');
- reserve('default').reach = true;
- reserve('finally');
- reservevar('arguments');
- reservevar('eval');
- reservevar('false');
- reservevar('Infinity');
- reservevar('NaN');
- reservevar('null');
- reservevar('this');
- reservevar('true');
- reservevar('undefined');
- assignop('=', 'assign', 20);
- assignop('+=', 'assignadd', 20);
- assignop('-=', 'assignsub', 20);
- assignop('*=', 'assignmult', 20);
- assignop('/=', 'assigndiv', 20).nud = function () {
- error("A regular expression literal can be confused with '/='.");
- };
- assignop('%=', 'assignmod', 20);
- bitwiseassignop('&=', 'assignbitand', 20);
- bitwiseassignop('|=', 'assignbitor', 20);
- bitwiseassignop('^=', 'assignbitxor', 20);
- bitwiseassignop('<<=', 'assignshiftleft', 20);
- bitwiseassignop('>>=', 'assignshiftright', 20);
- bitwiseassignop('>>>=', 'assignshiftrightunsigned', 20);
- infix('?', function (left, that) {
- that.left = left;
- that.right = parse(10);
- advance(':');
- that['else'] = parse(10);
- return that;
- }, 30);
-
- infix('||', 'or', 40);
- infix('&&', 'and', 50);
- bitwise('|', 'bitor', 70);
- bitwise('^', 'bitxor', 80);
- bitwise('&', 'bitand', 90);
- relation('==', function (left, right) {
- if (option.eqeqeq) {
- warning("Expected '{a}' and instead saw '{b}'.",
- this, '===', '==');
- } else if (isPoorRelation(left)) {
- warning("Use '{a}' to compare with '{b}'.",
- this, '===', left.value);
- } else if (isPoorRelation(right)) {
- warning("Use '{a}' to compare with '{b}'.",
- this, '===', right.value);
- }
- return this;
- });
- relation('===');
- relation('!=', function (left, right) {
- if (option.eqeqeq) {
- warning("Expected '{a}' and instead saw '{b}'.",
- this, '!==', '!=');
- } else if (isPoorRelation(left)) {
- warning("Use '{a}' to compare with '{b}'.",
- this, '!==', left.value);
- } else if (isPoorRelation(right)) {
- warning("Use '{a}' to compare with '{b}'.",
- this, '!==', right.value);
- }
- return this;
- });
- relation('!==');
- relation('<');
- relation('>');
- relation('<=');
- relation('>=');
- bitwise('<<', 'shiftleft', 120);
- bitwise('>>', 'shiftright', 120);
- bitwise('>>>', 'shiftrightunsigned', 120);
- infix('in', 'in', 120);
- infix('instanceof', 'instanceof', 120);
- infix('+', function (left, that) {
- var right = parse(130);
- if (left && right && left.id === '(string)' && right.id === '(string)') {
- left.value += right.value;
- left.character = right.character;
- if (jx.test(left.value)) {
- warning("JavaScript URL.", left);
- }
- return left;
- }
- that.left = left;
- that.right = right;
- return that;
- }, 130);
- prefix('+', 'num');
- infix('-', 'sub', 130);
- prefix('-', 'neg');
- infix('*', 'mult', 140);
- infix('/', 'div', 140);
- infix('%', 'mod', 140);
-
- suffix('++', 'postinc');
- prefix('++', 'preinc');
- syntax['++'].exps = true;
-
- suffix('--', 'postdec');
- prefix('--', 'predec');
- syntax['--'].exps = true;
- prefix('delete', function () {
- var p = parse(0);
- if (!p || (p.id !== '.' && p.id !== '[')) {
- warning("Expected '{a}' and instead saw '{b}'.",
- nexttoken, '.', nexttoken.value);
- }
- this.first = p;
- return this;
- }).exps = true;
-
-
- prefix('~', function () {
- if (option.bitwise) {
- warning("Unexpected '{a}'.", this, '~');
- }
- parse(150);
- return this;
- });
- prefix('!', function () {
- this.right = parse(150);
- this.arity = 'unary';
- if (bang[this.right.id] === true) {
- warning("Confusing use of '{a}'.", this, '!');
- }
- return this;
- });
- prefix('typeof', 'typeof');
- prefix('new', function () {
- var c = parse(155), i;
- if (c && c.id !== 'function') {
- if (c.identifier) {
- c['new'] = true;
- switch (c.value) {
- case 'Object':
- warning("Use the object literal notation {}.", token);
- break;
- case 'Array':
- if (nexttoken.id !== '(') {
- warning("Use the array literal notation [].", token);
- } else {
- advance('(');
- if (nexttoken.id === ')') {
- warning("Use the array literal notation [].", token);
- } else {
- i = parse(0);
- c.dimension = i;
- if ((i.id === '(number)' && /[.+\-Ee]/.test(i.value)) ||
- (i.id === '-' && !i.right) ||
- i.id === '(string)' || i.id === '[' ||
- i.id === '{' || i.id === 'true' ||
- i.id === 'false' ||
- i.id === 'null' || i.id === 'undefined' ||
- i.id === 'Infinity') {
- warning("Use the array literal notation [].", token);
- }
- if (nexttoken.id !== ')') {
- error("Use the array literal notation [].", token);
- }
- }
- advance(')');
- }
- this.first = c;
- return this;
- case 'Number':
- case 'String':
- case 'Boolean':
- case 'Math':
- case 'JSON':
- warning("Do not use {a} as a constructor.", token, c.value);
- break;
- case 'Function':
- if (!option.evil) {
- warning("The Function constructor is eval.");
- }
- break;
- case 'Date':
- case 'RegExp':
- break;
- default:
- if (c.id !== 'function') {
- i = c.value.substr(0, 1);
- if (option.newcap && (i < 'A' || i > 'Z')) {
- warning(
- "A constructor name should start with an uppercase letter.",
- token);
- }
- }
- }
- } else {
- if (c.id !== '.' && c.id !== '[' && c.id !== '(') {
- warning("Bad constructor.", token);
- }
- }
- } else {
- warning("Weird construction. Delete 'new'.", this);
- }
- adjacent(token, nexttoken);
- if (nexttoken.id !== '(') {
- warning("Missing '()' invoking a constructor.");
- }
- this.first = c;
- return this;
- });
- syntax['new'].exps = true;
-
- infix('.', function (left, that) {
- adjacent(prevtoken, token);
- var m = identifier();
- if (typeof m === 'string') {
- countMember(m);
- }
- that.left = left;
- that.right = m;
- if (!option.evil && left && left.value === 'document' &&
- (m === 'write' || m === 'writeln')) {
- warning("document.write can be a form of eval.", left);
- } else if (option.adsafe) {
- if (left && left.value === 'ADSAFE') {
- if (m === 'id' || m === 'lib') {
- warning("ADsafe violation.", that);
- } else if (m === 'go') {
- if (xmode !== 'script') {
- warning("ADsafe violation.", that);
- } else if (adsafe_went || nexttoken.id !== '(' ||
- peek(0).id !== '(string)' ||
- peek(0).value !== adsafe_id ||
- peek(1).id !== ',') {
- error("ADsafe violation: go.", that);
- }
- adsafe_went = true;
- adsafe_may = false;
- }
- }
- }
- if (!option.evil && (m === 'eval' || m === 'execScript')) {
- warning('eval is evil.');
- } else if (option.safe) {
- for (;;) {
- if (banned[m] === true) {
- warning("ADsafe restricted word '{a}'.", token, m);
- }
- if (typeof predefined[left.value] !== 'boolean' ||
- nexttoken.id === '(') {
- break;
- }
- if (standard_member[m] === true) {
- if (nexttoken.id === '.') {
- warning("ADsafe violation.", that);
- }
- break;
- }
- if (nexttoken.id !== '.') {
- warning("ADsafe violation.", that);
- break;
- }
- advance('.');
- token.left = that;
- token.right = m;
- that = token;
- m = identifier();
- if (typeof m === 'string') {
- countMember(m);
- }
- }
- }
- return that;
- }, 160, true);
-
- infix('(', function (left, that) {
- adjacent(prevtoken, token);
- nospace();
- var n = 0,
- p = [];
- if (left) {
- if (left.type === '(identifier)') {
- if (left.value.match(/^[A-Z]([A-Z0-9_$]*[a-z][A-Za-z0-9_$]*)?$/)) {
- if (left.value !== 'Number' && left.value !== 'String' &&
- left.value !== 'Boolean' &&
- left.value !== 'Date') {
- if (left.value === 'Math') {
- warning("Math is not a function.", left);
- } else if (option.newcap) {
- warning(
-"Missing 'new' prefix when invoking a constructor.", left);
- }
- }
- }
- } else if (left.id === '.') {
- if (option.safe && left.left.value === 'Math' &&
- left.right === 'random') {
- warning("ADsafe violation.", left);
- }
- }
- }
- if (nexttoken.id !== ')') {
- for (;;) {
- p[p.length] = parse(10);
- n += 1;
- if (nexttoken.id !== ',') {
- break;
- }
- comma();
- }
- }
- advance(')');
- if (option.immed && left.id === 'function' && nexttoken.id !== ')') {
- warning("Wrap the entire immediate function invocation in parens.",
- that);
- }
- nospace(prevtoken, token);
- if (typeof left === 'object') {
- if (left.value === 'parseInt' && n === 1) {
- warning("Missing radix parameter.", left);
- }
- if (!option.evil) {
- if (left.value === 'eval' || left.value === 'Function' ||
- left.value === 'execScript') {
- warning("eval is evil.", left);
- } else if (p[0] && p[0].id === '(string)' &&
- (left.value === 'setTimeout' ||
- left.value === 'setInterval')) {
- warning(
- "Implied eval is evil. Pass a function instead of a string.", left);
- }
- }
- if (!left.identifier && left.id !== '.' && left.id !== '[' &&
- left.id !== '(' && left.id !== '&&' && left.id !== '||' &&
- left.id !== '?') {
- warning("Bad invocation.", left);
- }
- }
- that.left = left;
- return that;
- }, 155, true).exps = true;
-
- prefix('(', function () {
- nospace();
- var v = parse(0);
- advance(')', this);
- nospace(prevtoken, token);
- if (option.immed && v.id === 'function') {
- if (nexttoken.id === '(') {
- warning(
-"Move the invocation into the parens that contain the function.", nexttoken);
- } else {
- warning(
-"Do not wrap function literals in parens unless they are to be immediately invoked.",
- this);
- }
- }
- return v;
- });
-
- infix('[', function (left, that) {
- nospace();
- var e = parse(0), s;
- if (e && e.type === '(string)') {
- if (option.safe && banned[e.value] === true) {
- warning("ADsafe restricted word '{a}'.", that, e.value);
- } else if (!option.evil &&
- (e.value === 'eval' || e.value === 'execScript')) {
- warning("eval is evil.", that);
- } else if (option.safe &&
- (e.value.charAt(0) === '_' || e.value.charAt(0) === '-')) {
- warning("ADsafe restricted subscript '{a}'.", that, e.value);
- }
- countMember(e.value);
- if (!option.sub && ix.test(e.value)) {
- s = syntax[e.value];
- if (!s || !s.reserved) {
- warning("['{a}'] is better written in dot notation.",
- e, e.value);
- }
- }
- } else if (!e || e.type !== '(number)' || e.value < 0) {
- if (option.safe) {
- warning('ADsafe subscripting.');
- }
- }
- advance(']', that);
- nospace(prevtoken, token);
- that.left = left;
- that.right = e;
- return that;
- }, 160, true);
-
- prefix('[', function () {
- var b = token.line !== nexttoken.line;
- this.first = [];
- if (b) {
- indent += option.indent;
- if (nexttoken.from === indent + option.indent) {
- indent += option.indent;
- }
- }
- while (nexttoken.id !== '(end)') {
- while (nexttoken.id === ',') {
- warning("Extra comma.");
- advance(',');
- }
- if (nexttoken.id === ']') {
- break;
- }
- if (b && token.line !== nexttoken.line) {
- indentation();
- }
- this.first.push(parse(10));
- if (nexttoken.id === ',') {
- comma();
- if (nexttoken.id === ']') {
- warning("Extra comma.", token);
- break;
- }
- } else {
- break;
- }
- }
- if (b) {
- indent -= option.indent;
- indentation();
- }
- advance(']', this);
- return this;
- }, 160);
-
- (function (x) {
- x.nud = function () {
- var b, i, s, seen = {};
- b = token.line !== nexttoken.line;
- if (b) {
- indent += option.indent;
- if (nexttoken.from === indent + option.indent) {
- indent += option.indent;
- }
- }
- for (;;) {
- if (nexttoken.id === '}') {
- break;
- }
- if (b) {
- indentation();
- }
- i = optionalidentifier(true);
- if (!i) {
- if (nexttoken.id === '(string)') {
- i = nexttoken.value;
- if (ix.test(i)) {
- s = syntax[i];
- }
- advance();
- } else if (nexttoken.id === '(number)') {
- i = nexttoken.value.toString();
- advance();
- } else {
- error("Expected '{a}' and instead saw '{b}'.",
- nexttoken, '}', nexttoken.value);
- }
- }
- if (seen[i] === true) {
- warning("Duplicate member '{a}'.", nexttoken, i);
- }
- seen[i] = true;
- countMember(i);
- advance(':');
- nonadjacent(token, nexttoken);
- parse(10);
- if (nexttoken.id === ',') {
- comma();
- if (nexttoken.id === ',' || nexttoken.id === '}') {
- warning("Extra comma.", token);
- }
- } else {
- break;
- }
- }
- if (b) {
- indent -= option.indent;
- indentation();
- }
- advance('}', this);
- return this;
- };
- x.fud = function () {
- error("Expected to see a statement and instead saw a block.", token);
- };
- }(delim('{')));
-
-
- function varstatement(prefix) {
-
-// JavaScript does not have block scope. It only has function scope. So,
-// declaring a variable in a block can have unexpected consequences.
-
- var id, name, value;
-
- if (funct['(onevar)'] && option.onevar) {
- warning("Too many var statements.");
- } else if (!funct['(global)']) {
- funct['(onevar)'] = true;
- }
- this.first = [];
- for (;;) {
- nonadjacent(token, nexttoken);
- id = identifier();
- if (funct['(global)'] && predefined[id] === false) {
- warning("Redefinition of '{a}'.", token, id);
- }
- addlabel(id, 'unused');
- if (prefix) {
- break;
- }
- name = token;
- this.first.push(token);
- if (nexttoken.id === '=') {
- nonadjacent(token, nexttoken);
- advance('=');
- nonadjacent(token, nexttoken);
- if (nexttoken.id === 'undefined') {
- warning("It is not necessary to initialize '{a}' to 'undefined'.", token, id);
- }
- if (peek(0).id === '=' && nexttoken.identifier) {
- error("Variable {a} was not declared correctly.",
- nexttoken, nexttoken.value);
- }
- value = parse(0);
- name.first = value;
- }
- if (nexttoken.id !== ',') {
- break;
- }
- comma();
- }
- return this;
- }
-
-
- stmt('var', varstatement).exps = true;
-
-
- function functionparams() {
- var i, t = nexttoken, p = [];
- advance('(');
- nospace();
- if (nexttoken.id === ')') {
- advance(')');
- nospace(prevtoken, token);
- return;
- }
- for (;;) {
- i = identifier();
- p.push(i);
- addlabel(i, 'parameter');
- if (nexttoken.id === ',') {
- comma();
- } else {
- advance(')', t);
- nospace(prevtoken, token);
- return p;
- }
- }
- }
-
- function doFunction(i) {
- var s = scope;
- scope = Object.create(s);
- funct = {
- '(name)' : i || '"' + anonname + '"',
- '(line)' : nexttoken.line,
- '(context)' : funct,
- '(breakage)': 0,
- '(loopage)' : 0,
- '(scope)' : scope
- };
- token.funct = funct;
- functions.push(funct);
- if (i) {
- addlabel(i, 'function');
- }
- funct['(params)'] = functionparams();
-
- block(false);
- scope = s;
- funct['(last)'] = token.line;
- funct = funct['(context)'];
- }
-
-
- blockstmt('function', function () {
- if (inblock) {
- warning(
-"Function statements cannot be placed in blocks. Use a function expression or move the statement to the top of the outer function.", token);
-
- }
- var i = identifier();
- adjacent(token, nexttoken);
- addlabel(i, 'unused');
- doFunction(i);
- if (nexttoken.id === '(' && nexttoken.line === token.line) {
- error(
-"Function statements are not invocable. Wrap the whole function invocation in parens.");
- }
- return this;
- });
-
- prefix('function', function () {
- var i = optionalidentifier();
- if (i) {
- adjacent(token, nexttoken);
- } else {
- nonadjacent(token, nexttoken);
- }
- doFunction(i);
- if (funct['(loopage)']) {
- warning("Don't make functions within a loop.");
- }
- return this;
- });
-
- blockstmt('if', function () {
- var t = nexttoken;
- advance('(');
- nonadjacent(this, t);
- nospace();
- parse(20);
- if (nexttoken.id === '=') {
- warning("Expected a conditional expression and instead saw an assignment.");
- advance('=');
- parse(20);
- }
- advance(')', t);
- nospace(prevtoken, token);
- block(true);
- if (nexttoken.id === 'else') {
- nonadjacent(token, nexttoken);
- advance('else');
- if (nexttoken.id === 'if' || nexttoken.id === 'switch') {
- statement(true);
- } else {
- block(true);
- }
- }
- return this;
- });
-
- blockstmt('try', function () {
- var b, e, s;
- if (option.adsafe) {
- warning("ADsafe try violation.", this);
- }
- block(false);
- if (nexttoken.id === 'catch') {
- advance('catch');
- nonadjacent(token, nexttoken);
- advance('(');
- s = scope;
- scope = Object.create(s);
- e = nexttoken.value;
- if (nexttoken.type !== '(identifier)') {
- warning("Expected an identifier and instead saw '{a}'.",
- nexttoken, e);
- } else {
- addlabel(e, 'exception');
- }
- advance();
- advance(')');
- block(false);
- b = true;
- scope = s;
- }
- if (nexttoken.id === 'finally') {
- advance('finally');
- block(false);
- return;
- } else if (!b) {
- error("Expected '{a}' and instead saw '{b}'.",
- nexttoken, 'catch', nexttoken.value);
- }
- return this;
- });
-
- blockstmt('while', function () {
- var t = nexttoken;
- funct['(breakage)'] += 1;
- funct['(loopage)'] += 1;
- advance('(');
- nonadjacent(this, t);
- nospace();
- parse(20);
- if (nexttoken.id === '=') {
- warning("Expected a conditional expression and instead saw an assignment.");
- advance('=');
- parse(20);
- }
- advance(')', t);
- nospace(prevtoken, token);
- block(true);
- funct['(breakage)'] -= 1;
- funct['(loopage)'] -= 1;
- return this;
- }).labelled = true;
-
- reserve('with');
-
- blockstmt('switch', function () {
- var t = nexttoken,
- g = false;
- funct['(breakage)'] += 1;
- advance('(');
- nonadjacent(this, t);
- nospace();
- this.condition = parse(20);
- advance(')', t);
- nospace(prevtoken, token);
- nonadjacent(token, nexttoken);
- t = nexttoken;
- advance('{');
- nonadjacent(token, nexttoken);
- indent += option.indent;
- this.cases = [];
- for (;;) {
- switch (nexttoken.id) {
- case 'case':
- switch (funct['(verb)']) {
- case 'break':
- case 'case':
- case 'continue':
- case 'return':
- case 'switch':
- case 'throw':
- break;
- default:
- warning(
- "Expected a 'break' statement before 'case'.",
- token);
- }
- indentation(-option.indent);
- advance('case');
- this.cases.push(parse(20));
- g = true;
- advance(':');
- funct['(verb)'] = 'case';
- break;
- case 'default':
- switch (funct['(verb)']) {
- case 'break':
- case 'continue':
- case 'return':
- case 'throw':
- break;
- default:
- warning(
- "Expected a 'break' statement before 'default'.",
- token);
- }
- indentation(-option.indent);
- advance('default');
- g = true;
- advance(':');
- break;
- case '}':
- indent -= option.indent;
- indentation();
- advance('}', t);
- if (this.cases.length === 1 || this.condition.id === 'true' ||
- this.condition.id === 'false') {
- warning("This 'switch' should be an 'if'.", this);
- }
- funct['(breakage)'] -= 1;
- funct['(verb)'] = undefined;
- return;
- case '(end)':
- error("Missing '{a}'.", nexttoken, '}');
- return;
- default:
- if (g) {
- switch (token.id) {
- case ',':
- error("Each value should have its own case label.");
- return;
- case ':':
- statements();
- break;
- default:
- error("Missing ':' on a case clause.", token);
- }
- } else {
- error("Expected '{a}' and instead saw '{b}'.",
- nexttoken, 'case', nexttoken.value);
- }
- }
- }
- }).labelled = true;
-
- stmt('debugger', function () {
- if (!option.debug) {
- warning("All 'debugger' statements should be removed.");
- }
- return this;
- }).exps = true;
-
- (function () {
- var x = stmt('do', function () {
- funct['(breakage)'] += 1;
- funct['(loopage)'] += 1;
- this.first = block(true);
- advance('while');
- var t = nexttoken;
- nonadjacent(token, t);
- advance('(');
- nospace();
- parse(20);
- if (nexttoken.id === '=') {
- warning("Expected a conditional expression and instead saw an assignment.");
- advance('=');
- parse(20);
- }
- advance(')', t);
- nospace(prevtoken, token);
- funct['(breakage)'] -= 1;
- funct['(loopage)'] -= 1;
- return this;
- });
- x.labelled = true;
- x.exps = true;
- }());
-
- blockstmt('for', function () {
- var f = option.forin, s, t = nexttoken;
- funct['(breakage)'] += 1;
- funct['(loopage)'] += 1;
- advance('(');
- nonadjacent(this, t);
- nospace();
- if (peek(nexttoken.id === 'var' ? 1 : 0).id === 'in') {
- if (nexttoken.id === 'var') {
- advance('var');
- varstatement(true);
- } else {
- switch (funct[nexttoken.value]) {
- case 'unused':
- funct[nexttoken.value] = 'var';
- break;
- case 'var':
- break;
- default:
- warning("Bad for in variable '{a}'.",
- nexttoken, nexttoken.value);
- }
- advance();
- }
- advance('in');
- parse(20);
- advance(')', t);
- s = block(true);
- if (!f && (s.length > 1 || typeof s[0] !== 'object' ||
- s[0].value !== 'if')) {
- warning("The body of a for in should be wrapped in an if statement to filter unwanted properties from the prototype.", this);
- }
- funct['(breakage)'] -= 1;
- funct['(loopage)'] -= 1;
- return this;
- } else {
- if (nexttoken.id !== ';') {
- if (nexttoken.id === 'var') {
- advance('var');
- varstatement();
- } else {
- for (;;) {
- parse(0, 'for');
- if (nexttoken.id !== ',') {
- break;
- }
- comma();
- }
- }
- }
- nolinebreak(token);
- advance(';');
- if (nexttoken.id !== ';') {
- parse(20);
- if (nexttoken.id === '=') {
- warning("Expected a conditional expression and instead saw an assignment.");
- advance('=');
- parse(20);
- }
- }
- nolinebreak(token);
- advance(';');
- if (nexttoken.id === ';') {
- error("Expected '{a}' and instead saw '{b}'.",
- nexttoken, ')', ';');
- }
- if (nexttoken.id !== ')') {
- for (;;) {
- parse(0, 'for');
- if (nexttoken.id !== ',') {
- break;
- }
- comma();
- }
- }
- advance(')', t);
- nospace(prevtoken, token);
- block(true);
- funct['(breakage)'] -= 1;
- funct['(loopage)'] -= 1;
- return this;
- }
- }).labelled = true;
-
-
- stmt('break', function () {
- var v = nexttoken.value;
- if (funct['(breakage)'] === 0) {
- warning("Unexpected '{a}'.", nexttoken, this.value);
- }
- nolinebreak(this);
- if (nexttoken.id !== ';') {
- if (token.line === nexttoken.line) {
- if (funct[v] !== 'label') {
- warning("'{a}' is not a statement label.", nexttoken, v);
- } else if (scope[v] !== funct) {
- warning("'{a}' is out of scope.", nexttoken, v);
- }
- this.first = nexttoken;
- advance();
- }
- }
- reachable('break');
- return this;
- }).exps = true;
-
-
- stmt('continue', function () {
- var v = nexttoken.value;
- if (funct['(breakage)'] === 0) {
- warning("Unexpected '{a}'.", nexttoken, this.value);
- }
- nolinebreak(this);
- if (nexttoken.id !== ';') {
- if (token.line === nexttoken.line) {
- if (funct[v] !== 'label') {
- warning("'{a}' is not a statement label.", nexttoken, v);
- } else if (scope[v] !== funct) {
- warning("'{a}' is out of scope.", nexttoken, v);
- }
- this.first = nexttoken;
- advance();
- }
- } else if (!funct['(loopage)']) {
- warning("Unexpected '{a}'.", nexttoken, this.value);
- }
- reachable('continue');
- return this;
- }).exps = true;
-
-
- stmt('return', function () {
- nolinebreak(this);
- if (nexttoken.id === '(regexp)') {
- warning("Wrap the /regexp/ literal in parens to disambiguate the slash operator.");
- }
- if (nexttoken.id !== ';' && !nexttoken.reach) {
- nonadjacent(token, nexttoken);
- this.first = parse(20);
- }
- reachable('return');
- return this;
- }).exps = true;
-
-
- stmt('throw', function () {
- nolinebreak(this);
- nonadjacent(token, nexttoken);
- this.first = parse(20);
- reachable('throw');
- return this;
- }).exps = true;
-
- reserve('void');
-
-// Superfluous reserved words
-
- reserve('class');
- reserve('const');
- reserve('enum');
- reserve('export');
- reserve('extends');
- reserve('import');
- reserve('super');
-
- reserve('let');
- reserve('yield');
- reserve('implements');
- reserve('interface');
- reserve('package');
- reserve('private');
- reserve('protected');
- reserve('public');
- reserve('static');
-
- function jsonValue() {
-
- function jsonObject() {
- var o = {}, t = nexttoken;
- advance('{');
- if (nexttoken.id !== '}') {
- for (;;) {
- if (nexttoken.id === '(end)') {
- error("Missing '}' to match '{' from line {a}.",
- nexttoken, t.line);
- } else if (nexttoken.id === '}') {
- warning("Unexpected comma.", token);
- break;
- } else if (nexttoken.id === ',') {
- error("Unexpected comma.", nexttoken);
- } else if (nexttoken.id !== '(string)') {
- warning("Expected a string and instead saw {a}.",
- nexttoken, nexttoken.value);
- }
- if (o[nexttoken.value] === true) {
- warning("Duplicate key '{a}'.",
- nexttoken, nexttoken.value);
- } else if (nexttoken.value === '__proto__') {
- warning("Stupid key '{a}'.",
- nexttoken, nexttoken.value);
- } else {
- o[nexttoken.value] = true;
- }
- advance();
- advance(':');
- jsonValue();
- if (nexttoken.id !== ',') {
- break;
- }
- advance(',');
- }
- }
- advance('}');
- }
-
- function jsonArray() {
- var t = nexttoken;
- advance('[');
- if (nexttoken.id !== ']') {
- for (;;) {
- if (nexttoken.id === '(end)') {
- error("Missing ']' to match '[' from line {a}.",
- nexttoken, t.line);
- } else if (nexttoken.id === ']') {
- warning("Unexpected comma.", token);
- break;
- } else if (nexttoken.id === ',') {
- error("Unexpected comma.", nexttoken);
- }
- jsonValue();
- if (nexttoken.id !== ',') {
- break;
- }
- advance(',');
- }
- }
- advance(']');
- }
-
- switch (nexttoken.id) {
- case '{':
- jsonObject();
- break;
- case '[':
- jsonArray();
- break;
- case 'true':
- case 'false':
- case 'null':
- case '(number)':
- case '(string)':
- advance();
- break;
- case '-':
- advance('-');
- if (token.character !== nexttoken.from) {
- warning("Unexpected space after '-'.", token);
- }
- adjacent(token, nexttoken);
- advance('(number)');
- break;
- default:
- error("Expected a JSON value.", nexttoken);
- }
- }
-
-
-// The actual JSLINT function itself.
-
- var itself = function (s, o) {
- var a, i;
- JSLINT.errors = [];
- predefined = Object.create(standard);
- if (o) {
- a = o.predef;
- if (a instanceof Array) {
- for (i = 0; i < a.length; i += 1) {
- predefined[a[i]] = true;
- }
- }
- if (o.adsafe) {
- o.safe = true;
- }
- if (o.safe) {
- o.browser = false;
- o.css = false;
- o.debug = false;
- o.devel = false;
- o.eqeqeq = true;
- o.evil = false;
- o.forin = false;
- o.nomen = true;
- o.on = false;
- o.rhino = false;
- o.safe = true;
- o.sidebar = false;
- o.strict = true;
- o.sub = false;
- o.undef = true;
- o.widget = false;
- predefined.Date = null;
- predefined['eval'] = null;
- predefined.Function = null;
- predefined.Object = null;
- predefined.ADSAFE = false;
- predefined.lib = false;
- }
- option = o;
- } else {
- option = {};
- }
- option.indent = option.indent || 4;
- option.maxerr = option.maxerr || 50;
- adsafe_id = '';
- adsafe_may = false;
- adsafe_went = false;
- approved = {};
- if (option.approved) {
- for (i = 0; i < option.approved.length; i += 1) {
- approved[option.approved[i]] = option.approved[i];
- }
- } else {
- approved.test = 'test';
- }
- tab = '';
- for (i = 0; i < option.indent; i += 1) {
- tab += ' ';
- }
- indent = 1;
- global = Object.create(predefined);
- scope = global;
- funct = {
- '(global)': true,
- '(name)': '(global)',
- '(scope)': scope,
- '(breakage)': 0,
- '(loopage)': 0
- };
- functions = [funct];
- ids = {};
- urls = [];
- src = false;
- xmode = false;
- stack = null;
- member = {};
- membersOnly = null;
- implied = {};
- inblock = false;
- lookahead = [];
- jsonmode = false;
- warnings = 0;
- lex.init(s);
- prereg = true;
- strict_mode = false;
-
- prevtoken = token = nexttoken = syntax['(begin)'];
- assume();
-
- try {
- advance();
- if (nexttoken.value.charAt(0) === '<') {
- html();
- if (option.adsafe && !adsafe_went) {
- warning("ADsafe violation: Missing ADSAFE.go.", this);
- }
- } else {
- switch (nexttoken.id) {
- case '{':
- case '[':
- option.laxbreak = true;
- jsonmode = true;
- jsonValue();
- break;
- case '@':
- case '*':
- case '#':
- case '.':
- case ':':
- xmode = 'style';
- advance();
- if (token.id !== '@' || !nexttoken.identifier ||
- nexttoken.value !== 'charset' || token.line !== 1 ||
- token.from !== 1) {
- error('A css file should begin with @charset "UTF-8";');
- }
- advance();
- if (nexttoken.type !== '(string)' &&
- nexttoken.value !== 'UTF-8') {
- error('A css file should begin with @charset "UTF-8";');
- }
- advance();
- advance(';');
- styles();
- break;
-
- default:
- if (option.adsafe && option.fragment) {
- error("Expected '{a}' and instead saw '{b}'.",
- nexttoken, '', nexttoken.value);
- }
- statements('lib');
- }
- }
- advance('(end)');
- } catch (e) {
- if (e) {
- JSLINT.errors.push({
- reason : e.message,
- line : e.line || nexttoken.line,
- character : e.character || nexttoken.from
- }, null);
- }
- }
- return JSLINT.errors.length === 0;
- };
-
- function is_array(o) {
- return Object.prototype.toString.apply(o) === '[object Array]';
- }
-
- function to_array(o) {
- var a = [], k;
- for (k in o) {
- if (is_own(o, k)) {
- a.push(k);
- }
- }
- return a;
- }
-
-// Data summary.
-
- itself.data = function () {
-
- var data = {functions: []}, fu, globals, implieds = [], f, i, j,
- members = [], n, unused = [], v;
- if (itself.errors.length) {
- data.errors = itself.errors;
- }
-
- if (jsonmode) {
- data.json = true;
- }
-
- for (n in implied) {
- if (is_own(implied, n)) {
- implieds.push({
- name: n,
- line: implied[n]
- });
- }
- }
- if (implieds.length > 0) {
- data.implieds = implieds;
- }
-
- if (urls.length > 0) {
- data.urls = urls;
- }
-
- globals = to_array(scope);
- if (globals.length > 0) {
- data.globals = globals;
- }
-
- for (i = 1; i < functions.length; i += 1) {
- f = functions[i];
- fu = {};
- for (j = 0; j < functionicity.length; j += 1) {
- fu[functionicity[j]] = [];
- }
- for (n in f) {
- if (is_own(f, n) && n.charAt(0) !== '(') {
- v = f[n];
- if (is_array(fu[v])) {
- fu[v].push(n);
- if (v === 'unused') {
- unused.push({
- name: n,
- line: f['(line)'],
- 'function': f['(name)']
- });
- }
- }
- }
- }
- for (j = 0; j < functionicity.length; j += 1) {
- if (fu[functionicity[j]].length === 0) {
- delete fu[functionicity[j]];
- }
- }
- fu.name = f['(name)'];
- fu.param = f['(params)'];
- fu.line = f['(line)'];
- fu.last = f['(last)'];
- data.functions.push(fu);
- }
-
- if (unused.length > 0) {
- data.unused = unused;
- }
-
- members = [];
- for (n in member) {
- if (typeof member[n] === 'number') {
- data.member = member;
- break;
- }
- }
-
- return data;
- };
-
- itself.report = function (option) {
- var data = itself.data();
-
- var a = [], c, e, err, f, i, k, l, m = '', n, o = [], s;
-
- function detail(h, array) {
- var b, i, singularity;
- if (array) {
- o.push('' + h + ' ');
- array = array.sort();
- for (i = 0; i < array.length; i += 1) {
- if (array[i] !== singularity) {
- singularity = array[i];
- o.push((b ? ', ' : '') + singularity);
- b = true;
- }
- }
- o.push('');
- }
- }
-
-
- if (data.errors || data.implieds || data.unused) {
- err = true;
- o.push('Error:');
- if (data.errors) {
- for (i = 0; i < data.errors.length; i += 1) {
- c = data.errors[i];
- if (c) {
- e = c.evidence || '';
- o.push('Problem' + (isFinite(c.line) ? ' at line ' +
- c.line + ' character ' + c.character : '') +
- ': ' + c.reason.entityify() +
- '
' +
- (e && (e.length > 80 ? e.slice(0, 77) + '...' :
- e).entityify()) + '
');
- }
- }
- }
-
- if (data.implieds) {
- s = [];
- for (i = 0; i < data.implieds.length; i += 1) {
- s[i] = '' + data.implieds[i].name + ' ' +
- data.implieds[i].line + '';
- }
- o.push('Implied global: ' + s.join(', ') + '
');
- }
-
- if (data.unused) {
- s = [];
- for (i = 0; i < data.unused.length; i += 1) {
- s[i] = '' + data.unused[i].name + ' ' +
- data.unused[i].line + ' ' +
- data.unused[i]['function'] + '';
- }
- o.push('Unused variable: ' + s.join(', ') + '
');
- }
- if (data.json) {
- o.push('JSON: bad.
');
- }
- o.push('');
- }
-
- if (!option) {
-
- o.push('
');
-
- if (data.urls) {
- detail("URLs
", data.urls, '
');
- }
-
- if (xmode === 'style') {
- o.push('CSS.
');
- } else if (data.json && !err) {
- o.push('JSON: good.
');
- } else if (data.globals) {
- o.push('Global ' +
- data.globals.sort().join(', ') + '');
- } else {
- o.push('No new global variables introduced.');
- }
-
- for (i = 0; i < data.functions.length; i += 1) {
- f = data.functions[i];
-
- o.push('
' + f.line + '-' +
- f.last + ' ' + (f.name || '') + '(' +
- (f.param ? f.param.join(', ') : '') + ')');
- detail('Unused', f.unused);
- detail('Closure', f.closure);
- detail('Variable', f['var']);
- detail('Exception', f.exception);
- detail('Outer', f.outer);
- detail('Global', f.global);
- detail('Label', f.label);
- }
-
- if (data.member) {
- a = to_array(data.member);
- if (a.length) {
- a = a.sort();
- m = '
/*members ';
- l = 10;
- for (i = 0; i < a.length; i += 1) {
- k = a[i];
- n = k.name();
- if (l + n.length > 72) {
- o.push(m + '
');
- m = ' ';
- l = 1;
- }
- l += n.length + 2;
- if (data.member[k] === 1) {
- n = '' + n + '';
- }
- if (i < a.length - 1) {
- n += ', ';
- }
- m += n;
- }
- o.push(m + '
*/');
- }
- o.push('');
- }
- }
- return o.join('');
- };
- itself.jslint = itself;
-
- itself.edition = '2010-03-02';
-
- return itself;
-
-}());
-
-// rhino.js
-// 2009-09-11
-/*
-Copyright (c) 2002 Douglas Crockford (www.JSLint.com) Rhino Edition
-*/
-
-// This is the Rhino companion to fulljslint.js.
-
-/*global JSLINT */
-/*jslint rhino: true, strict: false */
-
-(function (a) {
- var e, i, input;
- if (!a[0]) {
- print("Usage: jslint.js file.js");
- quit(1);
- }
- input = readFile(a[0]);
- if (!input) {
- print("jslint: Couldn't open file '" + a[0] + "'.");
- quit(1);
- }
- if (!JSLINT(input, {
- bitwise: true, eqeqeq: true, immed: true, newcap: true, nomen: true, onevar: true, rhino: true, undef: true, browser: true,
- predef: [ "window", "xui", "emile", "string" ]
- })) {
- for (i = 0; i < JSLINT.errors.length; i += 1) {
- e = JSLINT.errors[i];
- if (e) {
- print('Lint at line ' + e.line + ' character ' +
- e.character + ': ' + e.reason);
- print((e.evidence || '').
- replace(/^\s*(\S*(\s+\S+)*)\s*$/, "$1"));
- print('');
- }
- }
- quit(2);
- } else {
- print("jslint: No problems found in " + a[0]);
- quit();
- }
-}(arguments));
\ No newline at end of file
' + name + '
'; + html += '- ';
+ },
+ testDone: function (name, assertions) {
+ if (!assertions.failures()) {
+ html += '
- ' + name + ' '; + } + else { + html += '
- ' + name;
+ for (var i=0; i
'; + html += a.error.stack || a.error; + html += '
'; + } + }; + html += ' ';
+ }
+ },
+ moduleDone: function () {
+ html += '
FAILURES: ' + assertions.failures() + + '/' + assertions.length + ' assertions failed (' + + assertions.duration + 'ms)
'; + } + else { + html += 'OK: ' + assertions.length + + ' assertions (' + assertions.duration + 'ms)
'; + } + document.body.innerHTML += html; + } + }); +}; +})(reporter); +nodeunit = core; +nodeunit.assert = assert; +nodeunit.reporter = reporter; +nodeunit.run = reporter.run; +return nodeunit; })(); diff --git a/bin/node_modules/nodeunit/examples/browser/suite1.js b/bin/node_modules/nodeunit/examples/browser/suite1.js new file mode 100644 index 00000000..0d5fc90e --- /dev/null +++ b/bin/node_modules/nodeunit/examples/browser/suite1.js @@ -0,0 +1,12 @@ +this.suite1 = { + 'test one': function (test) { + test.ok(true, 'everythings ok'); + setTimeout(function () { + test.done(); + }, 10); + }, + 'apples and oranges': function (test) { + test.equal('apples', 'oranges', 'comparing apples and oranges'); + test.done(); + } +}; diff --git a/bin/node_modules/nodeunit/examples/browser/suite2.js b/bin/node_modules/nodeunit/examples/browser/suite2.js new file mode 100644 index 00000000..c7288e8d --- /dev/null +++ b/bin/node_modules/nodeunit/examples/browser/suite2.js @@ -0,0 +1,13 @@ +this.suite2 = { + 'another test': function (test) { + setTimeout(function () { + // lots of assertions + test.ok(true, 'everythings ok'); + test.ok(true, 'everythings ok'); + test.ok(true, 'everythings ok'); + test.ok(true, 'everythings ok'); + test.ok(true, 'everythings ok'); + test.done(); + }, 10); + } +}; diff --git a/bin/node_modules/nodeunit/examples/browser/test.html b/bin/node_modules/nodeunit/examples/browser/test.html new file mode 100644 index 00000000..e9f8180f --- /dev/null +++ b/bin/node_modules/nodeunit/examples/browser/test.html @@ -0,0 +1,16 @@ + + +' + + assertions.passes() + ' assertions of ' + + '' + assertions.length + ' passed, ' + + assertions.failures() + ' failed.'; + } + }); +}; diff --git a/bin/node_modules/nodeunit/lib/reporters/default.js b/bin/node_modules/nodeunit/lib/reporters/default.js new file mode 100644 index 00000000..279f5607 --- /dev/null +++ b/bin/node_modules/nodeunit/lib/reporters/default.js @@ -0,0 +1,123 @@ +/*! + * Nodeunit + * Copyright (c) 2010 Caolan McMahon + * MIT Licensed + */ + +/** + * Module dependencies + */ + +var nodeunit = require('../nodeunit'), + utils = require('../utils'), + fs = require('fs'), + track = require('../track'), + path = require('path'); + AssertionError = require('../assert').AssertionError; + +/** + * Reporter info string + */ + +exports.info = "Default tests reporter"; + + +/** + * Run all tests within each module, reporting the results to the command-line. + * + * @param {Array} files + * @api public + */ + +exports.run = function (files, options) { + + if (!options) { + // load default options + var content = fs.readFileSync( + __dirname + '/../../bin/nodeunit.json', 'utf8' + ); + options = JSON.parse(content); + } + + var error = function (str) { + return options.error_prefix + str + options.error_suffix; + }; + var ok = function (str) { + return options.ok_prefix + str + options.ok_suffix; + }; + var bold = function (str) { + return options.bold_prefix + str + options.bold_suffix; + }; + var assertion_message = function (str) { + return options.assertion_prefix + str + options.assertion_suffix; + }; + + var start = new Date().getTime(); + var paths = files.map(function (p) { + return path.join(process.cwd(), p); + }); + var tracker = track.createTracker(function (tracker) { + if (tracker.unfinished()) { + console.log(''); + console.log(error(bold( + 'FAILURES: Undone tests (or their setups/teardowns): ' + ))); + var names = tracker.names(); + for (var i = 0; i < names.length; i += 1) { + console.log('- ' + names[i]); + } + console.log(''); + console.log('To fix this, make sure all tests call test.done()'); + process.reallyExit(tracker.unfinished()); + } + }); + + nodeunit.runFiles(paths, { + testspec: options.testspec, + moduleStart: function (name) { + console.log('\n' + bold(name)); + }, + testDone: function (name, assertions) { + tracker.remove(name); + + if (!assertions.failures()) { + console.log('✔ ' + name); + } + else { + console.log(error('✖ ' + name) + '\n'); + assertions.forEach(function (a) { + if (a.failed()) { + a = utils.betterErrors(a); + if (a.error instanceof AssertionError && a.message) { + console.log( + 'Assertion Message: ' + + assertion_message(a.message) + ); + } + console.log(a.error.stack + '\n'); + } + }); + } + }, + done: function (assertions, end) { + var end = end || new Date().getTime(); + var duration = end - start; + if (assertions.failures()) { + console.log( + '\n' + bold(error('FAILURES: ')) + assertions.failures() + + '/' + assertions.length + ' assertions failed (' + + assertions.duration + 'ms)' + ); + } + else { + console.log( + '\n' + bold(ok('OK: ')) + assertions.length + + ' assertions (' + assertions.duration + 'ms)' + ); + } + }, + testStart: function(name) { + tracker.put(name); + } + }); +}; diff --git a/bin/node_modules/nodeunit/lib/reporters/html.js b/bin/node_modules/nodeunit/lib/reporters/html.js new file mode 100644 index 00000000..05fb4036 --- /dev/null +++ b/bin/node_modules/nodeunit/lib/reporters/html.js @@ -0,0 +1,107 @@ +/*! + * Nodeunit + * Copyright (c) 2010 Caolan McMahon + * MIT Licensed + */ + +/** + * Module dependencies + */ + +var nodeunit = require('../nodeunit'), + utils = require('../utils'), + fs = require('fs'), + path = require('path'), + AssertionError = require('assert').AssertionError; + +/** + * Reporter info string + */ + +exports.info = "Report tests result as HTML"; + +/** + * Run all tests within each module, reporting the results to the command-line. + * + * @param {Array} files + * @api public + */ + +exports.run = function (files, options) { + + var start = new Date().getTime(); + var paths = files.map(function (p) { + return path.join(process.cwd(), p); + }); + + console.log(''); + console.log(''); + console.log('
' + name + '
'); + console.log('- ');
+ },
+ testDone: function (name, assertions) {
+ if (!assertions.failures()) {
+ console.log('
- ' + name + ' '); + } + else { + console.log('
- ' + name);
+ assertions.forEach(function (a) {
+ if (a.failed()) {
+ a = utils.betterErrors(a);
+ if (a.error instanceof AssertionError && a.message) {
+ console.log('');
+ }
+ console.log('
'); + console.log(a.error.stack); + console.log(''); + } + }); + console.log(' ');
+ }
+ },
+ moduleDone: function () {
+ console.log('
FAILURES: ' + assertions.failures() + + '/' + assertions.length + ' assertions failed (' + + assertions.duration + 'ms)
' + ); + } + else { + console.log( + 'OK: ' + assertions.length + + ' assertions (' + assertions.duration + 'ms)
' + ); + } + console.log(''); + } + }); + +}; diff --git a/bin/node_modules/nodeunit/lib/reporters/index.js b/bin/node_modules/nodeunit/lib/reporters/index.js new file mode 100644 index 00000000..bbaf800d --- /dev/null +++ b/bin/node_modules/nodeunit/lib/reporters/index.js @@ -0,0 +1,9 @@ +module.exports = { + 'junit': require('./junit'), + 'default': require('./default'), + 'skip_passed': require('./skip_passed'), + 'minimal': require('./minimal'), + 'html': require('./html') + // browser test reporter is not listed because it cannot be used + // with the command line tool, only inside a browser. +}; diff --git a/bin/node_modules/nodeunit/lib/reporters/junit.js b/bin/node_modules/nodeunit/lib/reporters/junit.js new file mode 100644 index 00000000..a542c695 --- /dev/null +++ b/bin/node_modules/nodeunit/lib/reporters/junit.js @@ -0,0 +1,183 @@ +/*! + * Nodeunit + * Copyright (c) 2010 Caolan McMahon + * MIT Licensed + */ + +/** + * Module dependencies + */ + +var nodeunit = require('../nodeunit'), + utils = require('../utils'), + fs = require('fs'), + path = require('path'), + async = require('../../deps/async'), + AssertionError = require('assert').AssertionError, + child_process = require('child_process'), + ejs = require('../../deps/ejs'); + + +/** + * Reporter info string + */ + +exports.info = "jUnit XML test reports"; + + +/** + * Ensures a directory exists using mkdir -p. + * + * @param {String} path + * @param {Function} callback + * @api private + */ + +var ensureDir = function (path, callback) { + var mkdir = child_process.spawn('mkdir', ['-p', path]); + mkdir.on('error', function (err) { + callback(err); + callback = function(){}; + }); + mkdir.on('exit', function (code) { + if (code === 0) callback(); + else callback(new Error('mkdir exited with code: ' + code)); + }); +}; + + +/** + * Returns absolute version of a path. Relative paths are interpreted + * relative to process.cwd() or the cwd parameter. Paths that are already + * absolute are returned unaltered. + * + * @param {String} p + * @param {String} cwd + * @return {String} + * @api public + */ + +var abspath = function (p, /*optional*/cwd) { + if (p[0] === '/') return p; + cwd = cwd || process.cwd(); + return path.normalize(path.join(cwd, p)); +}; + + +/** + * Run all tests within each module, reporting the results to the command-line, + * then writes out junit-compatible xml documents. + * + * @param {Array} files + * @api public + */ + +exports.run = function (files, opts, callback) { + if (!opts.output) { + console.error( + 'Error: No output directory defined.\n' + + '\tEither add an "output" property to your nodeunit.json config ' + + 'file, or\n\tuse the --output command line option.' + ); + return; + } + opts.output = abspath(opts.output); + var error = function (str) { + return opts.error_prefix + str + opts.error_suffix; + }; + var ok = function (str) { + return opts.ok_prefix + str + opts.ok_suffix; + }; + var bold = function (str) { + return opts.bold_prefix + str + opts.bold_suffix; + }; + + var start = new Date().getTime(); + var paths = files.map(function (p) { + return path.join(process.cwd(), p); + }); + + var modules = {} + var curModule; + + nodeunit.runFiles(paths, { + testspec: opts.testspec, + moduleStart: function (name) { + curModule = { + errorCount: 0, + failureCount: 0, + tests: 0, + testcases: [], + name: name + }; + modules[name] = curModule; + }, + testDone: function (name, assertions) { + var testcase = {name: name}; + for (var i=0; i', nexttoken.value);
- }
- statements('lib');
- }
- }
- advance('(end)');
- } catch (e) {
- if (e) {
- JSLINT.errors.push({
- reason : e.message,
- line : e.line || nexttoken.line,
- character : e.character || nexttoken.from
- }, null);
- }
- }
- return JSLINT.errors.length === 0;
- };
-
- function is_array(o) {
- return Object.prototype.toString.apply(o) === '[object Array]';
- }
-
- function to_array(o) {
- var a = [], k;
- for (k in o) {
- if (is_own(o, k)) {
- a.push(k);
- }
- }
- return a;
- }
-
-// Data summary.
-
- itself.data = function () {
-
- var data = {functions: []}, fu, globals, implieds = [], f, i, j,
- members = [], n, unused = [], v;
- if (itself.errors.length) {
- data.errors = itself.errors;
- }
-
- if (jsonmode) {
- data.json = true;
- }
-
- for (n in implied) {
- if (is_own(implied, n)) {
- implieds.push({
- name: n,
- line: implied[n]
- });
- }
- }
- if (implieds.length > 0) {
- data.implieds = implieds;
- }
-
- if (urls.length > 0) {
- data.urls = urls;
- }
-
- globals = to_array(scope);
- if (globals.length > 0) {
- data.globals = globals;
- }
-
- for (i = 1; i < functions.length; i += 1) {
- f = functions[i];
- fu = {};
- for (j = 0; j < functionicity.length; j += 1) {
- fu[functionicity[j]] = [];
- }
- for (n in f) {
- if (is_own(f, n) && n.charAt(0) !== '(') {
- v = f[n];
- if (is_array(fu[v])) {
- fu[v].push(n);
- if (v === 'unused') {
- unused.push({
- name: n,
- line: f['(line)'],
- 'function': f['(name)']
- });
- }
- }
- }
- }
- for (j = 0; j < functionicity.length; j += 1) {
- if (fu[functionicity[j]].length === 0) {
- delete fu[functionicity[j]];
- }
- }
- fu.name = f['(name)'];
- fu.param = f['(params)'];
- fu.line = f['(line)'];
- fu.last = f['(last)'];
- data.functions.push(fu);
- }
-
- if (unused.length > 0) {
- data.unused = unused;
- }
-
- members = [];
- for (n in member) {
- if (typeof member[n] === 'number') {
- data.member = member;
- break;
- }
- }
-
- return data;
- };
-
- itself.report = function (option) {
- var data = itself.data();
-
- var a = [], c, e, err, f, i, k, l, m = '', n, o = [], s;
-
- function detail(h, array) {
- var b, i, singularity;
- if (array) {
- o.push('
' + h + ' ');
- array = array.sort();
- for (i = 0; i < array.length; i += 1) {
- if (array[i] !== singularity) {
- singularity = array[i];
- o.push((b ? ', ' : '') + singularity);
- b = true;
- }
- }
- o.push('
');
- }
- }
-
-
- if (data.errors || data.implieds || data.unused) {
- err = true;
- o.push('Error:');
- if (data.errors) {
- for (i = 0; i < data.errors.length; i += 1) {
- c = data.errors[i];
- if (c) {
- e = c.evidence || '';
- o.push('
');
- }
-
- if (!option) {
-
- o.push('Problem' + (isFinite(c.line) ? ' at line ' + - c.line + ' character ' + c.character : '') + - ': ' + c.reason.entityify() + - '
' + - (e && (e.length > 80 ? e.slice(0, 77) + '...' : - e).entityify()) + '
'); - } - } - } - - if (data.implieds) { - s = []; - for (i = 0; i < data.implieds.length; i += 1) { - s[i] = '' + data.implieds[i].name + ' ' +
- data.implieds[i].line + '';
- }
- o.push('Implied global: ' + s.join(', ') + '
'); - } - - if (data.unused) { - s = []; - for (i = 0; i < data.unused.length; i += 1) { - s[i] = '' + data.unused[i].name + ' ' +
- data.unused[i].line + ' ' +
- data.unused[i]['function'] + '';
- }
- o.push('Unused variable: ' + s.join(', ') + '
'); - } - if (data.json) { - o.push('JSON: bad.
'); - } - o.push('');
-
- if (data.urls) {
- detail("URLs
", data.urls, '
'); - } - - if (xmode === 'style') { - o.push('
');
- }
- }
- return o.join('');
- };
- itself.jslint = itself;
-
- itself.edition = '2010-03-02';
-
- return itself;
-
-}());
-
-// rhino.js
-// 2009-09-11
-/*
-Copyright (c) 2002 Douglas Crockford (www.JSLint.com) Rhino Edition
-*/
-
-// This is the Rhino companion to fulljslint.js.
-
-/*global JSLINT */
-/*jslint rhino: true, strict: false */
-
-(function (a) {
- var e, i, input;
- if (!a[0]) {
- print("Usage: jslint.js file.js");
- quit(1);
- }
- input = readFile(a[0]);
- if (!input) {
- print("jslint: Couldn't open file '" + a[0] + "'.");
- quit(1);
- }
- if (!JSLINT(input, {
- bitwise: true, eqeqeq: true, immed: true, newcap: true, nomen: true, onevar: true, rhino: true, undef: true, browser: true,
- predef: [ "window", "xui", "emile", "string" ]
- })) {
- for (i = 0; i < JSLINT.errors.length; i += 1) {
- e = JSLINT.errors[i];
- if (e) {
- print('Lint at line ' + e.line + ' character ' +
- e.character + ': ' + e.reason);
- print((e.evidence || '').
- replace(/^\s*(\S*(\s+\S+)*)\s*$/, "$1"));
- print('');
- }
- }
- quit(2);
- } else {
- print("jslint: No problems found in " + a[0]);
- quit();
- }
-}(arguments));
\ No newline at end of file
", data.urls, '
'); - } - - if (xmode === 'style') { - o.push('
CSS.
'); - } else if (data.json && !err) { - o.push('JSON: good.
'); - } else if (data.globals) { - o.push('Global ' +
- data.globals.sort().join(', ') + '
');
- } else {
- o.push('No new global variables introduced.
');
- }
-
- for (i = 0; i < data.functions.length; i += 1) {
- f = data.functions[i];
-
- o.push('' + f.line + '-' +
- f.last + ' ' + (f.name || '') + '(' +
- (f.param ? f.param.join(', ') : '') + ')
');
- detail('Unused', f.unused);
- detail('Closure', f.closure);
- detail('Variable', f['var']);
- detail('Exception', f.exception);
- detail('Outer', f.outer);
- detail('Global', f.global);
- detail('Label', f.label);
- }
-
- if (data.member) {
- a = to_array(data.member);
- if (a.length) {
- a = a.sort();
- m = '/*members ';
- l = 10;
- for (i = 0; i < a.length; i += 1) {
- k = a[i];
- n = k.name();
- if (l + n.length > 72) {
- o.push(m + '
');
- m = ' ';
- l = 1;
- }
- l += n.length + 2;
- if (data.member[k] === 1) {
- n = '' + n + '';
- }
- if (i < a.length - 1) {
- n += ', ';
- }
- m += n;
- }
- o.push(m + '
*/');
- }
- o.push('