;(function(){

// CommonJS require()

function require(p){

var path = require.resolve(p)

, mod = require.modules[path];

if (!mod) throw new Error('failed to require "' + p + '"');

if (!mod.exports) {

mod.exports = {};

mod.call(mod.exports, mod, mod.exports, require.relative(path));

}

return mod.exports;

}

require.modules = {};

require.resolve = function (path){

var orig = path

, reg = path + '.js'

, index = path + '/index.js';

return require.modules[reg] && reg

|| require.modules[index] && index

|| orig;

};

require.register = function (path, fn){

require.modules[path] = fn;

};

require.relative = function (parent) {

return function(p){

if ('.' != p.charAt(0)) return require(p);

var path = parent.split('/')

, segs = p.split('/');

path.pop();

for (var i = 0; i < segs.length; i++) {

var seg = segs[i];

if ('..' == seg) path.pop();

else if ('.' != seg) path.push(seg);

}

return require(path.join('/'));

};

};

require.register("browser/debug.js", function(module, exports, require){

module.exports = function(type){

return function(){

}

};

}); // module: browser/debug.js

require.register("browser/diff.js", function(module, exports, require){

}); // module: browser/diff.js

require.register("browser/events.js", function(module, exports, require){

/**

* Module exports.

*/

exports.EventEmitter = EventEmitter;

/**

* Check if `obj` is an array.

*/

function isArray(obj) {

return '[object Array]' == {}.toString.call(obj);

}

/**

* Event emitter constructor.

*

* @api public

*/

function EventEmitter(){};

/**

* Adds a listener.

*

* @api public

*/

EventEmitter.prototype.on = function (name, fn) {

if (!this.$events) {

this.$events = {};

}

if (!this.$events[name]) {

this.$events[name] = fn;

} else if (isArray(this.$events[name])) {

this.$events[name].push(fn);

} else {

this.$events[name] = [this.$events[name], fn];

}

return this;

};

EventEmitter.prototype.addListener = EventEmitter.prototype.on;

/**

* Adds a volatile listener.

*

* @api public

*/

EventEmitter.prototype.once = function (name, fn) {

var self = this;

function on () {

self.removeListener(name, on);

fn.apply(this, arguments);

};

on.listener = fn;

this.on(name, on);

return this;

};

/**

* Removes a listener.

*

* @api public

*/

EventEmitter.prototype.removeListener = function (name, fn) {

if (this.$events && this.$events[name]) {

var list = this.$events[name];

if (isArray(list)) {

var pos = -1;

for (var i = 0, l = list.length; i < l; i++) {

if (list[i] === fn || (list[i].listener && list[i].listener === fn)) {

pos = i;

break;

}

}

if (pos < 0) {

return this;

}

list.splice(pos, 1);

if (!list.length) {

delete this.$events[name];

}

} else if (list === fn || (list.listener && list.listener === fn)) {

delete this.$events[name];

}

}

return this;

};

/**

* Removes all listeners for an event.

*

* @api public

*/

EventEmitter.prototype.removeAllListeners = function (name) {

if (name === undefined) {

this.$events = {};

return this;

}

if (this.$events && this.$events[name]) {

this.$events[name] = null;

}

return this;

};

/**

* Gets all listeners for a certain event.

*

* @api public

*/

EventEmitter.prototype.listeners = function (name) {

if (!this.$events) {

this.$events = {};

}

if (!this.$events[name]) {

this.$events[name] = [];

}

if (!isArray(this.$events[name])) {

this.$events[name] = [this.$events[name]];

}

return this.$events[name];

};

/**

* Emits an event.

*

* @api public

*/

EventEmitter.prototype.emit = function (name) {

if (!this.$events) {

return false;

}

var handler = this.$events[name];

if (!handler) {

return false;

}

var args = [].slice.call(arguments, 1);

if ('function' == typeof handler) {

handler.apply(this, args);

} else if (isArray(handler)) {

var listeners = handler.slice();

for (var i = 0, l = listeners.length; i < l; i++) {

listeners[i].apply(this, args);

}

} else {

return false;

}

return true;

};

}); // module: browser/events.js

require.register("browser/fs.js", function(module, exports, require){

}); // module: browser/fs.js

require.register("browser/path.js", function(module, exports, require){

}); // module: browser/path.js

require.register("browser/progress.js", function(module, exports, require){

/**

* Expose `Progress`.

*/

module.exports = Progress;

/**

* Initialize a new `Progress` indicator.

*/

function Progress() {

this.percent = 0;

this.size(0);

this.fontSize(11);

this.font('helvetica, arial, sans-serif');

}

/**

* Set progress size to `n`.

*

* @param {Number} n

* @return {Progress} for chaining

* @api public

*/

Progress.prototype.size = function(n){

this._size = n;

return this;

};

/**

* Set text to `str`.

*

* @param {String} str

* @return {Progress} for chaining

* @api public

*/

Progress.prototype.text = function(str){

this._text = str;

return this;

};

/**

* Set font size to `n`.

*

* @param {Number} n

* @return {Progress} for chaining

* @api public

*/

Progress.prototype.fontSize = function(n){

this._fontSize = n;

return this;

};

/**

* Set font `family`.

*

* @param {String} family

* @return {Progress} for chaining

*/

Progress.prototype.font = function(family){

this._font = family;

return this;

};

/**

* Update percentage to `n`.

*

* @param {Number} n

* @return {Progress} for chaining

*/

Progress.prototype.update = function(n){

this.percent = n;

return this;

};

/**

* Draw on `ctx`.

*

* @param {CanvasRenderingContext2d} ctx

* @return {Progress} for chaining

*/

Progress.prototype.draw = function(ctx){

var percent = Math.min(this.percent, 100)

, size = this._size

, half = size / 2

, x = half

, y = half

, rad = half - 1

, fontSize = this._fontSize;

ctx.font = fontSize + 'px ' + this._font;

var angle = Math.PI * 2 * (percent / 100);

ctx.clearRect(0, 0, size, size);

// outer circle

ctx.strokeStyle = '#9f9f9f';

ctx.beginPath();

ctx.arc(x, y, rad, 0, angle, false);

ctx.stroke();

// inner circle

ctx.strokeStyle = '#eee';

ctx.beginPath();

ctx.arc(x, y, rad - 1, 0, angle, true);

ctx.stroke();

// text

var text = this._text || (percent | 0) + '%'

, w = ctx.measureText(text).width;

ctx.fillText(

text

, x - w / 2 + 1

, y + fontSize / 2 - 1);

return this;

};

}); // module: browser/progress.js

require.register("browser/tty.js", function(module, exports, require){

exports.isatty = function(){

return true;

};

exports.getWindowSize = function(){

return [window.innerHeight, window.innerWidth];

};

}); // module: browser/tty.js

require.register("context.js", function(module, exports, require){

/**

* Expose `Context`.

*/

module.exports = Context;

/**

* Initialize a new `Context`.

*

* @api private

*/

function Context(){}

/**

* Set the context `Runnable` to `runnable`.

*

* @param {Runnable} runnable

* @return {Context}

* @api private

*/

Context.prototype.runnable = function(runnable){

this._runnable = runnable;

return this;

};

/**

* Set test timeout `ms`.

*

* @param {Number} ms

* @return {Context} self

* @api private

*/

Context.prototype.timeout = function(ms){

this._runnable.timeout(ms);

return this;

};

/**

* Inspect the context void of `._runnable`.

*

* @return {String}

* @api private

*/

Context.prototype.inspect = function(){

return JSON.stringify(this, function(key, val){

return '_runnable' == key

? undefined

: val;

}, 2);

};

}); // module: context.js

require.register("hook.js", function(module, exports, require){

/**

* Module dependencies.

*/

var Runnable = require('./runnable');

/**

* Expose `Hook`.

*/

module.exports = Hook;

/**

* Initialize a new `Hook` with the given `title` and callback `fn`.

*

* @param {String} title

* @param {Function} fn

* @api private

*/

function Hook(title, fn) {

Runnable.call(this, title, fn);

this.type = 'hook';

}

/**

* Inherit from `Runnable.prototype`.

*/

Hook.prototype = new Runnable;

Hook.prototype.constructor = Hook;

}); // module: hook.js

require.register("interfaces/bdd.js", function(module, exports, require){

/**

* Module dependencies.

*/

var Suite = require('../suite')

, Test = require('../test');

/**

* BDD-style interface:

*

* describe('Array', function(){

* describe('#indexOf()', function(){

* it('should return -1 when not present', function(){

*

* });

*

* it('should return the index when present', function(){

*

* });

* });

* });

*

*/

module.exports = function(suite){

var suites = [suite];

suite.on('pre-require', function(context){

// noop variants

context.xdescribe = function(){};

context.xit = function(){};

/**

* Execute before running tests.

*/

context.before = function(fn){

suites[0].beforeAll(fn);

};

/**

* Execute after running tests.

*/

context.after = function(fn){

suites[0].afterAll(fn);

};

/**

* Execute before each test case.

*/

context.beforeEach = function(fn){

suites[0].beforeEach(fn);

};

/**

* Execute after each test case.

*/

context.afterEach = function(fn){

suites[0].afterEach(fn);

};

/**

* Describe a "suite" with the given `title`

* and callback `fn` containing nested suites

* and/or tests.

*/

context.describe = context.context = function(title, fn){

var suite = Suite.create(suites[0], title);

suites.unshift(suite);

fn();

suites.shift();

};

/**

* Describe a specification or test-case

* with the given `title` and callback `fn`

* acting as a thunk.

*/

context.it = function(title, fn){

suites[0].addTest(new Test(title, fn));

};

});

};

}); // module: interfaces/bdd.js

require.register("interfaces/exports.js", function(module, exports, require){

/**

* Module dependencies.

*/

var Suite = require('../suite')

, Test = require('../test');

/**

* TDD-style interface:

*

* exports.Array = {

* '#indexOf()': {

* 'should return -1 when the value is not present': function(){

*

* },

*

* 'should return the correct index when the value is present': function(){

*

* }

* }

* };

*

*/

module.exports = function(suite){

var suites = [suite];

suite.on('require', visit);

function visit(obj) {

var suite;

for (var key in obj) {

if ('function' == typeof obj[key]) {

var fn = obj[key];

switch (key) {

case 'before':

suites[0].beforeAll(fn);

break;

case 'after':

suites[0].afterAll(fn);

break;

case 'beforeEach':

suites[0].beforeEach(fn);

break;

case 'afterEach':

suites[0].afterEach(fn);

break;

default:

suites[0].addTest(new Test(key, fn));

}

} else {

var suite = Suite.create(suites[0], key);

suites.unshift(suite);

visit(obj[key]);

suites.shift();

}

}

}

};

}); // module: interfaces/exports.js

require.register("interfaces/index.js", function(module, exports, require){

exports.bdd = require('./bdd');

exports.tdd = require('./tdd');

exports.qunit = require('./qunit');

exports.exports = require('./exports');

}); // module: interfaces/index.js

require.register("interfaces/qunit.js", function(module, exports, require){

/**

* Module dependencies.

*/

var Suite = require('../suite')

, Test = require('../test');

/**

* QUnit-style interface:

*

* suite('Array');

*

* test('#length', function(){

* var arr = [1,2,3];

* ok(arr.length == 3);

* });

*

* test('#indexOf()', function(){

* var arr = [1,2,3];

* ok(arr.indexOf(1) == 0);

* ok(arr.indexOf(2) == 1);

* ok(arr.indexOf(3) == 2);

* });

*

* suite('String');

*

* test('#length', function(){

* ok('foo'.length == 3);

* });

*

*/

module.exports = function(suite){

var suites = [suite];

suite.on('pre-require', function(context){

/**

* Execute before running tests.

*/

context.before = function(fn){

suites[0].beforeAll(fn);

};

/**

* Execute after running tests.

*/

context.after = function(fn){

suites[0].afterAll(fn);

};

/**

* Execute before each test case.

*/

context.beforeEach = function(fn){

suites[0].beforeEach(fn);

};

/**

* Execute after each test case.

*/

context.afterEach = function(fn){

suites[0].afterEach(fn);

};

/**

* Describe a "suite" with the given `title`.

*/

context.suite = function(title){

if (suites.length > 1) suites.shift();

var suite = Suite.create(suites[0], title);

suites.unshift(suite);

};

/**

* Describe a specification or test-case

* with the given `title` and callback `fn`

* acting as a thunk.

*/

context.test = function(title, fn){

suites[0].addTest(new Test(title, fn));

};

});

};

}); // module: interfaces/qunit.js

require.register("interfaces/tdd.js", function(module, exports, require){

/**

* Module dependencies.

*/

var Suite = require('../suite')

, Test = require('../test');

/**

* TDD-style interface:

*

* suite('Array', function(){

* suite('#indexOf()', function(){

* suiteSetup(function(){

*

* });

*

* test('should return -1 when not present', function(){

*

* });

*

* test('should return the index when present', function(){

*

* });

*

* suiteTeardown(function(){

*

* });

* });

* });

*

*/

module.exports = function(suite){

var suites = [suite];

suite.on('pre-require', function(context){

/**

* Execute before each test case.

*/

context.setup = function(fn){

suites[0].beforeEach(fn);

};

/**

* Execute after each test case.

*/

context.teardown = function(fn){

suites[0].afterEach(fn);

};

/**

* Execute before the suite.

*/

context.suiteSetup = function(fn){

suites[0].beforeAll(fn);

};

/**

* Execute after the suite.

*/

context.suiteTeardown = function(fn){

suites[0].afterAll(fn);

};

/**

* Describe a "suite" with the given `title`

* and callback `fn` containing nested suites

* and/or tests.

*/

context.suite = function(title, fn){

var suite = Suite.create(suites[0], title);

suites.unshift(suite);

fn();

suites.shift();

};

/**

* Describe a specification or test-case

* with the given `title` and callback `fn`

* acting as a thunk.

*/

context.test = function(title, fn){

suites[0].addTest(new Test(title, fn));

};

});

};

}); // module: interfaces/tdd.js

require.register("mocha.js", function(module, exports, require){

/*!

* mocha

* Copyright(c) 2011 TJ Holowaychuk <tj@vision-media.ca>

* MIT Licensed

*/

/**

* Module dependencies.

*/

var path = require('browser/path');

/**

* Expose `Mocha`.

*/

exports = module.exports = Mocha;

/**

* Library version.

*/

exports.version = '1.1.0';

/**

* Expose internals.

*/

exports.utils = require('./utils');

exports.interfaces = require('./interfaces');

exports.reporters = require('./reporters');

exports.Runnable = require('./runnable');

exports.Context = require('./context');

exports.Runner = require('./runner');

exports.Suite = require('./suite');

exports.Hook = require('./hook');

exports.Test = require('./test');

/**

* Return image `name` path.

*

* @param {String} name

* @return {String}

* @api private

*/

function image(name) {

return __dirname + '/../images/' + name + '.png';

}

/**

* Setup mocha with `options`.

*

* Options:

*

* - `ui` name "bdd", "tdd", "exports" etc

* - `reporter` reporter instance, defaults to `mocha.reporters.Dot`

* - `globals` array of accepted globals

* - `timeout` timeout in milliseconds

* - `ignoreLeaks` ignore global leaks

* - `grep` string or regexp to filter tests with

*

* @param {Object} options

* @api public

*/

function Mocha(options) {

options = options || {};

this.files = [];

this.options = options;

this.grep(options.grep);

this.suite = new exports.Suite('', new exports.Context);

this.ui(options.ui);

this.reporter(options.reporter);

if (options.timeout) this.suite.timeout(options.timeout);

}

/**

* Add test `file`.

*

* @param {String} file

* @api public

*/

Mocha.prototype.addFile = function(file){

this.files.push(file);

return this;

};

/**

* Set reporter to `name`, defaults to "dot".

*

* @param {String} name

* @api public

*/

Mocha.prototype.reporter = function(name){

name = name || 'dot';

this._reporter = require('./reporters/' + name);

if (!this._reporter) throw new Error('invalid reporter "' + name + '"');

return this;

};

/**

* Set test UI `name`, defaults to "bdd".

*

* @param {String} bdd

* @api public

*/

Mocha.prototype.ui = function(name){

name = name || 'bdd';

this._ui = exports.interfaces[name];

if (!this._ui) throw new Error('invalid interface "' + name + '"');

this._ui = this._ui(this.suite);

return this;

};

/**

* Load registered files.

*

* @api private

*/

Mocha.prototype.loadFiles = function(){

var suite = this.suite;

this.files.forEach(function(file){

file = path.resolve(file);

suite.emit('pre-require', global, file);

suite.emit('require', require(file), file);

suite.emit('post-require', global, file);

});

};

/**

* Enable growl support.

*

* @api private

*/

Mocha.prototype.growl = function(runner, reporter) {

var notify = require('growl');

runner.on('end', function(){

var stats = reporter.stats;

if (stats.failures) {

var msg = stats.failures + ' of ' + runner.total + ' tests failed';

notify(msg, { title: 'Failed', image: image('fail') });

} else {

notify(stats.passes + ' tests passed in ' + stats.duration + 'ms', {