{I"
class:ETI"BundledAsset; FI"logical_path; TI"spec_helper.js; TI"pathname; TI"J/Users/Michael/Development/magic_lamp/spec/javascripts/spec_helper.js; FI"content_type; TI"application/javascript; TI"
mtime; Tl+gģ:TI"length; Ti"I"digest; TI"%a29b7ddedd9b87d221287a197981f1c1; FI"source; TI""if (!Function.prototype.bind) {
  Function.prototype.bind = function (oThis) {
    if (typeof this !== "function") {
      // closest thing possible to the ECMAScript 5 internal IsCallable function
      throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable");
    }

    var aArgs = Array.prototype.slice.call(arguments, 1),
        fToBind = this,
        fNOP = function () {},
        fBound = function () {
          return fToBind.apply(this instanceof fNOP && oThis
              ? this
              : oThis,
              aArgs.concat(Array.prototype.slice.call(arguments)));
        };

    fNOP.prototype = this.prototype;
    fBound.prototype = new fNOP();

    return fBound;
  };
}
;
var MagicLamp = {

  initialize: function() {
    this.genie = new this.Genie();
  },

  fixtureNames: function() {
    return this.genie.fixtureNames();
  },

  globalize: function() {
    var context = this;
    window.load = function(path) {
      context.load(path);
    };
    window.clean = function() {
      context.clean();
    };
  },

  load: function() {
    this.genie.load.apply(this.genie, arguments);
  },

  preload: function() {
    this.genie.preload.apply(this.genie, arguments);
  },

  clean: function() {
    this.genie.removeFixtureContainer();
  }
};

// aliases
MagicLamp.rub = MagicLamp.load;
MagicLamp.wish = MagicLamp.load;
MagicLamp.massage = MagicLamp.preload;
MagicLamp.wishForMoreWishes = MagicLamp.preload;
MagicLamp.polish = MagicLamp.clean;
(function(global) {

  function Genie() {
    this.cache = {};
    this.cacheOnly = false;
    this.namespace = MagicLamp;
  }

  Genie.prototype = {

    load: function(path) {
      this.removeFixtureContainer();
      var fixture = this.cache[path];
      this.createFixtureContainer();

      if (!fixture && this.cacheOnly) {
        throw new Error('The fixture "' + path + '" was not preloaded. Is the fixture registered? Call `MagicLamp.fixtureNames()` to see what is registered.');
      } else if (!fixture) {
        var xhr = this.xhrRequest(getPath() + '/' + path);
        this.cache[path] = fixture = xhr.responseText;
      }

      this.fixtureContainer.innerHTML = fixture;
      this.appendFixtureContainer();
    },

    preload: function() {
      var xhr = this.xhrRequest(getPath());
      var json = JSON.parse(xhr.responseText);
      this.cache = json;
      this.cacheOnly = true;
    },

    fixtureNames: function() {
      var names = [];
      for (fixtureName in this.cache) {
        if (this.cache.hasOwnProperty(fixtureName)) {
          names.push(fixtureName);
        }
      }
      var sortedNames = names.sort();
      for (var i = 0; i < sortedNames.length; i++) {
        console.log(sortedNames[i]);
      };

      return sortedNames;
    },

    createFixtureContainer: function() {
      var div = document.createElement('div');
      div.setAttribute('class', this.namespace.class || 'magic-lamp');
      this.fixtureContainer = div;
    },

    appendFixtureContainer: function() {
      document.body.appendChild(this.fixtureContainer);
    },

    removeFixtureContainer: function() {
      if (this.fixtureContainer) {
        remove(this.fixtureContainer);
        this.fixtureContainer = undefined;
      }
    },

    handleError: function(errorMessage) {
      throw new Error(errorMessage);
    },

    xhrRequest: function(path) {
      var xhr = newXhr();

      xhr.open('GET', path, false);
      xhr.send();

      if (this.xhrStatus(xhr) === 400) {
        this.handleError(xhr.responseText);
      } else if (this.xhrStatus(xhr) === 500) {
        this.handleError('Something went wrong, please check the server log or run `rake magic_lamp:lint` for more information');
      }
      return xhr;
    },

    xhrStatus: function(xhr) {
      return xhr.status;
    }
  };

  // private

  function getPath() {
    return MagicLamp.path || '/magic_lamp';
  }

  function remove(node) {
    var parentNode = node.parentNode;
    parentNode && parentNode.removeChild(node);
  }

  function newXhr() {
    var xhr;
    if (window.XMLHttpRequest) { // Mozilla, Safari, ...
      xhr = new XMLHttpRequest();
    } else if (window.ActiveXObject) { // IE
      try {
        xhr = new ActiveXObject('Msxml2.XMLHTTP');
      } catch (error) {
        try {
          xhr = new ActiveXObject('Microsoft.XMLHTTP');
        } catch (e) {
          // let it go
        }
      }
    }
    if (!xhr) {
      throw('Unable to make request');
    }
    return xhr;
  }

  MagicLamp.Genie = Genie;
})(this);
// This is a manifest file that'll be compiled into application.js, which will include all the files
// listed below.
//
// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
//
// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
// compiled file.
//
// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
// about supported directives.
//


;
//     Underscore.js 1.6.0
//     http://underscorejs.org
//     (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
//     Underscore may be freely distributed under the MIT license.

(function() {

  // Baseline setup
  // --------------

  // Establish the root object, `window` in the browser, or `exports` on the server.
  var root = this;

  // Save the previous value of the `_` variable.
  var previousUnderscore = root._;

  // Establish the object that gets returned to break out of a loop iteration.
  var breaker = {};

  // Save bytes in the minified (but not gzipped) version:
  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;

  // Create quick reference variables for speed access to core prototypes.
  var
    push             = ArrayProto.push,
    slice            = ArrayProto.slice,
    concat           = ArrayProto.concat,
    toString         = ObjProto.toString,
    hasOwnProperty   = ObjProto.hasOwnProperty;

  // All **ECMAScript 5** native function implementations that we hope to use
  // are declared here.
  var
    nativeForEach      = ArrayProto.forEach,
    nativeMap          = ArrayProto.map,
    nativeReduce       = ArrayProto.reduce,
    nativeReduceRight  = ArrayProto.reduceRight,
    nativeFilter       = ArrayProto.filter,
    nativeEvery        = ArrayProto.every,
    nativeSome         = ArrayProto.some,
    nativeIndexOf      = ArrayProto.indexOf,
    nativeLastIndexOf  = ArrayProto.lastIndexOf,
    nativeIsArray      = Array.isArray,
    nativeKeys         = Object.keys,
    nativeBind         = FuncProto.bind;

  // Create a safe reference to the Underscore object for use below.
  var _ = function(obj) {
    if (obj instanceof _) return obj;
    if (!(this instanceof _)) return new _(obj);
    this._wrapped = obj;
  };

  // Export the Underscore object for **Node.js**, with
  // backwards-compatibility for the old `require()` API. If we're in
  // the browser, add `_` as a global object via a string identifier,
  // for Closure Compiler "advanced" mode.
  if (typeof exports !== 'undefined') {
    if (typeof module !== 'undefined' && module.exports) {
      exports = module.exports = _;
    }
    exports._ = _;
  } else {
    root._ = _;
  }

  // Current version.
  _.VERSION = '1.6.0';

  // Collection Functions
  // --------------------

  // The cornerstone, an `each` implementation, aka `forEach`.
  // Handles objects with the built-in `forEach`, arrays, and raw objects.
  // Delegates to **ECMAScript 5**'s native `forEach` if available.
  var each = _.each = _.forEach = function(obj, iterator, context) {
    if (obj == null) return obj;
    if (nativeForEach && obj.forEach === nativeForEach) {
      obj.forEach(iterator, context);
    } else if (obj.length === +obj.length) {
      for (var i = 0, length = obj.length; i < length; i++) {
        if (iterator.call(context, obj[i], i, obj) === breaker) return;
      }
    } else {
      var keys = _.keys(obj);
      for (var i = 0, length = keys.length; i < length; i++) {
        if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) return;
      }
    }
    return obj;
  };

  // Return the results of applying the iterator to each element.
  // Delegates to **ECMAScript 5**'s native `map` if available.
  _.map = _.collect = function(obj, iterator, context) {
    var results = [];
    if (obj == null) return results;
    if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
    each(obj, function(value, index, list) {
      results.push(iterator.call(context, value, index, list));
    });
    return results;
  };

  var reduceError = 'Reduce of empty array with no initial value';

  // **Reduce** builds up a single result from a list of values, aka `inject`,
  // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available.
  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {
    var initial = arguments.length > 2;
    if (obj == null) obj = [];
    if (nativeReduce && obj.reduce === nativeReduce) {
      if (context) iterator = _.bind(iterator, context);
      return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);
    }
    each(obj, function(value, index, list) {
      if (!initial) {
        memo = value;
        initial = true;
      } else {
        memo = iterator.call(context, memo, value, index, list);
      }
    });
    if (!initial) throw new TypeError(reduceError);
    return memo;
  };

  // The right-associative version of reduce, also known as `foldr`.
  // Delegates to **ECMAScript 5**'s native `reduceRight` if available.
  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {
    var initial = arguments.length > 2;
    if (obj == null) obj = [];
    if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {
      if (context) iterator = _.bind(iterator, context);
      return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);
    }
    var length = obj.length;
    if (length !== +length) {
      var keys = _.keys(obj);
      length = keys.length;
    }
    each(obj, function(value, index, list) {
      index = keys ? keys[--length] : --length;
      if (!initial) {
        memo = obj[index];
        initial = true;
      } else {
        memo = iterator.call(context, memo, obj[index], index, list);
      }
    });
    if (!initial) throw new TypeError(reduceError);
    return memo;
  };

  // Return the first value which passes a truth test. Aliased as `detect`.
  _.find = _.detect = function(obj, predicate, context) {
    var result;
    any(obj, function(value, index, list) {
      if (predicate.call(context, value, index, list)) {
        result = value;
        return true;
      }
    });
    return result;
  };

  // Return all the elements that pass a truth test.
  // Delegates to **ECMAScript 5**'s native `filter` if available.
  // Aliased as `select`.
  _.filter = _.select = function(obj, predicate, context) {
    var results = [];
    if (obj == null) return results;
    if (nativeFilter && obj.filter === nativeFilter) return obj.filter(predicate, context);
    each(obj, function(value, index, list) {
      if (predicate.call(context, value, index, list)) results.push(value);
    });
    return results;
  };

  // Return all the elements for which a truth test fails.
  _.reject = function(obj, predicate, context) {
    return _.filter(obj, function(value, index, list) {
      return !predicate.call(context, value, index, list);
    }, context);
  };

  // Determine whether all of the elements match a truth test.
  // Delegates to **ECMAScript 5**'s native `every` if available.
  // Aliased as `all`.
  _.every = _.all = function(obj, predicate, context) {
    predicate || (predicate = _.identity);
    var result = true;
    if (obj == null) return result;
    if (nativeEvery && obj.every === nativeEvery) return obj.every(predicate, context);
    each(obj, function(value, index, list) {
      if (!(result = result && predicate.call(context, value, index, list))) return breaker;
    });
    return !!result;
  };

  // Determine if at least one element in the object matches a truth test.
  // Delegates to **ECMAScript 5**'s native `some` if available.
  // Aliased as `any`.
  var any = _.some = _.any = function(obj, predicate, context) {
    predicate || (predicate = _.identity);
    var result = false;
    if (obj == null) return result;
    if (nativeSome && obj.some === nativeSome) return obj.some(predicate, context);
    each(obj, function(value, index, list) {
      if (result || (result = predicate.call(context, value, index, list))) return breaker;
    });
    return !!result;
  };

  // Determine if the array or object contains a given value (using `===`).
  // Aliased as `include`.
  _.contains = _.include = function(obj, target) {
    if (obj == null) return false;
    if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;
    return any(obj, function(value) {
      return value === target;
    });
  };

  // Invoke a method (with arguments) on every item in a collection.
  _.invoke = function(obj, method) {
    var args = slice.call(arguments, 2);
    var isFunc = _.isFunction(method);
    return _.map(obj, function(value) {
      return (isFunc ? method : value[method]).apply(value, args);
    });
  };

  // Convenience version of a common use case of `map`: fetching a property.
  _.pluck = function(obj, key) {
    return _.map(obj, _.property(key));
  };

  // Convenience version of a common use case of `filter`: selecting only objects
  // containing specific `key:value` pairs.
  _.where = function(obj, attrs) {
    return _.filter(obj, _.matches(attrs));
  };

  // Convenience version of a common use case of `find`: getting the first object
  // containing specific `key:value` pairs.
  _.findWhere = function(obj, attrs) {
    return _.find(obj, _.matches(attrs));
  };

  // Return the maximum element or (element-based computation).
  // Can't optimize arrays of integers longer than 65,535 elements.
  // See [WebKit Bug 80797](https://bugs.webkit.org/show_bug.cgi?id=80797)
  _.max = function(obj, iterator, context) {
    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
      return Math.max.apply(Math, obj);
    }
    var result = -Infinity, lastComputed = -Infinity;
    each(obj, function(value, index, list) {
      var computed = iterator ? iterator.call(context, value, index, list) : value;
      if (computed > lastComputed) {
        result = value;
        lastComputed = computed;
      }
    });
    return result;
  };

  // Return the minimum element (or element-based computation).
  _.min = function(obj, iterator, context) {
    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {
      return Math.min.apply(Math, obj);
    }
    var result = Infinity, lastComputed = Infinity;
    each(obj, function(value, index, list) {
      var computed = iterator ? iterator.call(context, value, index, list) : value;
      if (computed < lastComputed) {
        result = value;
        lastComputed = computed;
      }
    });
    return result;
  };

  // Shuffle an array, using the modern version of the
  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisherā€“Yates_shuffle).
  _.shuffle = function(obj) {
    var rand;
    var index = 0;
    var shuffled = [];
    each(obj, function(value) {
      rand = _.random(index++);
      shuffled[index - 1] = shuffled[rand];
      shuffled[rand] = value;
    });
    return shuffled;
  };

  // Sample **n** random values from a collection.
  // If **n** is not specified, returns a single random element.
  // The internal `guard` argument allows it to work with `map`.
  _.sample = function(obj, n, guard) {
    if (n == null || guard) {
      if (obj.length !== +obj.length) obj = _.values(obj);
      return obj[_.random(obj.length - 1)];
    }
    return _.shuffle(obj).slice(0, Math.max(0, n));
  };

  // An internal function to generate lookup iterators.
  var lookupIterator = function(value) {
    if (value == null) return _.identity;
    if (_.isFunction(value)) return value;
    return _.property(value);
  };

  // Sort the object's values by a criterion produced by an iterator.
  _.sortBy = function(obj, iterator, context) {
    iterator = lookupIterator(iterator);
    return _.pluck(_.map(obj, function(value, index, list) {
      return {
        value: value,
        index: index,
        criteria: iterator.call(context, value, index, list)
      };
    }).sort(function(left, right) {
      var a = left.criteria;
      var b = right.criteria;
      if (a !== b) {
        if (a > b || a === void 0) return 1;
        if (a < b || b === void 0) return -1;
      }
      return left.index - right.index;
    }), 'value');
  };

  // An internal function used for aggregate "group by" operations.
  var group = function(behavior) {
    return function(obj, iterator, context) {
      var result = {};
      iterator = lookupIterator(iterator);
      each(obj, function(value, index) {
        var key = iterator.call(context, value, index, obj);
        behavior(result, key, value);
      });
      return result;
    };
  };

  // Groups the object's values by a criterion. Pass either a string attribute
  // to group by, or a function that returns the criterion.
  _.groupBy = group(function(result, key, value) {
    _.has(result, key) ? result[key].push(value) : result[key] = [value];
  });

  // Indexes the object's values by a criterion, similar to `groupBy`, but for
  // when you know that your index values will be unique.
  _.indexBy = group(function(result, key, value) {
    result[key] = value;
  });

  // Counts instances of an object that group by a certain criterion. Pass
  // either a string attribute to count by, or a function that returns the
  // criterion.
  _.countBy = group(function(result, key) {
    _.has(result, key) ? result[key]++ : result[key] = 1;
  });

  // Use a comparator function to figure out the smallest index at which
  // an object should be inserted so as to maintain order. Uses binary search.
  _.sortedIndex = function(array, obj, iterator, context) {
    iterator = lookupIterator(iterator);
    var value = iterator.call(context, obj);
    var low = 0, high = array.length;
    while (low < high) {
      var mid = (low + high) >>> 1;
      iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid;
    }
    return low;
  };

  // Safely create a real, live array from anything iterable.
  _.toArray = function(obj) {
    if (!obj) return [];
    if (_.isArray(obj)) return slice.call(obj);
    if (obj.length === +obj.length) return _.map(obj, _.identity);
    return _.values(obj);
  };

  // Return the number of elements in an object.
  _.size = function(obj) {
    if (obj == null) return 0;
    return (obj.length === +obj.length) ? obj.length : _.keys(obj).length;
  };

  // Array Functions
  // ---------------

  // Get the first element of an array. Passing **n** will return the first N
  // values in the array. Aliased as `head` and `take`. The **guard** check
  // allows it to work with `_.map`.
  _.first = _.head = _.take = function(array, n, guard) {
    if (array == null) return void 0;
    if ((n == null) || guard) return array[0];
    if (n < 0) return [];
    return slice.call(array, 0, n);
  };

  // Returns everything but the last entry of the array. Especially useful on
  // the arguments object. Passing **n** will return all the values in
  // the array, excluding the last N. The **guard** check allows it to work with
  // `_.map`.
  _.initial = function(array, n, guard) {
    return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n));
  };

  // Get the last element of an array. Passing **n** will return the last N
  // values in the array. The **guard** check allows it to work with `_.map`.
  _.last = function(array, n, guard) {
    if (array == null) return void 0;
    if ((n == null) || guard) return array[array.length - 1];
    return slice.call(array, Math.max(array.length - n, 0));
  };

  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
  // Especially useful on the arguments object. Passing an **n** will return
  // the rest N values in the array. The **guard**
  // check allows it to work with `_.map`.
  _.rest = _.tail = _.drop = function(array, n, guard) {
    return slice.call(array, (n == null) || guard ? 1 : n);
  };

  // Trim out all falsy values from an array.
  _.compact = function(array) {
    return _.filter(array, _.identity);
  };

  // Internal implementation of a recursive `flatten` function.
  var flatten = function(input, shallow, output) {
    if (shallow && _.every(input, _.isArray)) {
      return concat.apply(output, input);
    }
    each(input, function(value) {
      if (_.isArray(value) || _.isArguments(value)) {
        shallow ? push.apply(output, value) : flatten(value, shallow, output);
      } else {
        output.push(value);
      }
    });
    return output;
  };

  // Flatten out an array, either recursively (by default), or just one level.
  _.flatten = function(array, shallow) {
    return flatten(array, shallow, []);
  };

  // Return a version of the array that does not contain the specified value(s).
  _.without = function(array) {
    return _.difference(array, slice.call(arguments, 1));
  };

  // Split an array into two arrays: one whose elements all satisfy the given
  // predicate, and one whose elements all do not satisfy the predicate.
  _.partition = function(array, predicate) {
    var pass = [], fail = [];
    each(array, function(elem) {
      (predicate(elem) ? pass : fail).push(elem);
    });
    return [pass, fail];
  };

  // Produce a duplicate-free version of the array. If the array has already
  // been sorted, you have the option of using a faster algorithm.
  // Aliased as `unique`.
  _.uniq = _.unique = function(array, isSorted, iterator, context) {
    if (_.isFunction(isSorted)) {
      context = iterator;
      iterator = isSorted;
      isSorted = false;
    }
    var initial = iterator ? _.map(array, iterator, context) : array;
    var results = [];
    var seen = [];
    each(initial, function(value, index) {
      if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {
        seen.push(value);
        results.push(array[index]);
      }
    });
    return results;
  };

  // Produce an array that contains the union: each distinct element from all of
  // the passed-in arrays.
  _.union = function() {
    return _.uniq(_.flatten(arguments, true));
  };

  // Produce an array that contains every item shared between all the
  // passed-in arrays.
  _.intersection = function(array) {
    var rest = slice.call(arguments, 1);
    return _.filter(_.uniq(array), function(item) {
      return _.every(rest, function(other) {
        return _.contains(other, item);
      });
    });
  };

  // Take the difference between one array and a number of other arrays.
  // Only the elements present in just the first array will remain.
  _.difference = function(array) {
    var rest = concat.apply(ArrayProto, slice.call(arguments, 1));
    return _.filter(array, function(value){ return !_.contains(rest, value); });
  };

  // Zip together multiple lists into a single array -- elements that share
  // an index go together.
  _.zip = function() {
    var length = _.max(_.pluck(arguments, 'length').concat(0));
    var results = new Array(length);
    for (var i = 0; i < length; i++) {
      results[i] = _.pluck(arguments, '' + i);
    }
    return results;
  };

  // Converts lists into objects. Pass either a single array of `[key, value]`
  // pairs, or two parallel arrays of the same length -- one of keys, and one of
  // the corresponding values.
  _.object = function(list, values) {
    if (list == null) return {};
    var result = {};
    for (var i = 0, length = list.length; i < length; i++) {
      if (values) {
        result[list[i]] = values[i];
      } else {
        result[list[i][0]] = list[i][1];
      }
    }
    return result;
  };

  // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),
  // we need this function. Return the position of the first occurrence of an
  // item in an array, or -1 if the item is not included in the array.
  // Delegates to **ECMAScript 5**'s native `indexOf` if available.
  // If the array is large and already in sort order, pass `true`
  // for **isSorted** to use binary search.
  _.indexOf = function(array, item, isSorted) {
    if (array == null) return -1;
    var i = 0, length = array.length;
    if (isSorted) {
      if (typeof isSorted == 'number') {
        i = (isSorted < 0 ? Math.max(0, length + isSorted) : isSorted);
      } else {
        i = _.sortedIndex(array, item);
        return array[i] === item ? i : -1;
      }
    }
    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);
    for (; i < length; i++) if (array[i] === item) return i;
    return -1;
  };

  // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.
  _.lastIndexOf = function(array, item, from) {
    if (array == null) return -1;
    var hasIndex = from != null;
    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {
      return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);
    }
    var i = (hasIndex ? from : array.length);
    while (i--) if (array[i] === item) return i;
    return -1;
  };

  // Generate an integer Array containing an arithmetic progression. A port of
  // the native Python `range()` function. See
  // [the Python documentation](http://docs.python.org/library/functions.html#range).
  _.range = function(start, stop, step) {
    if (arguments.length <= 1) {
      stop = start || 0;
      start = 0;
    }
    step = arguments[2] || 1;

    var length = Math.max(Math.ceil((stop - start) / step), 0);
    var idx = 0;
    var range = new Array(length);

    while(idx < length) {
      range[idx++] = start;
      start += step;
    }

    return range;
  };

  // Function (ahem) Functions
  // ------------------

  // Reusable constructor function for prototype setting.
  var ctor = function(){};

  // Create a function bound to a given object (assigning `this`, and arguments,
  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
  // available.
  _.bind = function(func, context) {
    var args, bound;
    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
    if (!_.isFunction(func)) throw new TypeError;
    args = slice.call(arguments, 2);
    return bound = function() {
      if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
      ctor.prototype = func.prototype;
      var self = new ctor;
      ctor.prototype = null;
      var result = func.apply(self, args.concat(slice.call(arguments)));
      if (Object(result) === result) return result;
      return self;
    };
  };

  // Partially apply a function by creating a version that has had some of its
  // arguments pre-filled, without changing its dynamic `this` context. _ acts
  // as a placeholder, allowing any combination of arguments to be pre-filled.
  _.partial = function(func) {
    var boundArgs = slice.call(arguments, 1);
    return function() {
      var position = 0;
      var args = boundArgs.slice();
      for (var i = 0, length = args.length; i < length; i++) {
        if (args[i] === _) args[i] = arguments[position++];
      }
      while (position < arguments.length) args.push(arguments[position++]);
      return func.apply(this, args);
    };
  };

  // Bind a number of an object's methods to that object. Remaining arguments
  // are the method names to be bound. Useful for ensuring that all callbacks
  // defined on an object belong to it.
  _.bindAll = function(obj) {
    var funcs = slice.call(arguments, 1);
    if (funcs.length === 0) throw new Error('bindAll must be passed function names');
    each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });
    return obj;
  };

  // Memoize an expensive function by storing its results.
  _.memoize = function(func, hasher) {
    var memo = {};
    hasher || (hasher = _.identity);
    return function() {
      var key = hasher.apply(this, arguments);
      return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));
    };
  };

  // Delays a function for the given number of milliseconds, and then calls
  // it with the arguments supplied.
  _.delay = function(func, wait) {
    var args = slice.call(arguments, 2);
    return setTimeout(function(){ return func.apply(null, args); }, wait);
  };

  // Defers a function, scheduling it to run after the current call stack has
  // cleared.
  _.defer = function(func) {
    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
  };

  // Returns a function, that, when invoked, will only be triggered at most once
  // during a given window of time. Normally, the throttled function will run
  // as much as it can, without ever going more than once per `wait` duration;
  // but if you'd like to disable the execution on the leading edge, pass
  // `{leading: false}`. To disable execution on the trailing edge, ditto.
  _.throttle = function(func, wait, options) {
    var context, args, result;
    var timeout = null;
    var previous = 0;
    options || (options = {});
    var later = function() {
      previous = options.leading === false ? 0 : _.now();
      timeout = null;
      result = func.apply(context, args);
      context = args = null;
    };
    return function() {
      var now = _.now();
      if (!previous && options.leading === false) previous = now;
      var remaining = wait - (now - previous);
      context = this;
      args = arguments;
      if (remaining <= 0) {
        clearTimeout(timeout);
        timeout = null;
        previous = now;
        result = func.apply(context, args);
        context = args = null;
      } else if (!timeout && options.trailing !== false) {
        timeout = setTimeout(later, remaining);
      }
      return result;
    };
  };

  // Returns a function, that, as long as it continues to be invoked, will not
  // be triggered. The function will be called after it stops being called for
  // N milliseconds. If `immediate` is passed, trigger the function on the
  // leading edge, instead of the trailing.
  _.debounce = function(func, wait, immediate) {
    var timeout, args, context, timestamp, result;

    var later = function() {
      var last = _.now() - timestamp;
      if (last < wait) {
        timeout = setTimeout(later, wait - last);
      } else {
        timeout = null;
        if (!immediate) {
          result = func.apply(context, args);
          context = args = null;
        }
      }
    };

    return function() {
      context = this;
      args = arguments;
      timestamp = _.now();
      var callNow = immediate && !timeout;
      if (!timeout) {
        timeout = setTimeout(later, wait);
      }
      if (callNow) {
        result = func.apply(context, args);
        context = args = null;
      }

      return result;
    };
  };

  // Returns a function that will be executed at most one time, no matter how
  // often you call it. Useful for lazy initialization.
  _.once = function(func) {
    var ran = false, memo;
    return function() {
      if (ran) return memo;
      ran = true;
      memo = func.apply(this, arguments);
      func = null;
      return memo;
    };
  };

  // Returns the first function passed as an argument to the second,
  // allowing you to adjust arguments, run code before and after, and
  // conditionally execute the original function.
  _.wrap = function(func, wrapper) {
    return _.partial(wrapper, func);
  };

  // Returns a function that is the composition of a list of functions, each
  // consuming the return value of the function that follows.
  _.compose = function() {
    var funcs = arguments;
    return function() {
      var args = arguments;
      for (var i = funcs.length - 1; i >= 0; i--) {
        args = [funcs[i].apply(this, args)];
      }
      return args[0];
    };
  };

  // Returns a function that will only be executed after being called N times.
  _.after = function(times, func) {
    return function() {
      if (--times < 1) {
        return func.apply(this, arguments);
      }
    };
  };

  // Object Functions
  // ----------------

  // Retrieve the names of an object's properties.
  // Delegates to **ECMAScript 5**'s native `Object.keys`
  _.keys = function(obj) {
    if (!_.isObject(obj)) return [];
    if (nativeKeys) return nativeKeys(obj);
    var keys = [];
    for (var key in obj) if (_.has(obj, key)) keys.push(key);
    return keys;
  };

  // Retrieve the values of an object's properties.
  _.values = function(obj) {
    var keys = _.keys(obj);
    var length = keys.length;
    var values = new Array(length);
    for (var i = 0; i < length; i++) {
      values[i] = obj[keys[i]];
    }
    return values;
  };

  // Convert an object into a list of `[key, value]` pairs.
  _.pairs = function(obj) {
    var keys = _.keys(obj);
    var length = keys.length;
    var pairs = new Array(length);
    for (var i = 0; i < length; i++) {
      pairs[i] = [keys[i], obj[keys[i]]];
    }
    return pairs;
  };

  // Invert the keys and values of an object. The values must be serializable.
  _.invert = function(obj) {
    var result = {};
    var keys = _.keys(obj);
    for (var i = 0, length = keys.length; i < length; i++) {
      result[obj[keys[i]]] = keys[i];
    }
    return result;
  };

  // Return a sorted list of the function names available on the object.
  // Aliased as `methods`
  _.functions = _.methods = function(obj) {
    var names = [];
    for (var key in obj) {
      if (_.isFunction(obj[key])) names.push(key);
    }
    return names.sort();
  };

  // Extend a given object with all the properties in passed-in object(s).
  _.extend = function(obj) {
    each(slice.call(arguments, 1), function(source) {
      if (source) {
        for (var prop in source) {
          obj[prop] = source[prop];
        }
      }
    });
    return obj;
  };

  // Return a copy of the object only containing the whitelisted properties.
  _.pick = function(obj) {
    var copy = {};
    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
    each(keys, function(key) {
      if (key in obj) copy[key] = obj[key];
    });
    return copy;
  };

   // Return a copy of the object without the blacklisted properties.
  _.omit = function(obj) {
    var copy = {};
    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));
    for (var key in obj) {
      if (!_.contains(keys, key)) copy[key] = obj[key];
    }
    return copy;
  };

  // Fill in a given object with default properties.
  _.defaults = function(obj) {
    each(slice.call(arguments, 1), function(source) {
      if (source) {
        for (var prop in source) {
          if (obj[prop] === void 0) obj[prop] = source[prop];
        }
      }
    });
    return obj;
  };

  // Create a (shallow-cloned) duplicate of an object.
  _.clone = function(obj) {
    if (!_.isObject(obj)) return obj;
    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
  };

  // Invokes interceptor with the obj, and then returns obj.
  // The primary purpose of this method is to "tap into" a method chain, in
  // order to perform operations on intermediate results within the chain.
  _.tap = function(obj, interceptor) {
    interceptor(obj);
    return obj;
  };

  // Internal recursive comparison function for `isEqual`.
  var eq = function(a, b, aStack, bStack) {
    // Identical objects are equal. `0 === -0`, but they aren't identical.
    // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
    if (a === b) return a !== 0 || 1 / a == 1 / b;
    // A strict comparison is necessary because `null == undefined`.
    if (a == null || b == null) return a === b;
    // Unwrap any wrapped objects.
    if (a instanceof _) a = a._wrapped;
    if (b instanceof _) b = b._wrapped;
    // Compare `[[Class]]` names.
    var className = toString.call(a);
    if (className != toString.call(b)) return false;
    switch (className) {
      // Strings, numbers, dates, and booleans are compared by value.
      case '[object String]':
        // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
        // equivalent to `new String("5")`.
        return a == String(b);
      case '[object Number]':
        // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
        // other numeric values.
        return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b);
      case '[object Date]':
      case '[object Boolean]':
        // Coerce dates and booleans to numeric primitive values. Dates are compared by their
        // millisecond representations. Note that invalid dates with millisecond representations
        // of `NaN` are not equivalent.
        return +a == +b;
      // RegExps are compared by their source patterns and flags.
      case '[object RegExp]':
        return a.source == b.source &&
               a.global == b.global &&
               a.multiline == b.multiline &&
               a.ignoreCase == b.ignoreCase;
    }
    if (typeof a != 'object' || typeof b != 'object') return false;
    // Assume equality for cyclic structures. The algorithm for detecting cyclic
    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
    var length = aStack.length;
    while (length--) {
      // Linear search. Performance is inversely proportional to the number of
      // unique nested structures.
      if (aStack[length] == a) return bStack[length] == b;
    }
    // Objects with different constructors are not equivalent, but `Object`s
    // from different frames are.
    var aCtor = a.constructor, bCtor = b.constructor;
    if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&
                             _.isFunction(bCtor) && (bCtor instanceof bCtor))
                        && ('constructor' in a && 'constructor' in b)) {
      return false;
    }
    // Add the first object to the stack of traversed objects.
    aStack.push(a);
    bStack.push(b);
    var size = 0, result = true;
    // Recursively compare objects and arrays.
    if (className == '[object Array]') {
      // Compare array lengths to determine if a deep comparison is necessary.
      size = a.length;
      result = size == b.length;
      if (result) {
        // Deep compare the contents, ignoring non-numeric properties.
        while (size--) {
          if (!(result = eq(a[size], b[size], aStack, bStack))) break;
        }
      }
    } else {
      // Deep compare objects.
      for (var key in a) {
        if (_.has(a, key)) {
          // Count the expected number of properties.
          size++;
          // Deep compare each member.
          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
        }
      }
      // Ensure that both objects contain the same number of properties.
      if (result) {
        for (key in b) {
          if (_.has(b, key) && !(size--)) break;
        }
        result = !size;
      }
    }
    // Remove the first object from the stack of traversed objects.
    aStack.pop();
    bStack.pop();
    return result;
  };

  // Perform a deep comparison to check if two objects are equal.
  _.isEqual = function(a, b) {
    return eq(a, b, [], []);
  };

  // Is a given array, string, or object empty?
  // An "empty" object has no enumerable own-properties.
  _.isEmpty = function(obj) {
    if (obj == null) return true;
    if (_.isArray(obj) || _.isString(obj)) return obj.length === 0;
    for (var key in obj) if (_.has(obj, key)) return false;
    return true;
  };

  // Is a given value a DOM element?
  _.isElement = function(obj) {
    return !!(obj && obj.nodeType === 1);
  };

  // Is a given value an array?
  // Delegates to ECMA5's native Array.isArray
  _.isArray = nativeIsArray || function(obj) {
    return toString.call(obj) == '[object Array]';
  };

  // Is a given variable an object?
  _.isObject = function(obj) {
    return obj === Object(obj);
  };

  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
  each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
    _['is' + name] = function(obj) {
      return toString.call(obj) == '[object ' + name + ']';
    };
  });

  // Define a fallback version of the method in browsers (ahem, IE), where
  // there isn't any inspectable "Arguments" type.
  if (!_.isArguments(arguments)) {
    _.isArguments = function(obj) {
      return !!(obj && _.has(obj, 'callee'));
    };
  }

  // Optimize `isFunction` if appropriate.
  if (typeof (/./) !== 'function') {
    _.isFunction = function(obj) {
      return typeof obj === 'function';
    };
  }

  // Is a given object a finite number?
  _.isFinite = function(obj) {
    return isFinite(obj) && !isNaN(parseFloat(obj));
  };

  // Is the given value `NaN`? (NaN is the only number which does not equal itself).
  _.isNaN = function(obj) {
    return _.isNumber(obj) && obj != +obj;
  };

  // Is a given value a boolean?
  _.isBoolean = function(obj) {
    return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
  };

  // Is a given value equal to null?
  _.isNull = function(obj) {
    return obj === null;
  };

  // Is a given variable undefined?
  _.isUndefined = function(obj) {
    return obj === void 0;
  };

  // Shortcut function for checking if an object has a given property directly
  // on itself (in other words, not on a prototype).
  _.has = function(obj, key) {
    return hasOwnProperty.call(obj, key);
  };

  // Utility Functions
  // -----------------

  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its
  // previous owner. Returns a reference to the Underscore object.
  _.noConflict = function() {
    root._ = previousUnderscore;
    return this;
  };

  // Keep the identity function around for default iterators.
  _.identity = function(value) {
    return value;
  };

  _.constant = function(value) {
    return function () {
      return value;
    };
  };

  _.property = function(key) {
    return function(obj) {
      return obj[key];
    };
  };

  // Returns a predicate for checking whether an object has a given set of `key:value` pairs.
  _.matches = function(attrs) {
    return function(obj) {
      if (obj === attrs) return true; //avoid comparing an object to itself.
      for (var key in attrs) {
        if (attrs[key] !== obj[key])
          return false;
      }
      return true;
    }
  };

  // Run a function **n** times.
  _.times = function(n, iterator, context) {
    var accum = Array(Math.max(0, n));
    for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i);
    return accum;
  };

  // Return a random integer between min and max (inclusive).
  _.random = function(min, max) {
    if (max == null) {
      max = min;
      min = 0;
    }
    return min + Math.floor(Math.random() * (max - min + 1));
  };

  // A (possibly faster) way to get the current timestamp as an integer.
  _.now = Date.now || function() { return new Date().getTime(); };

  // List of HTML entities for escaping.
  var entityMap = {
    escape: {
      '&': '&amp;',
      '<': '&lt;',
      '>': '&gt;',
      '"': '&quot;',
      "'": '&#x27;'
    }
  };
  entityMap.unescape = _.invert(entityMap.escape);

  // Regexes containing the keys and values listed immediately above.
  var entityRegexes = {
    escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),
    unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')
  };

  // Functions for escaping and unescaping strings to/from HTML interpolation.
  _.each(['escape', 'unescape'], function(method) {
    _[method] = function(string) {
      if (string == null) return '';
      return ('' + string).replace(entityRegexes[method], function(match) {
        return entityMap[method][match];
      });
    };
  });

  // If the value of the named `property` is a function then invoke it with the
  // `object` as context; otherwise, return it.
  _.result = function(object, property) {
    if (object == null) return void 0;
    var value = object[property];
    return _.isFunction(value) ? value.call(object) : value;
  };

  // Add your own custom functions to the Underscore object.
  _.mixin = function(obj) {
    each(_.functions(obj), function(name) {
      var func = _[name] = obj[name];
      _.prototype[name] = function() {
        var args = [this._wrapped];
        push.apply(args, arguments);
        return result.call(this, func.apply(_, args));
      };
    });
  };

  // Generate a unique integer id (unique within the entire client session).
  // Useful for temporary DOM ids.
  var idCounter = 0;
  _.uniqueId = function(prefix) {
    var id = ++idCounter + '';
    return prefix ? prefix + id : id;
  };

  // By default, Underscore uses ERB-style template delimiters, change the
  // following template settings to use alternative delimiters.
  _.templateSettings = {
    evaluate    : /<%([\s\S]+?)%>/g,
    interpolate : /<%=([\s\S]+?)%>/g,
    escape      : /<%-([\s\S]+?)%>/g
  };

  // When customizing `templateSettings`, if you don't want to define an
  // interpolation, evaluation or escaping regex, we need one that is
  // guaranteed not to match.
  var noMatch = /(.)^/;

  // Certain characters need to be escaped so that they can be put into a
  // string literal.
  var escapes = {
    "'":      "'",
    '\\':     '\\',
    '\r':     'r',
    '\n':     'n',
    '\t':     't',
    '\u2028': 'u2028',
    '\u2029': 'u2029'
  };

  var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g;

  // JavaScript micro-templating, similar to John Resig's implementation.
  // Underscore templating handles arbitrary delimiters, preserves whitespace,
  // and correctly escapes quotes within interpolated code.
  _.template = function(text, data, settings) {
    var render;
    settings = _.defaults({}, settings, _.templateSettings);

    // Combine delimiters into one regular expression via alternation.
    var matcher = new RegExp([
      (settings.escape || noMatch).source,
      (settings.interpolate || noMatch).source,
      (settings.evaluate || noMatch).source
    ].join('|') + '|$', 'g');

    // Compile the template source, escaping string literals appropriately.
    var index = 0;
    var source = "__p+='";
    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {
      source += text.slice(index, offset)
        .replace(escaper, function(match) { return '\\' + escapes[match]; });

      if (escape) {
        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
      }
      if (interpolate) {
        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
      }
      if (evaluate) {
        source += "';\n" + evaluate + "\n__p+='";
      }
      index = offset + match.length;
      return match;
    });
    source += "';\n";

    // If a variable is not specified, place data values in local scope.
    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';

    source = "var __t,__p='',__j=Array.prototype.join," +
      "print=function(){__p+=__j.call(arguments,'');};\n" +
      source + "return __p;\n";

    try {
      render = new Function(settings.variable || 'obj', '_', source);
    } catch (e) {
      e.source = source;
      throw e;
    }

    if (data) return render(data, _);
    var template = function(data) {
      return render.call(this, data, _);
    };

    // Provide the compiled function source as a convenience for precompilation.
    template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}';

    return template;
  };

  // Add a "chain" function, which will delegate to the wrapper.
  _.chain = function(obj) {
    return _(obj).chain();
  };

  // OOP
  // ---------------
  // If Underscore is called as a function, it returns a wrapped object that
  // can be used OO-style. This wrapper holds altered versions of all the
  // underscore functions. Wrapped objects may be chained.

  // Helper function to continue chaining intermediate results.
  var result = function(obj) {
    return this._chain ? _(obj).chain() : obj;
  };

  // Add all of the Underscore functions to the wrapper object.
  _.mixin(_);

  // Add all mutator Array functions to the wrapper.
  each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {
    var method = ArrayProto[name];
    _.prototype[name] = function() {
      var obj = this._wrapped;
      method.apply(obj, arguments);
      if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0];
      return result.call(this, obj);
    };
  });

  // Add all accessor Array functions to the wrapper.
  each(['concat', 'join', 'slice'], function(name) {
    var method = ArrayProto[name];
    _.prototype[name] = function() {
      return result.call(this, method.apply(this._wrapped, arguments));
    };
  });

  _.extend(_.prototype, {

    // Start chaining a wrapped Underscore object.
    chain: function() {
      this._chain = true;
      return this;
    },

    // Extracts the result from a wrapped and chained object.
    value: function() {
      return this._wrapped;
    }

  });

  // AMD registration happens at the end for compatibility with AMD loaders
  // that may not enforce next-turn semantics on modules. Even though general
  // practice for AMD registration is to be anonymous, underscore registers
  // as a named module because, like jQuery, it is a base library that is
  // popular enough to be bundled in a third party lib, but not be part of
  // an AMD load request. Those cases could generate an error when an
  // anonymous define() is called outside of a loader request.
  if (typeof define === 'function' && define.amd) {
    define('underscore', [], function() {
      return _;
    });
  }
}).call(this);
;(function(){

  /**
   * Require the given path.
   *
   * @param {String} path
   * @return {Object} exports
   * @api public
   */

  function require(path, parent, orig) {
    var resolved = require.resolve(path);

    // lookup failed
    if (null == resolved) {
      orig = orig || path;
      parent = parent || 'root';
      var err = new Error('Failed to require "' + orig + '" from "' + parent + '"');
      err.path = orig;
      err.parent = parent;
      err.require = true;
      throw err;
    }

    var module = require.modules[resolved];

    // perform real require()
    // by invoking the module's
    // registered function
    if (!module._resolving && !module.exports) {
      var mod = {};
      mod.exports = {};
      mod.client = mod.component = true;
      module._resolving = true;
      module.call(this, mod.exports, require.relative(resolved), mod);
      delete module._resolving;
      module.exports = mod.exports;
    }

    return module.exports;
  }

  /**
   * Registered modules.
   */

  require.modules = {};

  /**
   * Registered aliases.
   */

  require.aliases = {};

  /**
   * Resolve `path`.
   *
   * Lookup:
   *
   *   - PATH/index.js
   *   - PATH.js
   *   - PATH
   *
   * @param {String} path
   * @return {String} path or null
   * @api private
   */

  require.resolve = function(path) {
    if (path.charAt(0) === '/') path = path.slice(1);

    var paths = [
      path,
      path + '.js',
      path + '.json',
      path + '/index.js',
      path + '/index.json'
    ];

    for (var i = 0; i < paths.length; i++) {
      var path = paths[i];
      if (require.modules.hasOwnProperty(path)) return path;
      if (require.aliases.hasOwnProperty(path)) return require.aliases[path];
    }
  };

  /**
   * Normalize `path` relative to the current path.
   *
   * @param {String} curr
   * @param {String} path
   * @return {String}
   * @api private
   */

  require.normalize = function(curr, path) {
    var segs = [];

    if ('.' != path.charAt(0)) return path;

    curr = curr.split('/');
    path = path.split('/');

    for (var i = 0; i < path.length; ++i) {
      if ('..' == path[i]) {
        curr.pop();
      } else if ('.' != path[i] && '' != path[i]) {
        segs.push(path[i]);
      }
    }

    return curr.concat(segs).join('/');
  };

  /**
   * Register module at `path` with callback `definition`.
   *
   * @param {String} path
   * @param {Function} definition
   * @api private
   */

  require.register = function(path, definition) {
    require.modules[path] = definition;
  };

  /**
   * Alias a module definition.
   *
   * @param {String} from
   * @param {String} to
   * @api private
   */

  require.alias = function(from, to) {
    if (!require.modules.hasOwnProperty(from)) {
      throw new Error('Failed to alias "' + from + '", it does not exist');
    }
    require.aliases[to] = from;
  };

  /**
   * Return a require function relative to the `parent` path.
   *
   * @param {String} parent
   * @return {Function}
   * @api private
   */

  require.relative = function(parent) {
    var p = require.normalize(parent, '..');

    /**
     * lastIndexOf helper.
     */

    function lastIndexOf(arr, obj) {
      var i = arr.length;
      while (i--) {
        if (arr[i] === obj) return i;
      }
      return -1;
    }

    /**
     * The relative require() itself.
     */

    function localRequire(path) {
      var resolved = localRequire.resolve(path);
      return require(resolved, parent, path);
    }

    /**
     * Resolve relative to the parent.
     */

    localRequire.resolve = function(path) {
      var c = path.charAt(0);
      if ('/' == c) return path.slice(1);
      if ('.' == c) return require.normalize(p, path);

      // resolve deps by returning
      // the dep in the nearest "deps"
      // directory
      var segs = parent.split('/');
      var i = lastIndexOf(segs, 'deps') + 1;
      if (!i) i = 0;
      path = segs.slice(0, i + 1).join('/') + '/deps/' + path;
      return path;
    };

    /**
     * Check if module is defined at `path`.
     */

    localRequire.exists = function(path) {
      return require.modules.hasOwnProperty(localRequire.resolve(path));
    };

    return localRequire;
  };
  require.register("chaijs-assertion-error/index.js", function(exports, require, module){
    /*!
     * assertion-error
     * Copyright(c) 2013 Jake Luer <jake@qualiancy.com>
     * MIT Licensed
     */

    /*!
     * Return a function that will copy properties from
     * one object to another excluding any originally
     * listed. Returned function will create a new `{}`.
     *
     * @param {String} excluded properties ...
     * @return {Function}
     */

    function exclude () {
      var excludes = [].slice.call(arguments);

      function excludeProps (res, obj) {
        Object.keys(obj).forEach(function (key) {
          if (!~excludes.indexOf(key)) res[key] = obj[key];
        });
      }

      return function extendExclude () {
        var args = [].slice.call(arguments)
            , i = 0
            , res = {};

        for (; i < args.length; i++) {
          excludeProps(res, args[i]);
        }

        return res;
      };
    };

    /*!
     * Primary Exports
     */

    module.exports = AssertionError;

    /**
     * ### AssertionError
     *
     * An extension of the JavaScript `Error` constructor for
     * assertion and validation scenarios.
     *
     * @param {String} message
     * @param {Object} properties to include (optional)
     * @param {callee} start stack function (optional)
     */

    function AssertionError (message, _props, ssf) {
      var extend = exclude('name', 'message', 'stack', 'constructor', 'toJSON')
          , props = extend(_props || {});

      // default values
      this.message = message || 'Unspecified AssertionError';
      this.showDiff = false;

      // copy from properties
      for (var key in props) {
        this[key] = props[key];
      }

      // capture stack trace
      ssf = ssf || arguments.callee;
      if (ssf && Error.captureStackTrace) {
        Error.captureStackTrace(this, ssf);
      }
    }

    /*!
     * Inherit from Error.prototype
     */

    AssertionError.prototype = Object.create(Error.prototype);

    /*!
     * Statically set name
     */

    AssertionError.prototype.name = 'AssertionError';

    /*!
     * Ensure correct constructor
     */

    AssertionError.prototype.constructor = AssertionError;

    /**
     * Allow errors to be converted to JSON for static transfer.
     *
     * @param {Boolean} include stack (default: `true`)
     * @return {Object} object that can be `JSON.stringify`
     */

    AssertionError.prototype.toJSON = function (stack) {
      var extend = exclude('constructor', 'toJSON', 'stack')
          , props = extend({ name: this.name }, this);

      // include stack if exists and not turned off
      if (false !== stack && this.stack) {
        props.stack = this.stack;
      }

      return props;
    };

  });
  require.register("chaijs-type-detect/lib/type.js", function(exports, require, module){
    /*!
     * type-detect
     * Copyright(c) 2013 jake luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /*!
     * Primary Exports
     */

    var exports = module.exports = getType;

    /*!
     * Detectable javascript natives
     */

    var natives = {
      '[object Array]': 'array'
      , '[object RegExp]': 'regexp'
      , '[object Function]': 'function'
      , '[object Arguments]': 'arguments'
      , '[object Date]': 'date'
    };

    /**
     * ### typeOf (obj)
     *
     * Use several different techniques to determine
     * the type of object being tested.
     *
     *
     * @param {Mixed} object
     * @return {String} object type
     * @api public
     */

    function getType (obj) {
      var str = Object.prototype.toString.call(obj);
      if (natives[str]) return natives[str];
      if (obj === null) return 'null';
      if (obj === undefined) return 'undefined';
      if (obj === Object(obj)) return 'object';
      return typeof obj;
    }

    exports.Library = Library;

    /**
     * ### Library
     *
     * Create a repository for custom type detection.
     *
     * ```js
     * var lib = new type.Library;
     * ```
     *
     */

    function Library () {
      this.tests = {};
    }

    /**
     * #### .of (obj)
     *
     * Expose replacement `typeof` detection to the library.
     *
     * ```js
     * if ('string' === lib.of('hello world')) {
 *   // ...
 * }
     * ```
     *
     * @param {Mixed} object to test
     * @return {String} type
     */

    Library.prototype.of = getType;

    /**
     * #### .define (type, test)
     *
     * Add a test to for the `.test()` assertion.
     *
     * Can be defined as a regular expression:
     *
     * ```js
     * lib.define('int', /^[0-9]+$/);
     * ```
     *
     * ... or as a function:
     *
     * ```js
     * lib.define('bln', function (obj) {
 *   if ('boolean' === lib.of(obj)) return true;
 *   var blns = [ 'yes', 'no', 'true', 'false', 1, 0 ];
 *   if ('string' === lib.of(obj)) obj = obj.toLowerCase();
 *   return !! ~blns.indexOf(obj);
 * });
     * ```
     *
     * @param {String} type
     * @param {RegExp|Function} test
     * @api public
     */

    Library.prototype.define = function (type, test) {
      if (arguments.length === 1) return this.tests[type];
      this.tests[type] = test;
      return this;
    };

    /**
     * #### .test (obj, test)
     *
     * Assert that an object is of type. Will first
     * check natives, and if that does not pass it will
     * use the user defined custom tests.
     *
     * ```js
     * assert(lib.test('1', 'int'));
     * assert(lib.test('yes', 'bln'));
     * ```
     *
     * @param {Mixed} object
     * @param {String} type
     * @return {Boolean} result
     * @api public
     */

    Library.prototype.test = function (obj, type) {
      if (type === getType(obj)) return true;
      var test = this.tests[type];

      if (test && 'regexp' === getType(test)) {
        return test.test(obj);
      } else if (test && 'function' === getType(test)) {
        return test(obj);
      } else {
        throw new ReferenceError('Type test "' + type + '" not defined or invalid.');
      }
    };

  });
  require.register("chaijs-deep-eql/lib/eql.js", function(exports, require, module){
    /*!
     * deep-eql
     * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /*!
     * Module dependencies
     */

    var type = require('type-detect');

    /*!
     * Buffer.isBuffer browser shim
     */

    var Buffer;
    try { Buffer = require('buffer').Buffer; }
    catch(ex) {
      Buffer = {};
      Buffer.isBuffer = function() { return false; }
    }

    /*!
     * Primary Export
     */

    module.exports = deepEqual;

    /**
     * Assert super-strict (egal) equality between
     * two objects of any type.
     *
     * @param {Mixed} a
     * @param {Mixed} b
     * @param {Array} memoised (optional)
     * @return {Boolean} equal match
     */

    function deepEqual(a, b, m) {
      if (sameValue(a, b)) {
        return true;
      } else if ('date' === type(a)) {
        return dateEqual(a, b);
      } else if ('regexp' === type(a)) {
        return regexpEqual(a, b);
      } else if (Buffer.isBuffer(a)) {
        return bufferEqual(a, b);
      } else if ('arguments' === type(a)) {
        return argumentsEqual(a, b, m);
      } else if (!typeEqual(a, b)) {
        return false;
      } else if (('object' !== type(a) && 'object' !== type(b))
          && ('array' !== type(a) && 'array' !== type(b))) {
        return sameValue(a, b);
      } else {
        return objectEqual(a, b, m);
      }
    }

    /*!
     * Strict (egal) equality test. Ensures that NaN always
     * equals NaN and `-0` does not equal `+0`.
     *
     * @param {Mixed} a
     * @param {Mixed} b
     * @return {Boolean} equal match
     */

    function sameValue(a, b) {
      if (a === b) return a !== 0 || 1 / a === 1 / b;
      return a !== a && b !== b;
    }

    /*!
     * Compare the types of two given objects and
     * return if they are equal. Note that an Array
     * has a type of `array` (not `object`) and arguments
     * have a type of `arguments` (not `array`/`object`).
     *
     * @param {Mixed} a
     * @param {Mixed} b
     * @return {Boolean} result
     */

    function typeEqual(a, b) {
      return type(a) === type(b);
    }

    /*!
     * Compare two Date objects by asserting that
     * the time values are equal using `saveValue`.
     *
     * @param {Date} a
     * @param {Date} b
     * @return {Boolean} result
     */

    function dateEqual(a, b) {
      if ('date' !== type(b)) return false;
      return sameValue(a.getTime(), b.getTime());
    }

    /*!
     * Compare two regular expressions by converting them
     * to string and checking for `sameValue`.
     *
     * @param {RegExp} a
     * @param {RegExp} b
     * @return {Boolean} result
     */

    function regexpEqual(a, b) {
      if ('regexp' !== type(b)) return false;
      return sameValue(a.toString(), b.toString());
    }

    /*!
     * Assert deep equality of two `arguments` objects.
     * Unfortunately, these must be sliced to arrays
     * prior to test to ensure no bad behavior.
     *
     * @param {Arguments} a
     * @param {Arguments} b
     * @param {Array} memoize (optional)
     * @return {Boolean} result
     */

    function argumentsEqual(a, b, m) {
      if ('arguments' !== type(b)) return false;
      a = [].slice.call(a);
      b = [].slice.call(b);
      return deepEqual(a, b, m);
    }

    /*!
     * Get enumerable properties of a given object.
     *
     * @param {Object} a
     * @return {Array} property names
     */

    function enumerable(a) {
      var res = [];
      for (var key in a) res.push(key);
      return res;
    }

    /*!
     * Simple equality for flat iterable objects
     * such as Arrays or Node.js buffers.
     *
     * @param {Iterable} a
     * @param {Iterable} b
     * @return {Boolean} result
     */

    function iterableEqual(a, b) {
      if (a.length !==  b.length) return false;

      var i = 0;
      var match = true;

      for (; i < a.length; i++) {
        if (a[i] !== b[i]) {
          match = false;
          break;
        }
      }

      return match;
    }

    /*!
     * Extension to `iterableEqual` specifically
     * for Node.js Buffers.
     *
     * @param {Buffer} a
     * @param {Mixed} b
     * @return {Boolean} result
     */

    function bufferEqual(a, b) {
      if (!Buffer.isBuffer(b)) return false;
      return iterableEqual(a, b);
    }

    /*!
     * Block for `objectEqual` ensuring non-existing
     * values don't get in.
     *
     * @param {Mixed} object
     * @return {Boolean} result
     */

    function isValue(a) {
      return a !== null && a !== undefined;
    }

    /*!
     * Recursively check the equality of two objects.
     * Once basic sameness has been established it will
     * defer to `deepEqual` for each enumerable key
     * in the object.
     *
     * @param {Mixed} a
     * @param {Mixed} b
     * @return {Boolean} result
     */

    function objectEqual(a, b, m) {
      if (!isValue(a) || !isValue(b)) {
        return false;
      }

      if (a.prototype !== b.prototype) {
        return false;
      }

      var i;
      if (m) {
        for (i = 0; i < m.length; i++) {
          if ((m[i][0] === a && m[i][1] === b)
              ||  (m[i][0] === b && m[i][1] === a)) {
            return true;
          }
        }
      } else {
        m = [];
      }

      try {
        var ka = enumerable(a);
        var kb = enumerable(b);
      } catch (ex) {
        return false;
      }

      ka.sort();
      kb.sort();

      if (!iterableEqual(ka, kb)) {
        return false;
      }

      m.push([ a, b ]);

      var key;
      for (i = ka.length - 1; i >= 0; i--) {
        key = ka[i];
        if (!deepEqual(a[key], b[key], m)) {
          return false;
        }
      }

      return true;
    }

  });
  require.register("chai/index.js", function(exports, require, module){
    module.exports = require('./lib/chai');

  });
  require.register("chai/lib/chai.js", function(exports, require, module){
    /*!
     * chai
     * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    var used = []
        , exports = module.exports = {};

    /*!
     * Chai version
     */

    exports.version = '1.8.1';

    /*!
     * Assertion Error
     */

    exports.AssertionError = require('assertion-error');

    /*!
     * Utils for plugins (not exported)
     */

    var util = require('./chai/utils');

    /**
     * # .use(function)
     *
     * Provides a way to extend the internals of Chai
     *
     * @param {Function}
     * @returns {this} for chaining
     * @api public
     */

    exports.use = function (fn) {
      if (!~used.indexOf(fn)) {
        fn(this, util);
        used.push(fn);
      }

      return this;
    };

    /*!
     * Primary `Assertion` prototype
     */

    var assertion = require('./chai/assertion');
    exports.use(assertion);

    /*!
     * Core Assertions
     */

    var core = require('./chai/core/assertions');
    exports.use(core);

    /*!
     * Expect interface
     */

    var expect = require('./chai/interface/expect');
    exports.use(expect);

    /*!
     * Should interface
     */

    var should = require('./chai/interface/should');
    exports.use(should);

    /*!
     * Assert interface
     */

    var assert = require('./chai/interface/assert');
    exports.use(assert);

  });
  require.register("chai/lib/chai/assertion.js", function(exports, require, module){
    /*!
     * chai
     * http://chaijs.com
     * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    module.exports = function (_chai, util) {
      /*!
       * Module dependencies.
       */

      var AssertionError = _chai.AssertionError
          , flag = util.flag;

      /*!
       * Module export.
       */

      _chai.Assertion = Assertion;

      /*!
       * Assertion Constructor
       *
       * Creates object for chaining.
       *
       * @api private
       */

      function Assertion (obj, msg, stack) {
        flag(this, 'ssfi', stack || arguments.callee);
        flag(this, 'object', obj);
        flag(this, 'message', msg);
      }

      /*!
       * ### Assertion.includeStack
       *
       * User configurable property, influences whether stack trace
       * is included in Assertion error message. Default of false
       * suppresses stack trace in the error message
       *
       *     Assertion.includeStack = true;  // enable stack on error
       *
       * @api public
       */

      Assertion.includeStack = false;

      /*!
       * ### Assertion.showDiff
       *
       * User configurable property, influences whether or not
       * the `showDiff` flag should be included in the thrown
       * AssertionErrors. `false` will always be `false`; `true`
       * will be true when the assertion has requested a diff
       * be shown.
       *
       * @api public
       */

      Assertion.showDiff = true;

      Assertion.addProperty = function (name, fn) {
        util.addProperty(this.prototype, name, fn);
      };

      Assertion.addMethod = function (name, fn) {
        util.addMethod(this.prototype, name, fn);
      };

      Assertion.addChainableMethod = function (name, fn, chainingBehavior) {
        util.addChainableMethod(this.prototype, name, fn, chainingBehavior);
      };

      Assertion.overwriteProperty = function (name, fn) {
        util.overwriteProperty(this.prototype, name, fn);
      };

      Assertion.overwriteMethod = function (name, fn) {
        util.overwriteMethod(this.prototype, name, fn);
      };

      Assertion.overwriteChainableMethod = function (name, fn, chainingBehavior) {
        util.overwriteChainableMethod(this.prototype, name, fn, chainingBehavior);
      };

      /*!
       * ### .assert(expression, message, negateMessage, expected, actual)
       *
       * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass.
       *
       * @name assert
       * @param {Philosophical} expression to be tested
       * @param {String} message to display if fails
       * @param {String} negatedMessage to display if negated expression fails
       * @param {Mixed} expected value (remember to check for negation)
       * @param {Mixed} actual (optional) will default to `this.obj`
       * @api private
       */

      Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) {
        var ok = util.test(this, arguments);
        if (true !== showDiff) showDiff = false;
        if (true !== Assertion.showDiff) showDiff = false;

        if (!ok) {
          var msg = util.getMessage(this, arguments)
              , actual = util.getActual(this, arguments);
          throw new AssertionError(msg, {
            actual: actual
            , expected: expected
            , showDiff: showDiff
          }, (Assertion.includeStack) ? this.assert : flag(this, 'ssfi'));
        }
      };

      /*!
       * ### ._obj
       *
       * Quick reference to stored `actual` value for plugin developers.
       *
       * @api private
       */

      Object.defineProperty(Assertion.prototype, '_obj',
          { get: function () {
            return flag(this, 'object');
          }
            , set: function (val) {
            flag(this, 'object', val);
          }
          });
    };

  });
  require.register("chai/lib/chai/core/assertions.js", function(exports, require, module){
    /*!
     * chai
     * http://chaijs.com
     * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    module.exports = function (chai, _) {
      var Assertion = chai.Assertion
          , toString = Object.prototype.toString
          , flag = _.flag;

      /**
       * ### Language Chains
       *
       * The following are provided as chainable getters to
       * improve the readability of your assertions. They
       * do not provide an testing capability unless they
       * have been overwritten by a plugin.
       *
       * **Chains**
       *
       * - to
       * - be
       * - been
       * - is
       * - that
       * - and
       * - has
       * - have
       * - with
       * - at
       * - of
       * - same
       *
       * @name language chains
       * @api public
       */

      [ 'to', 'be', 'been'
        , 'is', 'and', 'has', 'have'
        , 'with', 'that', 'at'
        , 'of', 'same' ].forEach(function (chain) {
            Assertion.addProperty(chain, function () {
              return this;
            });
          });

      /**
       * ### .not
       *
       * Negates any of assertions following in the chain.
       *
       *     expect(foo).to.not.equal('bar');
       *     expect(goodFn).to.not.throw(Error);
       *     expect({ foo: 'baz' }).to.have.property('foo')
       *       .and.not.equal('bar');
       *
       * @name not
       * @api public
       */

      Assertion.addProperty('not', function () {
        flag(this, 'negate', true);
      });

      /**
       * ### .deep
       *
       * Sets the `deep` flag, later used by the `equal` and
       * `property` assertions.
       *
       *     expect(foo).to.deep.equal({ bar: 'baz' });
       *     expect({ foo: { bar: { baz: 'quux' } } })
       *       .to.have.deep.property('foo.bar.baz', 'quux');
       *
       * @name deep
       * @api public
       */

      Assertion.addProperty('deep', function () {
        flag(this, 'deep', true);
      });

      /**
       * ### .a(type)
       *
       * The `a` and `an` assertions are aliases that can be
       * used either as language chains or to assert a value's
       * type.
       *
       *     // typeof
       *     expect('test').to.be.a('string');
       *     expect({ foo: 'bar' }).to.be.an('object');
       *     expect(null).to.be.a('null');
       *     expect(undefined).to.be.an('undefined');
       *
       *     // language chain
       *     expect(foo).to.be.an.instanceof(Foo);
       *
       * @name a
       * @alias an
       * @param {String} type
       * @param {String} message _optional_
       * @api public
       */

      function an (type, msg) {
        if (msg) flag(this, 'message', msg);
        type = type.toLowerCase();
        var obj = flag(this, 'object')
            , article = ~[ 'a', 'e', 'i', 'o', 'u' ].indexOf(type.charAt(0)) ? 'an ' : 'a ';

        this.assert(
            type === _.type(obj)
            , 'expected #{this} to be ' + article + type
            , 'expected #{this} not to be ' + article + type
        );
      }

      Assertion.addChainableMethod('an', an);
      Assertion.addChainableMethod('a', an);

      /**
       * ### .include(value)
       *
       * The `include` and `contain` assertions can be used as either property
       * based language chains or as methods to assert the inclusion of an object
       * in an array or a substring in a string. When used as language chains,
       * they toggle the `contain` flag for the `keys` assertion.
       *
       *     expect([1,2,3]).to.include(2);
       *     expect('foobar').to.contain('foo');
       *     expect({ foo: 'bar', hello: 'universe' }).to.include.keys('foo');
       *
       * @name include
       * @alias contain
       * @param {Object|String|Number} obj
       * @param {String} message _optional_
       * @api public
       */

      function includeChainingBehavior () {
        flag(this, 'contains', true);
      }

      function include (val, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object');

        if (_.type(val) === 'object') {
          if (!flag(this, 'negate')) {
            for (var k in val) new Assertion(obj).property(k, val[k]);
            return;
          }
          var subset = {}
          for (var k in val) subset[k] = obj[k]
          var expected = _.eql(subset, val);
        } else {
          var expected = obj && ~obj.indexOf(val)
        }
        this.assert(
            expected
            , 'expected #{this} to include ' + _.inspect(val)
            , 'expected #{this} to not include ' + _.inspect(val));
      }

      Assertion.addChainableMethod('include', include, includeChainingBehavior);
      Assertion.addChainableMethod('contain', include, includeChainingBehavior);

      /**
       * ### .ok
       *
       * Asserts that the target is truthy.
       *
       *     expect('everthing').to.be.ok;
       *     expect(1).to.be.ok;
       *     expect(false).to.not.be.ok;
       *     expect(undefined).to.not.be.ok;
       *     expect(null).to.not.be.ok;
       *
       * @name ok
       * @api public
       */

      Assertion.addProperty('ok', function () {
        this.assert(
            flag(this, 'object')
            , 'expected #{this} to be truthy'
            , 'expected #{this} to be falsy');
      });

      /**
       * ### .true
       *
       * Asserts that the target is `true`.
       *
       *     expect(true).to.be.true;
       *     expect(1).to.not.be.true;
       *
       * @name true
       * @api public
       */

      Assertion.addProperty('true', function () {
        this.assert(
            true === flag(this, 'object')
            , 'expected #{this} to be true'
            , 'expected #{this} to be false'
            , this.negate ? false : true
        );
      });

      /**
       * ### .false
       *
       * Asserts that the target is `false`.
       *
       *     expect(false).to.be.false;
       *     expect(0).to.not.be.false;
       *
       * @name false
       * @api public
       */

      Assertion.addProperty('false', function () {
        this.assert(
            false === flag(this, 'object')
            , 'expected #{this} to be false'
            , 'expected #{this} to be true'
            , this.negate ? true : false
        );
      });

      /**
       * ### .null
       *
       * Asserts that the target is `null`.
       *
       *     expect(null).to.be.null;
       *     expect(undefined).not.to.be.null;
       *
       * @name null
       * @api public
       */

      Assertion.addProperty('null', function () {
        this.assert(
            null === flag(this, 'object')
            , 'expected #{this} to be null'
            , 'expected #{this} not to be null'
        );
      });

      /**
       * ### .undefined
       *
       * Asserts that the target is `undefined`.
       *
       *     expect(undefined).to.be.undefined;
       *     expect(null).to.not.be.undefined;
       *
       * @name undefined
       * @api public
       */

      Assertion.addProperty('undefined', function () {
        this.assert(
            undefined === flag(this, 'object')
            , 'expected #{this} to be undefined'
            , 'expected #{this} not to be undefined'
        );
      });

      /**
       * ### .exist
       *
       * Asserts that the target is neither `null` nor `undefined`.
       *
       *     var foo = 'hi'
       *       , bar = null
       *       , baz;
       *
       *     expect(foo).to.exist;
       *     expect(bar).to.not.exist;
       *     expect(baz).to.not.exist;
       *
       * @name exist
       * @api public
       */

      Assertion.addProperty('exist', function () {
        this.assert(
            null != flag(this, 'object')
            , 'expected #{this} to exist'
            , 'expected #{this} to not exist'
        );
      });


      /**
       * ### .empty
       *
       * Asserts that the target's length is `0`. For arrays, it checks
       * the `length` property. For objects, it gets the count of
       * enumerable keys.
       *
       *     expect([]).to.be.empty;
       *     expect('').to.be.empty;
       *     expect({}).to.be.empty;
       *
       * @name empty
       * @api public
       */

      Assertion.addProperty('empty', function () {
        var obj = flag(this, 'object')
            , expected = obj;

        if (Array.isArray(obj) || 'string' === typeof object) {
          expected = obj.length;
        } else if (typeof obj === 'object') {
          expected = Object.keys(obj).length;
        }

        this.assert(
            !expected
            , 'expected #{this} to be empty'
            , 'expected #{this} not to be empty'
        );
      });

      /**
       * ### .arguments
       *
       * Asserts that the target is an arguments object.
       *
       *     function test () {
   *       expect(arguments).to.be.arguments;
   *     }
       *
       * @name arguments
       * @alias Arguments
       * @api public
       */

      function checkArguments () {
        var obj = flag(this, 'object')
            , type = Object.prototype.toString.call(obj);
        this.assert(
            '[object Arguments]' === type
            , 'expected #{this} to be arguments but got ' + type
            , 'expected #{this} to not be arguments'
        );
      }

      Assertion.addProperty('arguments', checkArguments);
      Assertion.addProperty('Arguments', checkArguments);

      /**
       * ### .equal(value)
       *
       * Asserts that the target is strictly equal (`===`) to `value`.
       * Alternately, if the `deep` flag is set, asserts that
       * the target is deeply equal to `value`.
       *
       *     expect('hello').to.equal('hello');
       *     expect(42).to.equal(42);
       *     expect(1).to.not.equal(true);
       *     expect({ foo: 'bar' }).to.not.equal({ foo: 'bar' });
       *     expect({ foo: 'bar' }).to.deep.equal({ foo: 'bar' });
       *
       * @name equal
       * @alias equals
       * @alias eq
       * @alias deep.equal
       * @param {Mixed} value
       * @param {String} message _optional_
       * @api public
       */

      function assertEqual (val, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object');
        if (flag(this, 'deep')) {
          return this.eql(val);
        } else {
          this.assert(
              val === obj
              , 'expected #{this} to equal #{exp}'
              , 'expected #{this} to not equal #{exp}'
              , val
              , this._obj
              , true
          );
        }
      }

      Assertion.addMethod('equal', assertEqual);
      Assertion.addMethod('equals', assertEqual);
      Assertion.addMethod('eq', assertEqual);

      /**
       * ### .eql(value)
       *
       * Asserts that the target is deeply equal to `value`.
       *
       *     expect({ foo: 'bar' }).to.eql({ foo: 'bar' });
       *     expect([ 1, 2, 3 ]).to.eql([ 1, 2, 3 ]);
       *
       * @name eql
       * @alias eqls
       * @param {Mixed} value
       * @param {String} message _optional_
       * @api public
       */

      function assertEql(obj, msg) {
        if (msg) flag(this, 'message', msg);
        this.assert(
            _.eql(obj, flag(this, 'object'))
            , 'expected #{this} to deeply equal #{exp}'
            , 'expected #{this} to not deeply equal #{exp}'
            , obj
            , this._obj
            , true
        );
      }

      Assertion.addMethod('eql', assertEql);
      Assertion.addMethod('eqls', assertEql);

      /**
       * ### .above(value)
       *
       * Asserts that the target is greater than `value`.
       *
       *     expect(10).to.be.above(5);
       *
       * Can also be used in conjunction with `length` to
       * assert a minimum length. The benefit being a
       * more informative error message than if the length
       * was supplied directly.
       *
       *     expect('foo').to.have.length.above(2);
       *     expect([ 1, 2, 3 ]).to.have.length.above(2);
       *
       * @name above
       * @alias gt
       * @alias greaterThan
       * @param {Number} value
       * @param {String} message _optional_
       * @api public
       */

      function assertAbove (n, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object');
        if (flag(this, 'doLength')) {
          new Assertion(obj, msg).to.have.property('length');
          var len = obj.length;
          this.assert(
              len > n
              , 'expected #{this} to have a length above #{exp} but got #{act}'
              , 'expected #{this} to not have a length above #{exp}'
              , n
              , len
          );
        } else {
          this.assert(
              obj > n
              , 'expected #{this} to be above ' + n
              , 'expected #{this} to be at most ' + n
          );
        }
      }

      Assertion.addMethod('above', assertAbove);
      Assertion.addMethod('gt', assertAbove);
      Assertion.addMethod('greaterThan', assertAbove);

      /**
       * ### .least(value)
       *
       * Asserts that the target is greater than or equal to `value`.
       *
       *     expect(10).to.be.at.least(10);
       *
       * Can also be used in conjunction with `length` to
       * assert a minimum length. The benefit being a
       * more informative error message than if the length
       * was supplied directly.
       *
       *     expect('foo').to.have.length.of.at.least(2);
       *     expect([ 1, 2, 3 ]).to.have.length.of.at.least(3);
       *
       * @name least
       * @alias gte
       * @param {Number} value
       * @param {String} message _optional_
       * @api public
       */

      function assertLeast (n, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object');
        if (flag(this, 'doLength')) {
          new Assertion(obj, msg).to.have.property('length');
          var len = obj.length;
          this.assert(
              len >= n
              , 'expected #{this} to have a length at least #{exp} but got #{act}'
              , 'expected #{this} to have a length below #{exp}'
              , n
              , len
          );
        } else {
          this.assert(
              obj >= n
              , 'expected #{this} to be at least ' + n
              , 'expected #{this} to be below ' + n
          );
        }
      }

      Assertion.addMethod('least', assertLeast);
      Assertion.addMethod('gte', assertLeast);

      /**
       * ### .below(value)
       *
       * Asserts that the target is less than `value`.
       *
       *     expect(5).to.be.below(10);
       *
       * Can also be used in conjunction with `length` to
       * assert a maximum length. The benefit being a
       * more informative error message than if the length
       * was supplied directly.
       *
       *     expect('foo').to.have.length.below(4);
       *     expect([ 1, 2, 3 ]).to.have.length.below(4);
       *
       * @name below
       * @alias lt
       * @alias lessThan
       * @param {Number} value
       * @param {String} message _optional_
       * @api public
       */

      function assertBelow (n, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object');
        if (flag(this, 'doLength')) {
          new Assertion(obj, msg).to.have.property('length');
          var len = obj.length;
          this.assert(
              len < n
              , 'expected #{this} to have a length below #{exp} but got #{act}'
              , 'expected #{this} to not have a length below #{exp}'
              , n
              , len
          );
        } else {
          this.assert(
              obj < n
              , 'expected #{this} to be below ' + n
              , 'expected #{this} to be at least ' + n
          );
        }
      }

      Assertion.addMethod('below', assertBelow);
      Assertion.addMethod('lt', assertBelow);
      Assertion.addMethod('lessThan', assertBelow);

      /**
       * ### .most(value)
       *
       * Asserts that the target is less than or equal to `value`.
       *
       *     expect(5).to.be.at.most(5);
       *
       * Can also be used in conjunction with `length` to
       * assert a maximum length. The benefit being a
       * more informative error message than if the length
       * was supplied directly.
       *
       *     expect('foo').to.have.length.of.at.most(4);
       *     expect([ 1, 2, 3 ]).to.have.length.of.at.most(3);
       *
       * @name most
       * @alias lte
       * @param {Number} value
       * @param {String} message _optional_
       * @api public
       */

      function assertMost (n, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object');
        if (flag(this, 'doLength')) {
          new Assertion(obj, msg).to.have.property('length');
          var len = obj.length;
          this.assert(
              len <= n
              , 'expected #{this} to have a length at most #{exp} but got #{act}'
              , 'expected #{this} to have a length above #{exp}'
              , n
              , len
          );
        } else {
          this.assert(
              obj <= n
              , 'expected #{this} to be at most ' + n
              , 'expected #{this} to be above ' + n
          );
        }
      }

      Assertion.addMethod('most', assertMost);
      Assertion.addMethod('lte', assertMost);

      /**
       * ### .within(start, finish)
       *
       * Asserts that the target is within a range.
       *
       *     expect(7).to.be.within(5,10);
       *
       * Can also be used in conjunction with `length` to
       * assert a length range. The benefit being a
       * more informative error message than if the length
       * was supplied directly.
       *
       *     expect('foo').to.have.length.within(2,4);
       *     expect([ 1, 2, 3 ]).to.have.length.within(2,4);
       *
       * @name within
       * @param {Number} start lowerbound inclusive
       * @param {Number} finish upperbound inclusive
       * @param {String} message _optional_
       * @api public
       */

      Assertion.addMethod('within', function (start, finish, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object')
            , range = start + '..' + finish;
        if (flag(this, 'doLength')) {
          new Assertion(obj, msg).to.have.property('length');
          var len = obj.length;
          this.assert(
              len >= start && len <= finish
              , 'expected #{this} to have a length within ' + range
              , 'expected #{this} to not have a length within ' + range
          );
        } else {
          this.assert(
              obj >= start && obj <= finish
              , 'expected #{this} to be within ' + range
              , 'expected #{this} to not be within ' + range
          );
        }
      });

      /**
       * ### .instanceof(constructor)
       *
       * Asserts that the target is an instance of `constructor`.
       *
       *     var Tea = function (name) { this.name = name; }
       *       , Chai = new Tea('chai');
       *
       *     expect(Chai).to.be.an.instanceof(Tea);
       *     expect([ 1, 2, 3 ]).to.be.instanceof(Array);
       *
       * @name instanceof
       * @param {Constructor} constructor
       * @param {String} message _optional_
       * @alias instanceOf
       * @api public
       */

      function assertInstanceOf (constructor, msg) {
        if (msg) flag(this, 'message', msg);
        var name = _.getName(constructor);
        this.assert(
            flag(this, 'object') instanceof constructor
            , 'expected #{this} to be an instance of ' + name
            , 'expected #{this} to not be an instance of ' + name
        );
      };

      Assertion.addMethod('instanceof', assertInstanceOf);
      Assertion.addMethod('instanceOf', assertInstanceOf);

      /**
       * ### .property(name, [value])
       *
       * Asserts that the target has a property `name`, optionally asserting that
       * the value of that property is strictly equal to  `value`.
       * If the `deep` flag is set, you can use dot- and bracket-notation for deep
       * references into objects and arrays.
       *
       *     // simple referencing
       *     var obj = { foo: 'bar' };
       *     expect(obj).to.have.property('foo');
       *     expect(obj).to.have.property('foo', 'bar');
       *
       *     // deep referencing
       *     var deepObj = {
   *         green: { tea: 'matcha' }
   *       , teas: [ 'chai', 'matcha', { tea: 'konacha' } ]
   *     };

       *     expect(deepObj).to.have.deep.property('green.tea', 'matcha');
       *     expect(deepObj).to.have.deep.property('teas[1]', 'matcha');
       *     expect(deepObj).to.have.deep.property('teas[2].tea', 'konacha');
       *
       * You can also use an array as the starting point of a `deep.property`
       * assertion, or traverse nested arrays.
       *
       *     var arr = [
       *         [ 'chai', 'matcha', 'konacha' ]
       *       , [ { tea: 'chai' }
       *         , { tea: 'matcha' }
       *         , { tea: 'konacha' } ]
       *     ];
       *
       *     expect(arr).to.have.deep.property('[0][1]', 'matcha');
       *     expect(arr).to.have.deep.property('[1][2].tea', 'konacha');
       *
       * Furthermore, `property` changes the subject of the assertion
       * to be the value of that property from the original object. This
       * permits for further chainable assertions on that property.
       *
       *     expect(obj).to.have.property('foo')
       *       .that.is.a('string');
       *     expect(deepObj).to.have.property('green')
       *       .that.is.an('object')
       *       .that.deep.equals({ tea: 'matcha' });
       *     expect(deepObj).to.have.property('teas')
       *       .that.is.an('array')
       *       .with.deep.property('[2]')
       *         .that.deep.equals({ tea: 'konacha' });
       *
       * @name property
       * @alias deep.property
       * @param {String} name
       * @param {Mixed} value (optional)
       * @param {String} message _optional_
       * @returns value of property for chaining
       * @api public
       */

      Assertion.addMethod('property', function (name, val, msg) {
        if (msg) flag(this, 'message', msg);

        var descriptor = flag(this, 'deep') ? 'deep property ' : 'property '
            , negate = flag(this, 'negate')
            , obj = flag(this, 'object')
            , value = flag(this, 'deep')
                ? _.getPathValue(name, obj)
                : obj[name];

        if (negate && undefined !== val) {
          if (undefined === value) {
            msg = (msg != null) ? msg + ': ' : '';
            throw new Error(msg + _.inspect(obj) + ' has no ' + descriptor + _.inspect(name));
          }
        } else {
          this.assert(
              undefined !== value
              , 'expected #{this} to have a ' + descriptor + _.inspect(name)
              , 'expected #{this} to not have ' + descriptor + _.inspect(name));
        }

        if (undefined !== val) {
          this.assert(
              val === value
              , 'expected #{this} to have a ' + descriptor + _.inspect(name) + ' of #{exp}, but got #{act}'
              , 'expected #{this} to not have a ' + descriptor + _.inspect(name) + ' of #{act}'
              , val
              , value
          );
        }

        flag(this, 'object', value);
      });


      /**
       * ### .ownProperty(name)
       *
       * Asserts that the target has an own property `name`.
       *
       *     expect('test').to.have.ownProperty('length');
       *
       * @name ownProperty
       * @alias haveOwnProperty
       * @param {String} name
       * @param {String} message _optional_
       * @api public
       */

      function assertOwnProperty (name, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object');
        this.assert(
            obj.hasOwnProperty(name)
            , 'expected #{this} to have own property ' + _.inspect(name)
            , 'expected #{this} to not have own property ' + _.inspect(name)
        );
      }

      Assertion.addMethod('ownProperty', assertOwnProperty);
      Assertion.addMethod('haveOwnProperty', assertOwnProperty);

      /**
       * ### .length(value)
       *
       * Asserts that the target's `length` property has
       * the expected value.
       *
       *     expect([ 1, 2, 3]).to.have.length(3);
       *     expect('foobar').to.have.length(6);
       *
       * Can also be used as a chain precursor to a value
       * comparison for the length property.
       *
       *     expect('foo').to.have.length.above(2);
       *     expect([ 1, 2, 3 ]).to.have.length.above(2);
       *     expect('foo').to.have.length.below(4);
       *     expect([ 1, 2, 3 ]).to.have.length.below(4);
       *     expect('foo').to.have.length.within(2,4);
       *     expect([ 1, 2, 3 ]).to.have.length.within(2,4);
       *
       * @name length
       * @alias lengthOf
       * @param {Number} length
       * @param {String} message _optional_
       * @api public
       */

      function assertLengthChain () {
        flag(this, 'doLength', true);
      }

      function assertLength (n, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object');
        new Assertion(obj, msg).to.have.property('length');
        var len = obj.length;

        this.assert(
            len == n
            , 'expected #{this} to have a length of #{exp} but got #{act}'
            , 'expected #{this} to not have a length of #{act}'
            , n
            , len
        );
      }

      Assertion.addChainableMethod('length', assertLength, assertLengthChain);
      Assertion.addMethod('lengthOf', assertLength, assertLengthChain);

      /**
       * ### .match(regexp)
       *
       * Asserts that the target matches a regular expression.
       *
       *     expect('foobar').to.match(/^foo/);
       *
       * @name match
       * @param {RegExp} RegularExpression
       * @param {String} message _optional_
       * @api public
       */

      Assertion.addMethod('match', function (re, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object');
        this.assert(
            re.exec(obj)
            , 'expected #{this} to match ' + re
            , 'expected #{this} not to match ' + re
        );
      });

      /**
       * ### .string(string)
       *
       * Asserts that the string target contains another string.
       *
       *     expect('foobar').to.have.string('bar');
       *
       * @name string
       * @param {String} string
       * @param {String} message _optional_
       * @api public
       */

      Assertion.addMethod('string', function (str, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object');
        new Assertion(obj, msg).is.a('string');

        this.assert(
            ~obj.indexOf(str)
            , 'expected #{this} to contain ' + _.inspect(str)
            , 'expected #{this} to not contain ' + _.inspect(str)
        );
      });


      /**
       * ### .keys(key1, [key2], [...])
       *
       * Asserts that the target has exactly the given keys, or
       * asserts the inclusion of some keys when using the
       * `include` or `contain` modifiers.
       *
       *     expect({ foo: 1, bar: 2 }).to.have.keys(['foo', 'bar']);
       *     expect({ foo: 1, bar: 2, baz: 3 }).to.contain.keys('foo', 'bar');
       *
       * @name keys
       * @alias key
       * @param {String...|Array} keys
       * @api public
       */

      function assertKeys (keys) {
        var obj = flag(this, 'object')
            , str
            , ok = true;

        keys = keys instanceof Array
            ? keys
            : Array.prototype.slice.call(arguments);

        if (!keys.length) throw new Error('keys required');

        var actual = Object.keys(obj)
            , len = keys.length;

        // Inclusion
        ok = keys.every(function(key){
          return ~actual.indexOf(key);
        });

        // Strict
        if (!flag(this, 'negate') && !flag(this, 'contains')) {
          ok = ok && keys.length == actual.length;
        }

        // Key string
        if (len > 1) {
          keys = keys.map(function(key){
            return _.inspect(key);
          });
          var last = keys.pop();
          str = keys.join(', ') + ', and ' + last;
        } else {
          str = _.inspect(keys[0]);
        }

        // Form
        str = (len > 1 ? 'keys ' : 'key ') + str;

        // Have / include
        str = (flag(this, 'contains') ? 'contain ' : 'have ') + str;

        // Assertion
        this.assert(
            ok
            , 'expected #{this} to ' + str
            , 'expected #{this} to not ' + str
        );
      }

      Assertion.addMethod('keys', assertKeys);
      Assertion.addMethod('key', assertKeys);

      /**
       * ### .throw(constructor)
       *
       * Asserts that the function target will throw a specific error, or specific type of error
       * (as determined using `instanceof`), optionally with a RegExp or string inclusion test
       * for the error's message.
       *
       *     var err = new ReferenceError('This is a bad function.');
       *     var fn = function () { throw err; }
       *     expect(fn).to.throw(ReferenceError);
       *     expect(fn).to.throw(Error);
       *     expect(fn).to.throw(/bad function/);
       *     expect(fn).to.not.throw('good function');
       *     expect(fn).to.throw(ReferenceError, /bad function/);
       *     expect(fn).to.throw(err);
       *     expect(fn).to.not.throw(new RangeError('Out of range.'));
       *
       * Please note that when a throw expectation is negated, it will check each
       * parameter independently, starting with error constructor type. The appropriate way
       * to check for the existence of a type of error but for a message that does not match
       * is to use `and`.
       *
       *     expect(fn).to.throw(ReferenceError)
       *        .and.not.throw(/good function/);
       *
       * @name throw
       * @alias throws
       * @alias Throw
       * @param {ErrorConstructor} constructor
       * @param {String|RegExp} expected error message
       * @param {String} message _optional_
       * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
       * @returns error for chaining (null if no error)
       * @api public
       */

      function assertThrows (constructor, errMsg, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object');
        new Assertion(obj, msg).is.a('function');

        var thrown = false
            , desiredError = null
            , name = null
            , thrownError = null;

        if (arguments.length === 0) {
          errMsg = null;
          constructor = null;
        } else if (constructor && (constructor instanceof RegExp || 'string' === typeof constructor)) {
          errMsg = constructor;
          constructor = null;
        } else if (constructor && constructor instanceof Error) {
          desiredError = constructor;
          constructor = null;
          errMsg = null;
        } else if (typeof constructor === 'function') {
          name = constructor.prototype.name || constructor.name;
          if (name === 'Error' && constructor !== Error) {
            name = (new constructor()).name;
          }
        } else {
          constructor = null;
        }

        try {
          obj();
        } catch (err) {
          // first, check desired error
          if (desiredError) {
            this.assert(
                err === desiredError
                , 'expected #{this} to throw #{exp} but #{act} was thrown'
                , 'expected #{this} to not throw #{exp}'
                , (desiredError instanceof Error ? desiredError.toString() : desiredError)
                , (err instanceof Error ? err.toString() : err)
            );

            flag(this, 'object', err);
            return this;
          }

          // next, check constructor
          if (constructor) {
            this.assert(
                err instanceof constructor
                , 'expected #{this} to throw #{exp} but #{act} was thrown'
                , 'expected #{this} to not throw #{exp} but #{act} was thrown'
                , name
                , (err instanceof Error ? err.toString() : err)
            );

            if (!errMsg) {
              flag(this, 'object', err);
              return this;
            }
          }

          // next, check message
          var message = 'object' === _.type(err) && "message" in err
              ? err.message
              : '' + err;

          if ((message != null) && errMsg && errMsg instanceof RegExp) {
            this.assert(
                errMsg.exec(message)
                , 'expected #{this} to throw error matching #{exp} but got #{act}'
                , 'expected #{this} to throw error not matching #{exp}'
                , errMsg
                , message
            );

            flag(this, 'object', err);
            return this;
          } else if ((message != null) && errMsg && 'string' === typeof errMsg) {
            this.assert(
                ~message.indexOf(errMsg)
                , 'expected #{this} to throw error including #{exp} but got #{act}'
                , 'expected #{this} to throw error not including #{act}'
                , errMsg
                , message
            );

            flag(this, 'object', err);
            return this;
          } else {
            thrown = true;
            thrownError = err;
          }
        }

        var actuallyGot = ''
            , expectedThrown = name !== null
                ? name
                : desiredError
                ? '#{exp}' //_.inspect(desiredError)
                : 'an error';

        if (thrown) {
          actuallyGot = ' but #{act} was thrown'
        }

        this.assert(
            thrown === true
            , 'expected #{this} to throw ' + expectedThrown + actuallyGot
            , 'expected #{this} to not throw ' + expectedThrown + actuallyGot
            , (desiredError instanceof Error ? desiredError.toString() : desiredError)
            , (thrownError instanceof Error ? thrownError.toString() : thrownError)
        );

        flag(this, 'object', thrownError);
      };

      Assertion.addMethod('throw', assertThrows);
      Assertion.addMethod('throws', assertThrows);
      Assertion.addMethod('Throw', assertThrows);

      /**
       * ### .respondTo(method)
       *
       * Asserts that the object or class target will respond to a method.
       *
       *     Klass.prototype.bar = function(){};
       *     expect(Klass).to.respondTo('bar');
       *     expect(obj).to.respondTo('bar');
       *
       * To check if a constructor will respond to a static function,
       * set the `itself` flag.
       *
       *     Klass.baz = function(){};
       *     expect(Klass).itself.to.respondTo('baz');
       *
       * @name respondTo
       * @param {String} method
       * @param {String} message _optional_
       * @api public
       */

      Assertion.addMethod('respondTo', function (method, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object')
            , itself = flag(this, 'itself')
            , context = ('function' === _.type(obj) && !itself)
                ? obj.prototype[method]
                : obj[method];

        this.assert(
            'function' === typeof context
            , 'expected #{this} to respond to ' + _.inspect(method)
            , 'expected #{this} to not respond to ' + _.inspect(method)
        );
      });

      /**
       * ### .itself
       *
       * Sets the `itself` flag, later used by the `respondTo` assertion.
       *
       *     function Foo() {}
       *     Foo.bar = function() {}
       *     Foo.prototype.baz = function() {}
       *
       *     expect(Foo).itself.to.respondTo('bar');
       *     expect(Foo).itself.not.to.respondTo('baz');
       *
       * @name itself
       * @api public
       */

      Assertion.addProperty('itself', function () {
        flag(this, 'itself', true);
      });

      /**
       * ### .satisfy(method)
       *
       * Asserts that the target passes a given truth test.
       *
       *     expect(1).to.satisfy(function(num) { return num > 0; });
       *
       * @name satisfy
       * @param {Function} matcher
       * @param {String} message _optional_
       * @api public
       */

      Assertion.addMethod('satisfy', function (matcher, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object');
        this.assert(
            matcher(obj)
            , 'expected #{this} to satisfy ' + _.objDisplay(matcher)
            , 'expected #{this} to not satisfy' + _.objDisplay(matcher)
            , this.negate ? false : true
            , matcher(obj)
        );
      });

      /**
       * ### .closeTo(expected, delta)
       *
       * Asserts that the target is equal `expected`, to within a +/- `delta` range.
       *
       *     expect(1.5).to.be.closeTo(1, 0.5);
       *
       * @name closeTo
       * @param {Number} expected
       * @param {Number} delta
       * @param {String} message _optional_
       * @api public
       */

      Assertion.addMethod('closeTo', function (expected, delta, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object');
        this.assert(
            Math.abs(obj - expected) <= delta
            , 'expected #{this} to be close to ' + expected + ' +/- ' + delta
            , 'expected #{this} not to be close to ' + expected + ' +/- ' + delta
        );
      });

      function isSubsetOf(subset, superset) {
        return subset.every(function(elem) {
          return superset.indexOf(elem) !== -1;
        })
      }

      /**
       * ### .members(set)
       *
       * Asserts that the target is a superset of `set`,
       * or that the target and `set` have the same members.
       *
       *     expect([1, 2, 3]).to.include.members([3, 2]);
       *     expect([1, 2, 3]).to.not.include.members([3, 2, 8]);
       *
       *     expect([4, 2]).to.have.members([2, 4]);
       *     expect([5, 2]).to.not.have.members([5, 2, 1]);
       *
       * @name members
       * @param {Array} set
       * @param {String} message _optional_
       * @api public
       */

      Assertion.addMethod('members', function (subset, msg) {
        if (msg) flag(this, 'message', msg);
        var obj = flag(this, 'object');

        new Assertion(obj).to.be.an('array');
        new Assertion(subset).to.be.an('array');

        if (flag(this, 'contains')) {
          return this.assert(
              isSubsetOf(subset, obj)
              , 'expected #{this} to be a superset of #{act}'
              , 'expected #{this} to not be a superset of #{act}'
              , obj
              , subset
          );
        }

        this.assert(
            isSubsetOf(obj, subset) && isSubsetOf(subset, obj)
            , 'expected #{this} to have the same members as #{act}'
            , 'expected #{this} to not have the same members as #{act}'
            , obj
            , subset
        );
      });
    };

  });
  require.register("chai/lib/chai/interface/assert.js", function(exports, require, module){
    /*!
     * chai
     * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */


    module.exports = function (chai, util) {

      /*!
       * Chai dependencies.
       */

      var Assertion = chai.Assertion
          , flag = util.flag;

      /*!
       * Module export.
       */

      /**
       * ### assert(expression, message)
       *
       * Write your own test expressions.
       *
       *     assert('foo' !== 'bar', 'foo is not bar');
       *     assert(Array.isArray([]), 'empty arrays are arrays');
       *
       * @param {Mixed} expression to test for truthiness
       * @param {String} message to display on error
       * @name assert
       * @api public
       */

      var assert = chai.assert = function (express, errmsg) {
        var test = new Assertion(null);
        test.assert(
            express
            , errmsg
            , '[ negation message unavailable ]'
        );
      };

      /**
       * ### .fail(actual, expected, [message], [operator])
       *
       * Throw a failure. Node.js `assert` module-compatible.
       *
       * @name fail
       * @param {Mixed} actual
       * @param {Mixed} expected
       * @param {String} message
       * @param {String} operator
       * @api public
       */

      assert.fail = function (actual, expected, message, operator) {
        message = message || 'assert.fail()';
        throw new chai.AssertionError(message, {
          actual: actual
          , expected: expected
          , operator: operator
        }, assert.fail);
      };

      /**
       * ### .ok(object, [message])
       *
       * Asserts that `object` is truthy.
       *
       *     assert.ok('everything', 'everything is ok');
       *     assert.ok(false, 'this will fail');
       *
       * @name ok
       * @param {Mixed} object to test
       * @param {String} message
       * @api public
       */

      assert.ok = function (val, msg) {
        new Assertion(val, msg).is.ok;
      };

      /**
       * ### .notOk(object, [message])
       *
       * Asserts that `object` is falsy.
       *
       *     assert.notOk('everything', 'this will fail');
       *     assert.notOk(false, 'this will pass');
       *
       * @name notOk
       * @param {Mixed} object to test
       * @param {String} message
       * @api public
       */

      assert.notOk = function (val, msg) {
        new Assertion(val, msg).is.not.ok;
      };

      /**
       * ### .equal(actual, expected, [message])
       *
       * Asserts non-strict equality (`==`) of `actual` and `expected`.
       *
       *     assert.equal(3, '3', '== coerces values to strings');
       *
       * @name equal
       * @param {Mixed} actual
       * @param {Mixed} expected
       * @param {String} message
       * @api public
       */

      assert.equal = function (act, exp, msg) {
        var test = new Assertion(act, msg);

        test.assert(
            exp == flag(test, 'object')
            , 'expected #{this} to equal #{exp}'
            , 'expected #{this} to not equal #{act}'
            , exp
            , act
        );
      };

      /**
       * ### .notEqual(actual, expected, [message])
       *
       * Asserts non-strict inequality (`!=`) of `actual` and `expected`.
       *
       *     assert.notEqual(3, 4, 'these numbers are not equal');
       *
       * @name notEqual
       * @param {Mixed} actual
       * @param {Mixed} expected
       * @param {String} message
       * @api public
       */

      assert.notEqual = function (act, exp, msg) {
        var test = new Assertion(act, msg);

        test.assert(
            exp != flag(test, 'object')
            , 'expected #{this} to not equal #{exp}'
            , 'expected #{this} to equal #{act}'
            , exp
            , act
        );
      };

      /**
       * ### .strictEqual(actual, expected, [message])
       *
       * Asserts strict equality (`===`) of `actual` and `expected`.
       *
       *     assert.strictEqual(true, true, 'these booleans are strictly equal');
       *
       * @name strictEqual
       * @param {Mixed} actual
       * @param {Mixed} expected
       * @param {String} message
       * @api public
       */

      assert.strictEqual = function (act, exp, msg) {
        new Assertion(act, msg).to.equal(exp);
      };

      /**
       * ### .notStrictEqual(actual, expected, [message])
       *
       * Asserts strict inequality (`!==`) of `actual` and `expected`.
       *
       *     assert.notStrictEqual(3, '3', 'no coercion for strict equality');
       *
       * @name notStrictEqual
       * @param {Mixed} actual
       * @param {Mixed} expected
       * @param {String} message
       * @api public
       */

      assert.notStrictEqual = function (act, exp, msg) {
        new Assertion(act, msg).to.not.equal(exp);
      };

      /**
       * ### .deepEqual(actual, expected, [message])
       *
       * Asserts that `actual` is deeply equal to `expected`.
       *
       *     assert.deepEqual({ tea: 'green' }, { tea: 'green' });
       *
       * @name deepEqual
       * @param {Mixed} actual
       * @param {Mixed} expected
       * @param {String} message
       * @api public
       */

      assert.deepEqual = function (act, exp, msg) {
        new Assertion(act, msg).to.eql(exp);
      };

      /**
       * ### .notDeepEqual(actual, expected, [message])
       *
       * Assert that `actual` is not deeply equal to `expected`.
       *
       *     assert.notDeepEqual({ tea: 'green' }, { tea: 'jasmine' });
       *
       * @name notDeepEqual
       * @param {Mixed} actual
       * @param {Mixed} expected
       * @param {String} message
       * @api public
       */

      assert.notDeepEqual = function (act, exp, msg) {
        new Assertion(act, msg).to.not.eql(exp);
      };

      /**
       * ### .isTrue(value, [message])
       *
       * Asserts that `value` is true.
       *
       *     var teaServed = true;
       *     assert.isTrue(teaServed, 'the tea has been served');
       *
       * @name isTrue
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isTrue = function (val, msg) {
        new Assertion(val, msg).is['true'];
      };

      /**
       * ### .isFalse(value, [message])
       *
       * Asserts that `value` is false.
       *
       *     var teaServed = false;
       *     assert.isFalse(teaServed, 'no tea yet? hmm...');
       *
       * @name isFalse
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isFalse = function (val, msg) {
        new Assertion(val, msg).is['false'];
      };

      /**
       * ### .isNull(value, [message])
       *
       * Asserts that `value` is null.
       *
       *     assert.isNull(err, 'there was no error');
       *
       * @name isNull
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isNull = function (val, msg) {
        new Assertion(val, msg).to.equal(null);
      };

      /**
       * ### .isNotNull(value, [message])
       *
       * Asserts that `value` is not null.
       *
       *     var tea = 'tasty chai';
       *     assert.isNotNull(tea, 'great, time for tea!');
       *
       * @name isNotNull
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isNotNull = function (val, msg) {
        new Assertion(val, msg).to.not.equal(null);
      };

      /**
       * ### .isUndefined(value, [message])
       *
       * Asserts that `value` is `undefined`.
       *
       *     var tea;
       *     assert.isUndefined(tea, 'no tea defined');
       *
       * @name isUndefined
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isUndefined = function (val, msg) {
        new Assertion(val, msg).to.equal(undefined);
      };

      /**
       * ### .isDefined(value, [message])
       *
       * Asserts that `value` is not `undefined`.
       *
       *     var tea = 'cup of chai';
       *     assert.isDefined(tea, 'tea has been defined');
       *
       * @name isDefined
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isDefined = function (val, msg) {
        new Assertion(val, msg).to.not.equal(undefined);
      };

      /**
       * ### .isFunction(value, [message])
       *
       * Asserts that `value` is a function.
       *
       *     function serveTea() { return 'cup of tea'; };
       *     assert.isFunction(serveTea, 'great, we can have tea now');
       *
       * @name isFunction
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isFunction = function (val, msg) {
        new Assertion(val, msg).to.be.a('function');
      };

      /**
       * ### .isNotFunction(value, [message])
       *
       * Asserts that `value` is _not_ a function.
       *
       *     var serveTea = [ 'heat', 'pour', 'sip' ];
       *     assert.isNotFunction(serveTea, 'great, we have listed the steps');
       *
       * @name isNotFunction
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isNotFunction = function (val, msg) {
        new Assertion(val, msg).to.not.be.a('function');
      };

      /**
       * ### .isObject(value, [message])
       *
       * Asserts that `value` is an object (as revealed by
       * `Object.prototype.toString`).
       *
       *     var selection = { name: 'Chai', serve: 'with spices' };
       *     assert.isObject(selection, 'tea selection is an object');
       *
       * @name isObject
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isObject = function (val, msg) {
        new Assertion(val, msg).to.be.a('object');
      };

      /**
       * ### .isNotObject(value, [message])
       *
       * Asserts that `value` is _not_ an object.
       *
       *     var selection = 'chai'
       *     assert.isObject(selection, 'tea selection is not an object');
       *     assert.isObject(null, 'null is not an object');
       *
       * @name isNotObject
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isNotObject = function (val, msg) {
        new Assertion(val, msg).to.not.be.a('object');
      };

      /**
       * ### .isArray(value, [message])
       *
       * Asserts that `value` is an array.
       *
       *     var menu = [ 'green', 'chai', 'oolong' ];
       *     assert.isArray(menu, 'what kind of tea do we want?');
       *
       * @name isArray
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isArray = function (val, msg) {
        new Assertion(val, msg).to.be.an('array');
      };

      /**
       * ### .isNotArray(value, [message])
       *
       * Asserts that `value` is _not_ an array.
       *
       *     var menu = 'green|chai|oolong';
       *     assert.isNotArray(menu, 'what kind of tea do we want?');
       *
       * @name isNotArray
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isNotArray = function (val, msg) {
        new Assertion(val, msg).to.not.be.an('array');
      };

      /**
       * ### .isString(value, [message])
       *
       * Asserts that `value` is a string.
       *
       *     var teaOrder = 'chai';
       *     assert.isString(teaOrder, 'order placed');
       *
       * @name isString
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isString = function (val, msg) {
        new Assertion(val, msg).to.be.a('string');
      };

      /**
       * ### .isNotString(value, [message])
       *
       * Asserts that `value` is _not_ a string.
       *
       *     var teaOrder = 4;
       *     assert.isNotString(teaOrder, 'order placed');
       *
       * @name isNotString
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isNotString = function (val, msg) {
        new Assertion(val, msg).to.not.be.a('string');
      };

      /**
       * ### .isNumber(value, [message])
       *
       * Asserts that `value` is a number.
       *
       *     var cups = 2;
       *     assert.isNumber(cups, 'how many cups');
       *
       * @name isNumber
       * @param {Number} value
       * @param {String} message
       * @api public
       */

      assert.isNumber = function (val, msg) {
        new Assertion(val, msg).to.be.a('number');
      };

      /**
       * ### .isNotNumber(value, [message])
       *
       * Asserts that `value` is _not_ a number.
       *
       *     var cups = '2 cups please';
       *     assert.isNotNumber(cups, 'how many cups');
       *
       * @name isNotNumber
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isNotNumber = function (val, msg) {
        new Assertion(val, msg).to.not.be.a('number');
      };

      /**
       * ### .isBoolean(value, [message])
       *
       * Asserts that `value` is a boolean.
       *
       *     var teaReady = true
       *       , teaServed = false;
       *
       *     assert.isBoolean(teaReady, 'is the tea ready');
       *     assert.isBoolean(teaServed, 'has tea been served');
       *
       * @name isBoolean
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isBoolean = function (val, msg) {
        new Assertion(val, msg).to.be.a('boolean');
      };

      /**
       * ### .isNotBoolean(value, [message])
       *
       * Asserts that `value` is _not_ a boolean.
       *
       *     var teaReady = 'yep'
       *       , teaServed = 'nope';
       *
       *     assert.isNotBoolean(teaReady, 'is the tea ready');
       *     assert.isNotBoolean(teaServed, 'has tea been served');
       *
       * @name isNotBoolean
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.isNotBoolean = function (val, msg) {
        new Assertion(val, msg).to.not.be.a('boolean');
      };

      /**
       * ### .typeOf(value, name, [message])
       *
       * Asserts that `value`'s type is `name`, as determined by
       * `Object.prototype.toString`.
       *
       *     assert.typeOf({ tea: 'chai' }, 'object', 'we have an object');
       *     assert.typeOf(['chai', 'jasmine'], 'array', 'we have an array');
       *     assert.typeOf('tea', 'string', 'we have a string');
       *     assert.typeOf(/tea/, 'regexp', 'we have a regular expression');
       *     assert.typeOf(null, 'null', 'we have a null');
       *     assert.typeOf(undefined, 'undefined', 'we have an undefined');
       *
       * @name typeOf
       * @param {Mixed} value
       * @param {String} name
       * @param {String} message
       * @api public
       */

      assert.typeOf = function (val, type, msg) {
        new Assertion(val, msg).to.be.a(type);
      };

      /**
       * ### .notTypeOf(value, name, [message])
       *
       * Asserts that `value`'s type is _not_ `name`, as determined by
       * `Object.prototype.toString`.
       *
       *     assert.notTypeOf('tea', 'number', 'strings are not numbers');
       *
       * @name notTypeOf
       * @param {Mixed} value
       * @param {String} typeof name
       * @param {String} message
       * @api public
       */

      assert.notTypeOf = function (val, type, msg) {
        new Assertion(val, msg).to.not.be.a(type);
      };

      /**
       * ### .instanceOf(object, constructor, [message])
       *
       * Asserts that `value` is an instance of `constructor`.
       *
       *     var Tea = function (name) { this.name = name; }
       *       , chai = new Tea('chai');
       *
       *     assert.instanceOf(chai, Tea, 'chai is an instance of tea');
       *
       * @name instanceOf
       * @param {Object} object
       * @param {Constructor} constructor
       * @param {String} message
       * @api public
       */

      assert.instanceOf = function (val, type, msg) {
        new Assertion(val, msg).to.be.instanceOf(type);
      };

      /**
       * ### .notInstanceOf(object, constructor, [message])
       *
       * Asserts `value` is not an instance of `constructor`.
       *
       *     var Tea = function (name) { this.name = name; }
       *       , chai = new String('chai');
       *
       *     assert.notInstanceOf(chai, Tea, 'chai is not an instance of tea');
       *
       * @name notInstanceOf
       * @param {Object} object
       * @param {Constructor} constructor
       * @param {String} message
       * @api public
       */

      assert.notInstanceOf = function (val, type, msg) {
        new Assertion(val, msg).to.not.be.instanceOf(type);
      };

      /**
       * ### .include(haystack, needle, [message])
       *
       * Asserts that `haystack` includes `needle`. Works
       * for strings and arrays.
       *
       *     assert.include('foobar', 'bar', 'foobar contains string "bar"');
       *     assert.include([ 1, 2, 3 ], 3, 'array contains value');
       *
       * @name include
       * @param {Array|String} haystack
       * @param {Mixed} needle
       * @param {String} message
       * @api public
       */

      assert.include = function (exp, inc, msg) {
        new Assertion(exp, msg).include(inc);
      };

      /**
       * ### .notInclude(haystack, needle, [message])
       *
       * Asserts that `haystack` does not include `needle`. Works
       * for strings and arrays.
       *i
       *     assert.notInclude('foobar', 'baz', 'string not include substring');
       *     assert.notInclude([ 1, 2, 3 ], 4, 'array not include contain value');
       *
       * @name notInclude
       * @param {Array|String} haystack
       * @param {Mixed} needle
       * @param {String} message
       * @api public
       */

      assert.notInclude = function (exp, inc, msg) {
        new Assertion(exp, msg).not.include(inc);
      };

      /**
       * ### .match(value, regexp, [message])
       *
       * Asserts that `value` matches the regular expression `regexp`.
       *
       *     assert.match('foobar', /^foo/, 'regexp matches');
       *
       * @name match
       * @param {Mixed} value
       * @param {RegExp} regexp
       * @param {String} message
       * @api public
       */

      assert.match = function (exp, re, msg) {
        new Assertion(exp, msg).to.match(re);
      };

      /**
       * ### .notMatch(value, regexp, [message])
       *
       * Asserts that `value` does not match the regular expression `regexp`.
       *
       *     assert.notMatch('foobar', /^foo/, 'regexp does not match');
       *
       * @name notMatch
       * @param {Mixed} value
       * @param {RegExp} regexp
       * @param {String} message
       * @api public
       */

      assert.notMatch = function (exp, re, msg) {
        new Assertion(exp, msg).to.not.match(re);
      };

      /**
       * ### .property(object, property, [message])
       *
       * Asserts that `object` has a property named by `property`.
       *
       *     assert.property({ tea: { green: 'matcha' }}, 'tea');
       *
       * @name property
       * @param {Object} object
       * @param {String} property
       * @param {String} message
       * @api public
       */

      assert.property = function (obj, prop, msg) {
        new Assertion(obj, msg).to.have.property(prop);
      };

      /**
       * ### .notProperty(object, property, [message])
       *
       * Asserts that `object` does _not_ have a property named by `property`.
       *
       *     assert.notProperty({ tea: { green: 'matcha' }}, 'coffee');
       *
       * @name notProperty
       * @param {Object} object
       * @param {String} property
       * @param {String} message
       * @api public
       */

      assert.notProperty = function (obj, prop, msg) {
        new Assertion(obj, msg).to.not.have.property(prop);
      };

      /**
       * ### .deepProperty(object, property, [message])
       *
       * Asserts that `object` has a property named by `property`, which can be a
       * string using dot- and bracket-notation for deep reference.
       *
       *     assert.deepProperty({ tea: { green: 'matcha' }}, 'tea.green');
       *
       * @name deepProperty
       * @param {Object} object
       * @param {String} property
       * @param {String} message
       * @api public
       */

      assert.deepProperty = function (obj, prop, msg) {
        new Assertion(obj, msg).to.have.deep.property(prop);
      };

      /**
       * ### .notDeepProperty(object, property, [message])
       *
       * Asserts that `object` does _not_ have a property named by `property`, which
       * can be a string using dot- and bracket-notation for deep reference.
       *
       *     assert.notDeepProperty({ tea: { green: 'matcha' }}, 'tea.oolong');
       *
       * @name notDeepProperty
       * @param {Object} object
       * @param {String} property
       * @param {String} message
       * @api public
       */

      assert.notDeepProperty = function (obj, prop, msg) {
        new Assertion(obj, msg).to.not.have.deep.property(prop);
      };

      /**
       * ### .propertyVal(object, property, value, [message])
       *
       * Asserts that `object` has a property named by `property` with value given
       * by `value`.
       *
       *     assert.propertyVal({ tea: 'is good' }, 'tea', 'is good');
       *
       * @name propertyVal
       * @param {Object} object
       * @param {String} property
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.propertyVal = function (obj, prop, val, msg) {
        new Assertion(obj, msg).to.have.property(prop, val);
      };

      /**
       * ### .propertyNotVal(object, property, value, [message])
       *
       * Asserts that `object` has a property named by `property`, but with a value
       * different from that given by `value`.
       *
       *     assert.propertyNotVal({ tea: 'is good' }, 'tea', 'is bad');
       *
       * @name propertyNotVal
       * @param {Object} object
       * @param {String} property
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.propertyNotVal = function (obj, prop, val, msg) {
        new Assertion(obj, msg).to.not.have.property(prop, val);
      };

      /**
       * ### .deepPropertyVal(object, property, value, [message])
       *
       * Asserts that `object` has a property named by `property` with value given
       * by `value`. `property` can use dot- and bracket-notation for deep
       * reference.
       *
       *     assert.deepPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'matcha');
       *
       * @name deepPropertyVal
       * @param {Object} object
       * @param {String} property
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.deepPropertyVal = function (obj, prop, val, msg) {
        new Assertion(obj, msg).to.have.deep.property(prop, val);
      };

      /**
       * ### .deepPropertyNotVal(object, property, value, [message])
       *
       * Asserts that `object` has a property named by `property`, but with a value
       * different from that given by `value`. `property` can use dot- and
       * bracket-notation for deep reference.
       *
       *     assert.deepPropertyNotVal({ tea: { green: 'matcha' }}, 'tea.green', 'konacha');
       *
       * @name deepPropertyNotVal
       * @param {Object} object
       * @param {String} property
       * @param {Mixed} value
       * @param {String} message
       * @api public
       */

      assert.deepPropertyNotVal = function (obj, prop, val, msg) {
        new Assertion(obj, msg).to.not.have.deep.property(prop, val);
      };

      /**
       * ### .lengthOf(object, length, [message])
       *
       * Asserts that `object` has a `length` property with the expected value.
       *
       *     assert.lengthOf([1,2,3], 3, 'array has length of 3');
       *     assert.lengthOf('foobar', 5, 'string has length of 6');
       *
       * @name lengthOf
       * @param {Mixed} object
       * @param {Number} length
       * @param {String} message
       * @api public
       */

      assert.lengthOf = function (exp, len, msg) {
        new Assertion(exp, msg).to.have.length(len);
      };

      /**
       * ### .throws(function, [constructor/string/regexp], [string/regexp], [message])
       *
       * Asserts that `function` will throw an error that is an instance of
       * `constructor`, or alternately that it will throw an error with message
       * matching `regexp`.
       *
       *     assert.throw(fn, 'function throws a reference error');
       *     assert.throw(fn, /function throws a reference error/);
       *     assert.throw(fn, ReferenceError);
       *     assert.throw(fn, ReferenceError, 'function throws a reference error');
       *     assert.throw(fn, ReferenceError, /function throws a reference error/);
       *
       * @name throws
       * @alias throw
       * @alias Throw
       * @param {Function} function
       * @param {ErrorConstructor} constructor
       * @param {RegExp} regexp
       * @param {String} message
       * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
       * @api public
       */

      assert.Throw = function (fn, errt, errs, msg) {
        if ('string' === typeof errt || errt instanceof RegExp) {
          errs = errt;
          errt = null;
        }

        var assertErr = new Assertion(fn, msg).to.Throw(errt, errs);
        return flag(assertErr, 'object');
      };

      /**
       * ### .doesNotThrow(function, [constructor/regexp], [message])
       *
       * Asserts that `function` will _not_ throw an error that is an instance of
       * `constructor`, or alternately that it will not throw an error with message
       * matching `regexp`.
       *
       *     assert.doesNotThrow(fn, Error, 'function does not throw');
       *
       * @name doesNotThrow
       * @param {Function} function
       * @param {ErrorConstructor} constructor
       * @param {RegExp} regexp
       * @param {String} message
       * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types
       * @api public
       */

      assert.doesNotThrow = function (fn, type, msg) {
        if ('string' === typeof type) {
          msg = type;
          type = null;
        }

        new Assertion(fn, msg).to.not.Throw(type);
      };

      /**
       * ### .operator(val1, operator, val2, [message])
       *
       * Compares two values using `operator`.
       *
       *     assert.operator(1, '<', 2, 'everything is ok');
       *     assert.operator(1, '>', 2, 'this will fail');
       *
       * @name operator
       * @param {Mixed} val1
       * @param {String} operator
       * @param {Mixed} val2
       * @param {String} message
       * @api public
       */

      assert.operator = function (val, operator, val2, msg) {
        if (!~['==', '===', '>', '>=', '<', '<=', '!=', '!=='].indexOf(operator)) {
          throw new Error('Invalid operator "' + operator + '"');
        }
        var test = new Assertion(eval(val + operator + val2), msg);
        test.assert(
            true === flag(test, 'object')
            , 'expected ' + util.inspect(val) + ' to be ' + operator + ' ' + util.inspect(val2)
            , 'expected ' + util.inspect(val) + ' to not be ' + operator + ' ' + util.inspect(val2) );
      };

      /**
       * ### .closeTo(actual, expected, delta, [message])
       *
       * Asserts that the target is equal `expected`, to within a +/- `delta` range.
       *
       *     assert.closeTo(1.5, 1, 0.5, 'numbers are close');
       *
       * @name closeTo
       * @param {Number} actual
       * @param {Number} expected
       * @param {Number} delta
       * @param {String} message
       * @api public
       */

      assert.closeTo = function (act, exp, delta, msg) {
        new Assertion(act, msg).to.be.closeTo(exp, delta);
      };

      /**
       * ### .sameMembers(set1, set2, [message])
       *
       * Asserts that `set1` and `set2` have the same members.
       * Order is not taken into account.
       *
       *     assert.sameMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'same members');
       *
       * @name sameMembers
       * @param {Array} superset
       * @param {Array} subset
       * @param {String} message
       * @api public
       */

      assert.sameMembers = function (set1, set2, msg) {
        new Assertion(set1, msg).to.have.same.members(set2);
      }

      /**
       * ### .includeMembers(superset, subset, [message])
       *
       * Asserts that `subset` is included in `superset`.
       * Order is not taken into account.
       *
       *     assert.includeMembers([ 1, 2, 3 ], [ 2, 1 ], 'include members');
       *
       * @name includeMembers
       * @param {Array} superset
       * @param {Array} subset
       * @param {String} message
       * @api public
       */

      assert.includeMembers = function (superset, subset, msg) {
        new Assertion(superset, msg).to.include.members(subset);
      }

      /*!
       * Undocumented / untested
       */

      assert.ifError = function (val, msg) {
        new Assertion(val, msg).to.not.be.ok;
      };

      /*!
       * Aliases.
       */

      (function alias(name, as){
        assert[as] = assert[name];
        return alias;
      })
          ('Throw', 'throw')
          ('Throw', 'throws');
    };

  });
  require.register("chai/lib/chai/interface/expect.js", function(exports, require, module){
    /*!
     * chai
     * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    module.exports = function (chai, util) {
      chai.expect = function (val, message) {
        return new chai.Assertion(val, message);
      };
    };


  });
  require.register("chai/lib/chai/interface/should.js", function(exports, require, module){
    /*!
     * chai
     * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    module.exports = function (chai, util) {
      var Assertion = chai.Assertion;

      function loadShould () {
        // modify Object.prototype to have `should`
        Object.defineProperty(Object.prototype, 'should',
            {
              set: function (value) {
                // See https://github.com/chaijs/chai/issues/86: this makes
                // `whatever.should = someValue` actually set `someValue`, which is
                // especially useful for `global.should = require('chai').should()`.
                //
                // Note that we have to use [[DefineProperty]] instead of [[Put]]
                // since otherwise we would trigger this very setter!
                Object.defineProperty(this, 'should', {
                  value: value,
                  enumerable: true,
                  configurable: true,
                  writable: true
                });
              }
              , get: function(){
              if (this instanceof String || this instanceof Number) {
                return new Assertion(this.constructor(this));
              } else if (this instanceof Boolean) {
                return new Assertion(this == true);
              }
              return new Assertion(this);
            }
              , configurable: true
            });

        var should = {};

        should.equal = function (val1, val2, msg) {
          new Assertion(val1, msg).to.equal(val2);
        };

        should.Throw = function (fn, errt, errs, msg) {
          new Assertion(fn, msg).to.Throw(errt, errs);
        };

        should.exist = function (val, msg) {
          new Assertion(val, msg).to.exist;
        }

        // negation
        should.not = {}

        should.not.equal = function (val1, val2, msg) {
          new Assertion(val1, msg).to.not.equal(val2);
        };

        should.not.Throw = function (fn, errt, errs, msg) {
          new Assertion(fn, msg).to.not.Throw(errt, errs);
        };

        should.not.exist = function (val, msg) {
          new Assertion(val, msg).to.not.exist;
        }

        should['throw'] = should['Throw'];
        should.not['throw'] = should.not['Throw'];

        return should;
      };

      chai.should = loadShould;
      chai.Should = loadShould;
    };

  });
  require.register("chai/lib/chai/utils/addChainableMethod.js", function(exports, require, module){
    /*!
     * Chai - addChainingMethod utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /*!
     * Module dependencies
     */

    var transferFlags = require('./transferFlags');

    /*!
     * Module variables
     */

// Check whether `__proto__` is supported
    var hasProtoSupport = '__proto__' in Object;

// Without `__proto__` support, this module will need to add properties to a function.
// However, some Function.prototype methods cannot be overwritten,
// and there seems no easy cross-platform way to detect them (@see chaijs/chai/issues/69).
    var excludeNames = /^(?:length|name|arguments|caller)$/;

// Cache `Function` properties
    var call  = Function.prototype.call,
        apply = Function.prototype.apply;

    /**
     * ### addChainableMethod (ctx, name, method, chainingBehavior)
     *
     * Adds a method to an object, such that the method can also be chained.
     *
     *     utils.addChainableMethod(chai.Assertion.prototype, 'foo', function (str) {
 *       var obj = utils.flag(this, 'object');
 *       new chai.Assertion(obj).to.be.equal(str);
 *     });
     *
     * Can also be accessed directly from `chai.Assertion`.
     *
     *     chai.Assertion.addChainableMethod('foo', fn, chainingBehavior);
     *
     * The result can then be used as both a method assertion, executing both `method` and
     * `chainingBehavior`, or as a language chain, which only executes `chainingBehavior`.
     *
     *     expect(fooStr).to.be.foo('bar');
     *     expect(fooStr).to.be.foo.equal('foo');
     *
     * @param {Object} ctx object to which the method is added
     * @param {String} name of method to add
     * @param {Function} method function to be used for `name`, when called
     * @param {Function} chainingBehavior function to be called every time the property is accessed
     * @name addChainableMethod
     * @api public
     */

    module.exports = function (ctx, name, method, chainingBehavior) {
      if (typeof chainingBehavior !== 'function') {
        chainingBehavior = function () { };
      }

      var chainableBehavior = {
        method: method
        , chainingBehavior: chainingBehavior
      };

      // save the methods so we can overwrite them later, if we need to.
      if (!ctx.__methods) {
        ctx.__methods = {};
      }
      ctx.__methods[name] = chainableBehavior;

      Object.defineProperty(ctx, name,
          { get: function () {
            chainableBehavior.chainingBehavior.call(this);

            var assert = function () {
              var result = chainableBehavior.method.apply(this, arguments);
              return result === undefined ? this : result;
            };

            // Use `__proto__` if available
            if (hasProtoSupport) {
              // Inherit all properties from the object by replacing the `Function` prototype
              var prototype = assert.__proto__ = Object.create(this);
              // Restore the `call` and `apply` methods from `Function`
              prototype.call = call;
              prototype.apply = apply;
            }
            // Otherwise, redefine all properties (slow!)
            else {
              var asserterNames = Object.getOwnPropertyNames(ctx);
              asserterNames.forEach(function (asserterName) {
                if (!excludeNames.test(asserterName)) {
                  var pd = Object.getOwnPropertyDescriptor(ctx, asserterName);
                  Object.defineProperty(assert, asserterName, pd);
                }
              });
            }

            transferFlags(this, assert);
            return assert;
          }
            , configurable: true
          });
    };

  });
  require.register("chai/lib/chai/utils/addMethod.js", function(exports, require, module){
    /*!
     * Chai - addMethod utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /**
     * ### .addMethod (ctx, name, method)
     *
     * Adds a method to the prototype of an object.
     *
     *     utils.addMethod(chai.Assertion.prototype, 'foo', function (str) {
 *       var obj = utils.flag(this, 'object');
 *       new chai.Assertion(obj).to.be.equal(str);
 *     });
     *
     * Can also be accessed directly from `chai.Assertion`.
     *
     *     chai.Assertion.addMethod('foo', fn);
     *
     * Then can be used as any other assertion.
     *
     *     expect(fooStr).to.be.foo('bar');
     *
     * @param {Object} ctx object to which the method is added
     * @param {String} name of method to add
     * @param {Function} method function to be used for name
     * @name addMethod
     * @api public
     */

    module.exports = function (ctx, name, method) {
      ctx[name] = function () {
        var result = method.apply(this, arguments);
        return result === undefined ? this : result;
      };
    };

  });
  require.register("chai/lib/chai/utils/addProperty.js", function(exports, require, module){
    /*!
     * Chai - addProperty utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /**
     * ### addProperty (ctx, name, getter)
     *
     * Adds a property to the prototype of an object.
     *
     *     utils.addProperty(chai.Assertion.prototype, 'foo', function () {
 *       var obj = utils.flag(this, 'object');
 *       new chai.Assertion(obj).to.be.instanceof(Foo);
 *     });
     *
     * Can also be accessed directly from `chai.Assertion`.
     *
     *     chai.Assertion.addProperty('foo', fn);
     *
     * Then can be used as any other assertion.
     *
     *     expect(myFoo).to.be.foo;
     *
     * @param {Object} ctx object to which the property is added
     * @param {String} name of property to add
     * @param {Function} getter function to be used for name
     * @name addProperty
     * @api public
     */

    module.exports = function (ctx, name, getter) {
      Object.defineProperty(ctx, name,
          { get: function () {
            var result = getter.call(this);
            return result === undefined ? this : result;
          }
            , configurable: true
          });
    };

  });
  require.register("chai/lib/chai/utils/flag.js", function(exports, require, module){
    /*!
     * Chai - flag utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /**
     * ### flag(object ,key, [value])
     *
     * Get or set a flag value on an object. If a
     * value is provided it will be set, else it will
     * return the currently set value or `undefined` if
     * the value is not set.
     *
     *     utils.flag(this, 'foo', 'bar'); // setter
     *     utils.flag(this, 'foo'); // getter, returns `bar`
     *
     * @param {Object} object (constructed Assertion
     * @param {String} key
     * @param {Mixed} value (optional)
     * @name flag
     * @api private
     */

    module.exports = function (obj, key, value) {
      var flags = obj.__flags || (obj.__flags = Object.create(null));
      if (arguments.length === 3) {
        flags[key] = value;
      } else {
        return flags[key];
      }
    };

  });
  require.register("chai/lib/chai/utils/getActual.js", function(exports, require, module){
    /*!
     * Chai - getActual utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /**
     * # getActual(object, [actual])
     *
     * Returns the `actual` value for an Assertion
     *
     * @param {Object} object (constructed Assertion)
     * @param {Arguments} chai.Assertion.prototype.assert arguments
     */

    module.exports = function (obj, args) {
      var actual = args[4];
      return 'undefined' !== typeof actual ? actual : obj._obj;
    };

  });
  require.register("chai/lib/chai/utils/getEnumerableProperties.js", function(exports, require, module){
    /*!
     * Chai - getEnumerableProperties utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /**
     * ### .getEnumerableProperties(object)
     *
     * This allows the retrieval of enumerable property names of an object,
     * inherited or not.
     *
     * @param {Object} object
     * @returns {Array}
     * @name getEnumerableProperties
     * @api public
     */

    module.exports = function getEnumerableProperties(object) {
      var result = [];
      for (var name in object) {
        result.push(name);
      }
      return result;
    };

  });
  require.register("chai/lib/chai/utils/getMessage.js", function(exports, require, module){
    /*!
     * Chai - message composition utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /*!
     * Module dependancies
     */

    var flag = require('./flag')
        , getActual = require('./getActual')
        , inspect = require('./inspect')
        , objDisplay = require('./objDisplay');

    /**
     * ### .getMessage(object, message, negateMessage)
     *
     * Construct the error message based on flags
     * and template tags. Template tags will return
     * a stringified inspection of the object referenced.
     *
     * Message template tags:
     * - `#{this}` current asserted object
     * - `#{act}` actual value
     * - `#{exp}` expected value
     *
     * @param {Object} object (constructed Assertion)
     * @param {Arguments} chai.Assertion.prototype.assert arguments
     * @name getMessage
     * @api public
     */

    module.exports = function (obj, args) {
      var negate = flag(obj, 'negate')
          , val = flag(obj, 'object')
          , expected = args[3]
          , actual = getActual(obj, args)
          , msg = negate ? args[2] : args[1]
          , flagMsg = flag(obj, 'message');

      msg = msg || '';
      msg = msg
          .replace(/#{this}/g, objDisplay(val))
          .replace(/#{act}/g, objDisplay(actual))
          .replace(/#{exp}/g, objDisplay(expected));

      return flagMsg ? flagMsg + ': ' + msg : msg;
    };

  });
  require.register("chai/lib/chai/utils/getName.js", function(exports, require, module){
    /*!
     * Chai - getName utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /**
     * # getName(func)
     *
     * Gets the name of a function, in a cross-browser way.
     *
     * @param {Function} a function (usually a constructor)
     */

    module.exports = function (func) {
      if (func.name) return func.name;

      var match = /^\s?function ([^(]*)\(/.exec(func);
      return match && match[1] ? match[1] : "";
    };

  });
  require.register("chai/lib/chai/utils/getPathValue.js", function(exports, require, module){
    /*!
     * Chai - getPathValue utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * @see https://github.com/logicalparadox/filtr
     * MIT Licensed
     */

    /**
     * ### .getPathValue(path, object)
     *
     * This allows the retrieval of values in an
     * object given a string path.
     *
     *     var obj = {
 *         prop1: {
 *             arr: ['a', 'b', 'c']
 *           , str: 'Hello'
 *         }
 *       , prop2: {
 *             arr: [ { nested: 'Universe' } ]
 *           , str: 'Hello again!'
 *         }
 *     }
     *
     * The following would be the results.
     *
     *     getPathValue('prop1.str', obj); // Hello
     *     getPathValue('prop1.att[2]', obj); // b
     *     getPathValue('prop2.arr[0].nested', obj); // Universe
     *
     * @param {String} path
     * @param {Object} object
     * @returns {Object} value or `undefined`
     * @name getPathValue
     * @api public
     */

    var getPathValue = module.exports = function (path, obj) {
      var parsed = parsePath(path);
      return _getPathValue(parsed, obj);
    };

    /*!
     * ## parsePath(path)
     *
     * Helper function used to parse string object
     * paths. Use in conjunction with `_getPathValue`.
     *
     *      var parsed = parsePath('myobject.property.subprop');
     *
     * ### Paths:
     *
     * * Can be as near infinitely deep and nested
     * * Arrays are also valid using the formal `myobject.document[3].property`.
     *
     * @param {String} path
     * @returns {Object} parsed
     * @api private
     */

    function parsePath (path) {
      var str = path.replace(/\[/g, '.[')
          , parts = str.match(/(\\\.|[^.]+?)+/g);
      return parts.map(function (value) {
        var re = /\[(\d+)\]$/
            , mArr = re.exec(value)
        if (mArr) return { i: parseFloat(mArr[1]) };
        else return { p: value };
      });
    };

    /*!
     * ## _getPathValue(parsed, obj)
     *
     * Helper companion function for `.parsePath` that returns
     * the value located at the parsed address.
     *
     *      var value = getPathValue(parsed, obj);
     *
     * @param {Object} parsed definition from `parsePath`.
     * @param {Object} object to search against
     * @returns {Object|Undefined} value
     * @api private
     */

    function _getPathValue (parsed, obj) {
      var tmp = obj
          , res;
      for (var i = 0, l = parsed.length; i < l; i++) {
        var part = parsed[i];
        if (tmp) {
          if ('undefined' !== typeof part.p)
            tmp = tmp[part.p];
          else if ('undefined' !== typeof part.i)
            tmp = tmp[part.i];
          if (i == (l - 1)) res = tmp;
        } else {
          res = undefined;
        }
      }
      return res;
    };

  });
  require.register("chai/lib/chai/utils/getProperties.js", function(exports, require, module){
    /*!
     * Chai - getProperties utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /**
     * ### .getProperties(object)
     *
     * This allows the retrieval of property names of an object, enumerable or not,
     * inherited or not.
     *
     * @param {Object} object
     * @returns {Array}
     * @name getProperties
     * @api public
     */

    module.exports = function getProperties(object) {
      var result = Object.getOwnPropertyNames(subject);

      function addProperty(property) {
        if (result.indexOf(property) === -1) {
          result.push(property);
        }
      }

      var proto = Object.getPrototypeOf(subject);
      while (proto !== null) {
        Object.getOwnPropertyNames(proto).forEach(addProperty);
        proto = Object.getPrototypeOf(proto);
      }

      return result;
    };

  });
  require.register("chai/lib/chai/utils/index.js", function(exports, require, module){
    /*!
     * chai
     * Copyright(c) 2011 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /*!
     * Main exports
     */

    var exports = module.exports = {};

    /*!
     * test utility
     */

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

    /*!
     * type utility
     */

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

    /*!
     * message utility
     */

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

    /*!
     * actual utility
     */

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

    /*!
     * Inspect util
     */

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

    /*!
     * Object Display util
     */

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

    /*!
     * Flag utility
     */

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

    /*!
     * Flag transferring utility
     */

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

    /*!
     * Deep equal utility
     */

    exports.eql = require('deep-eql');

    /*!
     * Deep path value
     */

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

    /*!
     * Function name
     */

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

    /*!
     * add Property
     */

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

    /*!
     * add Method
     */

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

    /*!
     * overwrite Property
     */

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

    /*!
     * overwrite Method
     */

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

    /*!
     * Add a chainable method
     */

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

    /*!
     * Overwrite chainable method
     */

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


  });
  require.register("chai/lib/chai/utils/inspect.js", function(exports, require, module){
// This is (almost) directly from Node.js utils
// https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/util.js

    var getName = require('./getName');
    var getProperties = require('./getProperties');
    var getEnumerableProperties = require('./getEnumerableProperties');

    module.exports = inspect;

    /**
     * Echos the value of a value. Trys to print the value out
     * in the best way possible given the different types.
     *
     * @param {Object} obj The object to print out.
     * @param {Boolean} showHidden Flag that shows hidden (not enumerable)
     *    properties of objects.
     * @param {Number} depth Depth in which to descend in object. Default is 2.
     * @param {Boolean} colors Flag to turn on ANSI escape codes to color the
     *    output. Default is false (no coloring).
     */
    function inspect(obj, showHidden, depth, colors) {
      var ctx = {
        showHidden: showHidden,
        seen: [],
        stylize: function (str) { return str; }
      };
      return formatValue(ctx, obj, (typeof depth === 'undefined' ? 2 : depth));
    }

// https://gist.github.com/1044128/
    var getOuterHTML = function(element) {
      if ('outerHTML' in element) return element.outerHTML;
      var ns = "http://www.w3.org/1999/xhtml";
      var container = document.createElementNS(ns, '_');
      var elemProto = (window.HTMLElement || window.Element).prototype;
      var xmlSerializer = new XMLSerializer();
      var html;
      if (document.xmlVersion) {
        return xmlSerializer.serializeToString(element);
      } else {
        container.appendChild(element.cloneNode(false));
        html = container.innerHTML.replace('><', '>' + element.innerHTML + '<');
        container.innerHTML = '';
        return html;
      }
    };

// Returns true if object is a DOM element.
    var isDOMElement = function (object) {
      if (typeof HTMLElement === 'object') {
        return object instanceof HTMLElement;
      } else {
        return object &&
            typeof object === 'object' &&
            object.nodeType === 1 &&
            typeof object.nodeName === 'string';
      }
    };

    function formatValue(ctx, value, recurseTimes) {
      // Provide a hook for user-specified inspect functions.
      // Check that value is an object with an inspect function on it
      if (value && typeof value.inspect === 'function' &&
        // Filter out the util module, it's inspect function is special
          value.inspect !== exports.inspect &&
        // Also filter out any prototype objects using the circular check.
          !(value.constructor && value.constructor.prototype === value)) {
        var ret = value.inspect(recurseTimes);
        if (typeof ret !== 'string') {
          ret = formatValue(ctx, ret, recurseTimes);
        }
        return ret;
      }

      // Primitive types cannot have properties
      var primitive = formatPrimitive(ctx, value);
      if (primitive) {
        return primitive;
      }

      // If it's DOM elem, get outer HTML.
      if (isDOMElement(value)) {
        return getOuterHTML(value);
      }

      // Look up the keys of the object.
      var visibleKeys = getEnumerableProperties(value);
      var keys = ctx.showHidden ? getProperties(value) : visibleKeys;

      // Some type of object without properties can be shortcutted.
      // In IE, errors have a single `stack` property, or if they are vanilla `Error`,
      // a `stack` plus `description` property; ignore those for consistency.
      if (keys.length === 0 || (isError(value) && (
          (keys.length === 1 && keys[0] === 'stack') ||
              (keys.length === 2 && keys[0] === 'description' && keys[1] === 'stack')
          ))) {
        if (typeof value === 'function') {
          var name = getName(value);
          var nameSuffix = name ? ': ' + name : '';
          return ctx.stylize('[Function' + nameSuffix + ']', 'special');
        }
        if (isRegExp(value)) {
          return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
        }
        if (isDate(value)) {
          return ctx.stylize(Date.prototype.toUTCString.call(value), 'date');
        }
        if (isError(value)) {
          return formatError(value);
        }
      }

      var base = '', array = false, braces = ['{', '}'];

      // Make Array say that they are Array
      if (isArray(value)) {
        array = true;
        braces = ['[', ']'];
      }

      // Make functions say that they are functions
      if (typeof value === 'function') {
        var name = getName(value);
        var nameSuffix = name ? ': ' + name : '';
        base = ' [Function' + nameSuffix + ']';
      }

      // Make RegExps say that they are RegExps
      if (isRegExp(value)) {
        base = ' ' + RegExp.prototype.toString.call(value);
      }

      // Make dates with properties first say the date
      if (isDate(value)) {
        base = ' ' + Date.prototype.toUTCString.call(value);
      }

      // Make error with message first say the error
      if (isError(value)) {
        return formatError(value);
      }

      if (keys.length === 0 && (!array || value.length == 0)) {
        return braces[0] + base + braces[1];
      }

      if (recurseTimes < 0) {
        if (isRegExp(value)) {
          return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
        } else {
          return ctx.stylize('[Object]', 'special');
        }
      }

      ctx.seen.push(value);

      var output;
      if (array) {
        output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
      } else {
        output = keys.map(function(key) {
          return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
        });
      }

      ctx.seen.pop();

      return reduceToSingleString(output, base, braces);
    }


    function formatPrimitive(ctx, value) {
      switch (typeof value) {
        case 'undefined':
          return ctx.stylize('undefined', 'undefined');

        case 'string':
          var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
              .replace(/'/g, "\\'")
              .replace(/\\"/g, '"') + '\'';
          return ctx.stylize(simple, 'string');

        case 'number':
          return ctx.stylize('' + value, 'number');

        case 'boolean':
          return ctx.stylize('' + value, 'boolean');
      }
      // For some reason typeof null is "object", so special case here.
      if (value === null) {
        return ctx.stylize('null', 'null');
      }
    }


    function formatError(value) {
      return '[' + Error.prototype.toString.call(value) + ']';
    }


    function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
      var output = [];
      for (var i = 0, l = value.length; i < l; ++i) {
        if (Object.prototype.hasOwnProperty.call(value, String(i))) {
          output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
              String(i), true));
        } else {
          output.push('');
        }
      }
      keys.forEach(function(key) {
        if (!key.match(/^\d+$/)) {
          output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
              key, true));
        }
      });
      return output;
    }


    function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
      var name, str;
      if (value.__lookupGetter__) {
        if (value.__lookupGetter__(key)) {
          if (value.__lookupSetter__(key)) {
            str = ctx.stylize('[Getter/Setter]', 'special');
          } else {
            str = ctx.stylize('[Getter]', 'special');
          }
        } else {
          if (value.__lookupSetter__(key)) {
            str = ctx.stylize('[Setter]', 'special');
          }
        }
      }
      if (visibleKeys.indexOf(key) < 0) {
        name = '[' + key + ']';
      }
      if (!str) {
        if (ctx.seen.indexOf(value[key]) < 0) {
          if (recurseTimes === null) {
            str = formatValue(ctx, value[key], null);
          } else {
            str = formatValue(ctx, value[key], recurseTimes - 1);
          }
          if (str.indexOf('\n') > -1) {
            if (array) {
              str = str.split('\n').map(function(line) {
                return '  ' + line;
              }).join('\n').substr(2);
            } else {
              str = '\n' + str.split('\n').map(function(line) {
                return '   ' + line;
              }).join('\n');
            }
          }
        } else {
          str = ctx.stylize('[Circular]', 'special');
        }
      }
      if (typeof name === 'undefined') {
        if (array && key.match(/^\d+$/)) {
          return str;
        }
        name = JSON.stringify('' + key);
        if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
          name = name.substr(1, name.length - 2);
          name = ctx.stylize(name, 'name');
        } else {
          name = name.replace(/'/g, "\\'")
              .replace(/\\"/g, '"')
              .replace(/(^"|"$)/g, "'");
          name = ctx.stylize(name, 'string');
        }
      }

      return name + ': ' + str;
    }


    function reduceToSingleString(output, base, braces) {
      var numLinesEst = 0;
      var length = output.reduce(function(prev, cur) {
        numLinesEst++;
        if (cur.indexOf('\n') >= 0) numLinesEst++;
        return prev + cur.length + 1;
      }, 0);

      if (length > 60) {
        return braces[0] +
            (base === '' ? '' : base + '\n ') +
            ' ' +
            output.join(',\n  ') +
            ' ' +
            braces[1];
      }

      return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
    }

    function isArray(ar) {
      return Array.isArray(ar) ||
          (typeof ar === 'object' && objectToString(ar) === '[object Array]');
    }

    function isRegExp(re) {
      return typeof re === 'object' && objectToString(re) === '[object RegExp]';
    }

    function isDate(d) {
      return typeof d === 'object' && objectToString(d) === '[object Date]';
    }

    function isError(e) {
      return typeof e === 'object' && objectToString(e) === '[object Error]';
    }

    function objectToString(o) {
      return Object.prototype.toString.call(o);
    }

  });
  require.register("chai/lib/chai/utils/objDisplay.js", function(exports, require, module){
    /*!
     * Chai - flag utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /*!
     * Module dependancies
     */

    var inspect = require('./inspect');

    /**
     * ### .objDisplay (object)
     *
     * Determines if an object or an array matches
     * criteria to be inspected in-line for error
     * messages or should be truncated.
     *
     * @param {Mixed} javascript object to inspect
     * @name objDisplay
     * @api public
     */

    module.exports = function (obj) {
      var str = inspect(obj)
          , type = Object.prototype.toString.call(obj);

      if (str.length >= 40) {
        if (type === '[object Function]') {
          return !obj.name || obj.name === ''
              ? '[Function]'
              : '[Function: ' + obj.name + ']';
        } else if (type === '[object Array]') {
          return '[ Array(' + obj.length + ') ]';
        } else if (type === '[object Object]') {
          var keys = Object.keys(obj)
              , kstr = keys.length > 2
                  ? keys.splice(0, 2).join(', ') + ', ...'
                  : keys.join(', ');
          return '{ Object (' + kstr + ') }';
        } else {
          return str;
        }
      } else {
        return str;
      }
    };

  });
  require.register("chai/lib/chai/utils/overwriteMethod.js", function(exports, require, module){
    /*!
     * Chai - overwriteMethod utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /**
     * ### overwriteMethod (ctx, name, fn)
     *
     * Overwites an already existing method and provides
     * access to previous function. Must return function
     * to be used for name.
     *
     *     utils.overwriteMethod(chai.Assertion.prototype, 'equal', function (_super) {
 *       return function (str) {
 *         var obj = utils.flag(this, 'object');
 *         if (obj instanceof Foo) {
 *           new chai.Assertion(obj.value).to.equal(str);
 *         } else {
 *           _super.apply(this, arguments);
 *         }
 *       }
 *     });
     *
     * Can also be accessed directly from `chai.Assertion`.
     *
     *     chai.Assertion.overwriteMethod('foo', fn);
     *
     * Then can be used as any other assertion.
     *
     *     expect(myFoo).to.equal('bar');
     *
     * @param {Object} ctx object whose method is to be overwritten
     * @param {String} name of method to overwrite
     * @param {Function} method function that returns a function to be used for name
     * @name overwriteMethod
     * @api public
     */

    module.exports = function (ctx, name, method) {
      var _method = ctx[name]
          , _super = function () { return this; };

      if (_method && 'function' === typeof _method)
        _super = _method;

      ctx[name] = function () {
        var result = method(_super).apply(this, arguments);
        return result === undefined ? this : result;
      }
    };

  });
  require.register("chai/lib/chai/utils/overwriteProperty.js", function(exports, require, module){
    /*!
     * Chai - overwriteProperty utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /**
     * ### overwriteProperty (ctx, name, fn)
     *
     * Overwites an already existing property getter and provides
     * access to previous value. Must return function to use as getter.
     *
     *     utils.overwriteProperty(chai.Assertion.prototype, 'ok', function (_super) {
 *       return function () {
 *         var obj = utils.flag(this, 'object');
 *         if (obj instanceof Foo) {
 *           new chai.Assertion(obj.name).to.equal('bar');
 *         } else {
 *           _super.call(this);
 *         }
 *       }
 *     });
     *
     *
     * Can also be accessed directly from `chai.Assertion`.
     *
     *     chai.Assertion.overwriteProperty('foo', fn);
     *
     * Then can be used as any other assertion.
     *
     *     expect(myFoo).to.be.ok;
     *
     * @param {Object} ctx object whose property is to be overwritten
     * @param {String} name of property to overwrite
     * @param {Function} getter function that returns a getter function to be used for name
     * @name overwriteProperty
     * @api public
     */

    module.exports = function (ctx, name, getter) {
      var _get = Object.getOwnPropertyDescriptor(ctx, name)
          , _super = function () {};

      if (_get && 'function' === typeof _get.get)
        _super = _get.get

      Object.defineProperty(ctx, name,
          { get: function () {
            var result = getter(_super).call(this);
            return result === undefined ? this : result;
          }
            , configurable: true
          });
    };

  });
  require.register("chai/lib/chai/utils/overwriteChainableMethod.js", function(exports, require, module){
    /*!
     * Chai - overwriteChainableMethod utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /**
     * ### overwriteChainableMethod (ctx, name, fn)
     *
     * Overwites an already existing chainable method
     * and provides access to the previous function or
     * property.  Must return functions to be used for
     * name.
     *
     *     utils.overwriteChainableMethod(chai.Assertion.prototype, 'length',
     *       function (_super) {
 *       }
     *     , function (_super) {
 *       }
     *     );
     *
     * Can also be accessed directly from `chai.Assertion`.
     *
     *     chai.Assertion.overwriteChainableMethod('foo', fn, fn);
     *
     * Then can be used as any other assertion.
     *
     *     expect(myFoo).to.have.length(3);
     *     expect(myFoo).to.have.length.above(3);
     *
     * @param {Object} ctx object whose method / property is to be overwritten
     * @param {String} name of method / property to overwrite
     * @param {Function} method function that returns a function to be used for name
     * @param {Function} chainingBehavior function that returns a function to be used for property
     * @name overwriteChainableMethod
     * @api public
     */

    module.exports = function (ctx, name, method, chainingBehavior) {
      var chainableBehavior = ctx.__methods[name];

      var _chainingBehavior = chainableBehavior.chainingBehavior;
      chainableBehavior.chainingBehavior = function () {
        var result = chainingBehavior(_chainingBehavior).call(this);
        return result === undefined ? this : result;
      };

      var _method = chainableBehavior.method;
      chainableBehavior.method = function () {
        var result = method(_method).apply(this, arguments);
        return result === undefined ? this : result;
      };
    };

  });
  require.register("chai/lib/chai/utils/test.js", function(exports, require, module){
    /*!
     * Chai - test utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /*!
     * Module dependancies
     */

    var flag = require('./flag');

    /**
     * # test(object, expression)
     *
     * Test and object for expression.
     *
     * @param {Object} object (constructed Assertion)
     * @param {Arguments} chai.Assertion.prototype.assert arguments
     */

    module.exports = function (obj, args) {
      var negate = flag(obj, 'negate')
          , expr = args[0];
      return negate ? !expr : expr;
    };

  });
  require.register("chai/lib/chai/utils/transferFlags.js", function(exports, require, module){
    /*!
     * Chai - transferFlags utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /**
     * ### transferFlags(assertion, object, includeAll = true)
     *
     * Transfer all the flags for `assertion` to `object`. If
     * `includeAll` is set to `false`, then the base Chai
     * assertion flags (namely `object`, `ssfi`, and `message`)
     * will not be transferred.
     *
     *
     *     var newAssertion = new Assertion();
     *     utils.transferFlags(assertion, newAssertion);
     *
     *     var anotherAsseriton = new Assertion(myObj);
     *     utils.transferFlags(assertion, anotherAssertion, false);
     *
     * @param {Assertion} assertion the assertion to transfer the flags from
     * @param {Object} object the object to transfer the flags too; usually a new assertion
     * @param {Boolean} includeAll
     * @name getAllFlags
     * @api private
     */

    module.exports = function (assertion, object, includeAll) {
      var flags = assertion.__flags || (assertion.__flags = Object.create(null));

      if (!object.__flags) {
        object.__flags = Object.create(null);
      }

      includeAll = arguments.length === 3 ? includeAll : true;

      for (var flag in flags) {
        if (includeAll ||
            (flag !== 'object' && flag !== 'ssfi' && flag != 'message')) {
          object.__flags[flag] = flags[flag];
        }
      }
    };

  });
  require.register("chai/lib/chai/utils/type.js", function(exports, require, module){
    /*!
     * Chai - type utility
     * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
     * MIT Licensed
     */

    /*!
     * Detectable javascript natives
     */

    var natives = {
      '[object Arguments]': 'arguments'
      , '[object Array]': 'array'
      , '[object Date]': 'date'
      , '[object Function]': 'function'
      , '[object Number]': 'number'
      , '[object RegExp]': 'regexp'
      , '[object String]': 'string'
    };

    /**
     * ### type(object)
     *
     * Better implementation of `typeof` detection that can
     * be used cross-browser. Handles the inconsistencies of
     * Array, `null`, and `undefined` detection.
     *
     *     utils.type({}) // 'object'
     *     utils.type(null) // `null'
     *     utils.type(undefined) // `undefined`
     *     utils.type([]) // `array`
     *
     * @param {Mixed} object to detect type of
     * @name type
     * @api private
     */

    module.exports = function (obj) {
      var str = Object.prototype.toString.call(obj);
      if (natives[str]) return natives[str];
      if (obj === null) return 'null';
      if (obj === undefined) return 'undefined';
      if (obj === Object(obj)) return 'object';
      return typeof obj;
    };

  });


  require.alias("chaijs-assertion-error/index.js", "chai/deps/assertion-error/index.js");
  require.alias("chaijs-assertion-error/index.js", "chai/deps/assertion-error/index.js");
  require.alias("chaijs-assertion-error/index.js", "assertion-error/index.js");
  require.alias("chaijs-assertion-error/index.js", "chaijs-assertion-error/index.js");
  require.alias("chaijs-deep-eql/lib/eql.js", "chai/deps/deep-eql/lib/eql.js");
  require.alias("chaijs-deep-eql/lib/eql.js", "chai/deps/deep-eql/index.js");
  require.alias("chaijs-deep-eql/lib/eql.js", "deep-eql/index.js");
  require.alias("chaijs-type-detect/lib/type.js", "chaijs-deep-eql/deps/type-detect/lib/type.js");
  require.alias("chaijs-type-detect/lib/type.js", "chaijs-deep-eql/deps/type-detect/index.js");
  require.alias("chaijs-type-detect/lib/type.js", "chaijs-type-detect/index.js");
  require.alias("chaijs-deep-eql/lib/eql.js", "chaijs-deep-eql/index.js");
  require.alias("chai/index.js", "chai/index.js");if (typeof exports == "object") {
    module.exports = require("chai");
  } else if (typeof define == "function" && define.amd) {
    define([], function(){ return require("chai"); });
  } else {
    this["chai"] = require("chai");
  }})();
(function(plugin){
  if (
    typeof require === "function"
    && typeof exports === "object"
    && typeof module === "object"
  ) {
    // NodeJS
    module.exports = plugin;
  } else if (
    typeof define === "function"
    && define.amd
  ) {
    // AMD
    define(function () {
      return plugin;
    });
  } else {
    // Other environment (usually <script> tag): plug in to global chai instance directly.
    chai.use(plugin);
  }
}(function(chai, utils){
  var _;

  if (
    typeof window === "object"
    && typeof window._ == "function"
  ) {
    // browser-side
    _ = window._;
  } else {
    // server-side
    _ = require('underscore');
  }

  // contain => _.where, check _.isEqual
  // containOnce => contain, check size of returned array
  // like => _.isEqual

  chai.Assertion.addMethod('like', function(expected){
    var obj = this._obj
    this.assert(
      _.isEqual(obj, expected)
      , "expected #{this} to be like #{exp}"
      , "expected #{this} not to be like #{exp}"
      , expected
      , obj
      , true
    )
  });

  chai.Assertion.addMethod('jsonOf', function(expected){
    var obj            = this._obj;
    var expectedAsJSON = JSON.parse(JSON.stringify(expected));

    this.assert(
      _.isEqual(obj, expectedAsJSON)
      , "expected #{this} to be like JSON #{exp}"
      , "expected #{this} not to be like JSON #{exp}"
      , expectedAsJSON
      , obj
      , true
    )
  });

  chai.Assertion.addMethod('containOneLike', function(expected){
    var obj = this._obj

    var _obj = _(obj);

    if (!_obj.isObject() && !_obj.isArray()) {
      this.assert(
        false
        , "expected #{this} to be an array, object, or string"
        , "expected #{this} to be an array, object, or string"
      )
    }

    var found = _obj.some(function(needle){
      return _.isEqual(needle,expected);
    });

    this.assert(
      found
      , "expected #{this} to contain one thing like #{exp}"
      , "expected #{this} not to contain one thing like #{exp}"
      , expected
    )
  });

  //export tdd style
  var assert = chai.assert;
  assert.like = function (val, exp, msg) {
    new chai.Assertion(val, msg).to.be.like(exp);
  };
  assert.notLike = function (val, exp, msg) {
    new chai.Assertion(val, msg).to.not.be.like(exp);
  };
  assert.containOneLike = function (val, exp, msg) {
    new chai.Assertion(val, msg).to.containOneLike(exp);
  };
  assert.notContainOneLike = function (val, exp, msg) {
    new chai.Assertion(val, msg).to.not.containOneLike(exp);
  };
  assert.jsonOf = function (val, exp, msg) {
    new chai.Assertion(val, msg).to.be.jsonOf(exp);
  };
  assert.notJsonOf = function (val, exp, msg) {
    new chai.Assertion(val, msg).to.not.be.jsonOf(exp);
  };
}));
/**
 * Sinon.JS 1.9.0, 2014/03/05
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @author Contributors: https://github.com/cjohansen/Sinon.JS/blob/master/AUTHORS
 *
 * (The BSD License)
 *
 * Copyright (c) 2010-2014, Christian Johansen, christian@cjohansen.no
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright notice,
 *       this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright notice,
 *       this list of conditions and the following disclaimer in the documentation
 *       and/or other materials provided with the distribution.
 *     * Neither the name of Christian Johansen nor the names of his contributors
 *       may be used to endorse or promote products derived from this software
 *       without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


this.sinon = (function () {
  var samsam, formatio;
  function define(mod, deps, fn) { if (mod == "samsam") { samsam = deps(); } else { formatio = fn(samsam); } }
  define.amd = true;
  ((typeof define === "function" && define.amd && function (m) { define("samsam", m); }) ||
      (typeof module === "object" &&
          function (m) { module.exports = m(); }) || // Node
      function (m) { this.samsam = m(); } // Browser globals
      )(function () {
    var o = Object.prototype;
    var div = typeof document !== "undefined" && document.createElement("div");

    function isNaN(value) {
      // Unlike global isNaN, this avoids type coercion
      // typeof check avoids IE host object issues, hat tip to
      // lodash
      var val = value; // JsLint thinks value !== value is "weird"
      return typeof value === "number" && value !== val;
    }

    function getClass(value) {
      // Returns the internal [[Class]] by calling Object.prototype.toString
      // with the provided value as this. Return value is a string, naming the
      // internal class, e.g. "Array"
      return o.toString.call(value).split(/[ \]]/)[1];
    }

    /**
     * @name samsam.isArguments
     * @param Object object
     *
     * Returns ``true`` if ``object`` is an ``arguments`` object,
     * ``false`` otherwise.
     */
    function isArguments(object) {
      if (typeof object !== "object" || typeof object.length !== "number" ||
          getClass(object) === "Array") {
        return false;
      }
      if (typeof object.callee == "function") { return true; }
      try {
        object[object.length] = 6;
        delete object[object.length];
      } catch (e) {
        return true;
      }
      return false;
    }

    /**
     * @name samsam.isElement
     * @param Object object
     *
     * Returns ``true`` if ``object`` is a DOM element node. Unlike
     * Underscore.js/lodash, this function will return ``false`` if ``object``
     * is an *element-like* object, i.e. a regular object with a ``nodeType``
     * property that holds the value ``1``.
     */
    function isElement(object) {
      if (!object || object.nodeType !== 1 || !div) { return false; }
      try {
        object.appendChild(div);
        object.removeChild(div);
      } catch (e) {
        return false;
      }
      return true;
    }

    /**
     * @name samsam.keys
     * @param Object object
     *
     * Return an array of own property names.
     */
    function keys(object) {
      var ks = [], prop;
      for (prop in object) {
        if (o.hasOwnProperty.call(object, prop)) { ks.push(prop); }
      }
      return ks;
    }

    /**
     * @name samsam.isDate
     * @param Object value
     *
     * Returns true if the object is a ``Date``, or *date-like*. Duck typing
     * of date objects work by checking that the object has a ``getTime``
     * function whose return value equals the return value from the object's
     * ``valueOf``.
     */
    function isDate(value) {
      return typeof value.getTime == "function" &&
          value.getTime() == value.valueOf();
    }

    /**
     * @name samsam.isNegZero
     * @param Object value
     *
     * Returns ``true`` if ``value`` is ``-0``.
     */
    function isNegZero(value) {
      return value === 0 && 1 / value === -Infinity;
    }

    /**
     * @name samsam.equal
     * @param Object obj1
     * @param Object obj2
     *
     * Returns ``true`` if two objects are strictly equal. Compared to
     * ``===`` there are two exceptions:
     *
     *   - NaN is considered equal to NaN
     *   - -0 and +0 are not considered equal
     */
    function identical(obj1, obj2) {
      if (obj1 === obj2 || (isNaN(obj1) && isNaN(obj2))) {
        return obj1 !== 0 || isNegZero(obj1) === isNegZero(obj2);
      }
    }


    /**
     * @name samsam.deepEqual
     * @param Object obj1
     * @param Object obj2
     *
     * Deep equal comparison. Two values are "deep equal" if:
     *
     *   - They are equal, according to samsam.identical
     *   - They are both date objects representing the same time
     *   - They are both arrays containing elements that are all deepEqual
     *   - They are objects with the same set of properties, and each property
     *     in ``obj1`` is deepEqual to the corresponding property in ``obj2``
     *
     * Supports cyclic objects.
     */
    function deepEqualCyclic(obj1, obj2) {

      // used for cyclic comparison
      // contain already visited objects
      var objects1 = [],
          objects2 = [],
      // contain pathes (position in the object structure)
      // of the already visited objects
      // indexes same as in objects arrays
          paths1 = [],
          paths2 = [],
      // contains combinations of already compared objects
      // in the manner: { "$1['ref']$2['ref']": true }
          compared = {};

      /**
       * used to check, if the value of a property is an object
       * (cyclic logic is only needed for objects)
       * only needed for cyclic logic
       */
      function isObject(value) {

        if (typeof value === 'object' && value !== null &&
            !(value instanceof Boolean) &&
            !(value instanceof Date)    &&
            !(value instanceof Number)  &&
            !(value instanceof RegExp)  &&
            !(value instanceof String)) {

          return true;
        }

        return false;
      }

      /**
       * returns the index of the given object in the
       * given objects array, -1 if not contained
       * only needed for cyclic logic
       */
      function getIndex(objects, obj) {

        var i;
        for (i = 0; i < objects.length; i++) {
          if (objects[i] === obj) {
            return i;
          }
        }

        return -1;
      }

      // does the recursion for the deep equal check
      return (function deepEqual(obj1, obj2, path1, path2) {
        var type1 = typeof obj1;
        var type2 = typeof obj2;

        // == null also matches undefined
        if (obj1 === obj2 ||
            isNaN(obj1) || isNaN(obj2) ||
            obj1 == null || obj2 == null ||
            type1 !== "object" || type2 !== "object") {

          return identical(obj1, obj2);
        }

        // Elements are only equal if identical(expected, actual)
        if (isElement(obj1) || isElement(obj2)) { return false; }

        var isDate1 = isDate(obj1), isDate2 = isDate(obj2);
        if (isDate1 || isDate2) {
          if (!isDate1 || !isDate2 || obj1.getTime() !== obj2.getTime()) {
            return false;
          }
        }

        if (obj1 instanceof RegExp && obj2 instanceof RegExp) {
          if (obj1.toString() !== obj2.toString()) { return false; }
        }

        var class1 = getClass(obj1);
        var class2 = getClass(obj2);
        var keys1 = keys(obj1);
        var keys2 = keys(obj2);

        if (isArguments(obj1) || isArguments(obj2)) {
          if (obj1.length !== obj2.length) { return false; }
        } else {
          if (type1 !== type2 || class1 !== class2 ||
              keys1.length !== keys2.length) {
            return false;
          }
        }

        var key, i, l,
        // following vars are used for the cyclic logic
            value1, value2,
            isObject1, isObject2,
            index1, index2,
            newPath1, newPath2;

        for (i = 0, l = keys1.length; i < l; i++) {
          key = keys1[i];
          if (!o.hasOwnProperty.call(obj2, key)) {
            return false;
          }

          // Start of the cyclic logic

          value1 = obj1[key];
          value2 = obj2[key];

          isObject1 = isObject(value1);
          isObject2 = isObject(value2);

          // determine, if the objects were already visited
          // (it's faster to check for isObject first, than to
          // get -1 from getIndex for non objects)
          index1 = isObject1 ? getIndex(objects1, value1) : -1;
          index2 = isObject2 ? getIndex(objects2, value2) : -1;

          // determine the new pathes of the objects
          // - for non cyclic objects the current path will be extended
          //   by current property name
          // - for cyclic objects the stored path is taken
          newPath1 = index1 !== -1
              ? paths1[index1]
              : path1 + '[' + JSON.stringify(key) + ']';
          newPath2 = index2 !== -1
              ? paths2[index2]
              : path2 + '[' + JSON.stringify(key) + ']';

          // stop recursion if current objects are already compared
          if (compared[newPath1 + newPath2]) {
            return true;
          }

          // remember the current objects and their pathes
          if (index1 === -1 && isObject1) {
            objects1.push(value1);
            paths1.push(newPath1);
          }
          if (index2 === -1 && isObject2) {
            objects2.push(value2);
            paths2.push(newPath2);
          }

          // remember that the current objects are already compared
          if (isObject1 && isObject2) {
            compared[newPath1 + newPath2] = true;
          }

          // End of cyclic logic

          // neither value1 nor value2 is a cycle
          // continue with next level
          if (!deepEqual(value1, value2, newPath1, newPath2)) {
            return false;
          }
        }

        return true;

      }(obj1, obj2, '$1', '$2'));
    }

    var match;

    function arrayContains(array, subset) {
      if (subset.length === 0) { return true; }
      var i, l, j, k;
      for (i = 0, l = array.length; i < l; ++i) {
        if (match(array[i], subset[0])) {
          for (j = 0, k = subset.length; j < k; ++j) {
            if (!match(array[i + j], subset[j])) { return false; }
          }
          return true;
        }
      }
      return false;
    }

    /**
     * @name samsam.match
     * @param Object object
     * @param Object matcher
     *
     * Compare arbitrary value ``object`` with matcher.
     */
    match = function match(object, matcher) {
      if (matcher && typeof matcher.test === "function") {
        return matcher.test(object);
      }

      if (typeof matcher === "function") {
        return matcher(object) === true;
      }

      if (typeof matcher === "string") {
        matcher = matcher.toLowerCase();
        var notNull = typeof object === "string" || !!object;
        return notNull &&
            (String(object)).toLowerCase().indexOf(matcher) >= 0;
      }

      if (typeof matcher === "number") {
        return matcher === object;
      }

      if (typeof matcher === "boolean") {
        return matcher === object;
      }

      if (getClass(object) === "Array" && getClass(matcher) === "Array") {
        return arrayContains(object, matcher);
      }

      if (matcher && typeof matcher === "object") {
        var prop;
        for (prop in matcher) {
          if (!match(object[prop], matcher[prop])) {
            return false;
          }
        }
        return true;
      }

      throw new Error("Matcher was not a string, a number, a " +
          "function, a boolean or an object");
    };

    return {
      isArguments: isArguments,
      isElement: isElement,
      isDate: isDate,
      isNegZero: isNegZero,
      identical: identical,
      deepEqual: deepEqualCyclic,
      match: match,
      keys: keys
    };
  });
  ((typeof define === "function" && define.amd && function (m) {
    define("formatio", ["samsam"], m);
  }) || (typeof module === "object" && function (m) {
    module.exports = m(require("samsam"));
  }) || function (m) { this.formatio = m(this.samsam); }
      )(function (samsam) {

    var formatio = {
      excludeConstructors: ["Object", /^.$/],
      quoteStrings: true
    };

    var hasOwn = Object.prototype.hasOwnProperty;

    var specialObjects = [];
    if (typeof global !== "undefined") {
      specialObjects.push({ object: global, value: "[object global]" });
    }
    if (typeof document !== "undefined") {
      specialObjects.push({
        object: document,
        value: "[object HTMLDocument]"
      });
    }
    if (typeof window !== "undefined") {
      specialObjects.push({ object: window, value: "[object Window]" });
    }

    function functionName(func) {
      if (!func) { return ""; }
      if (func.displayName) { return func.displayName; }
      if (func.name) { return func.name; }
      var matches = func.toString().match(/function\s+([^\(]+)/m);
      return (matches && matches[1]) || "";
    }

    function constructorName(f, object) {
      var name = functionName(object && object.constructor);
      var excludes = f.excludeConstructors ||
          formatio.excludeConstructors || [];

      var i, l;
      for (i = 0, l = excludes.length; i < l; ++i) {
        if (typeof excludes[i] === "string" && excludes[i] === name) {
          return "";
        } else if (excludes[i].test && excludes[i].test(name)) {
          return "";
        }
      }

      return name;
    }

    function isCircular(object, objects) {
      if (typeof object !== "object") { return false; }
      var i, l;
      for (i = 0, l = objects.length; i < l; ++i) {
        if (objects[i] === object) { return true; }
      }
      return false;
    }

    function ascii(f, object, processed, indent) {
      if (typeof object === "string") {
        var qs = f.quoteStrings;
        var quote = typeof qs !== "boolean" || qs;
        return processed || quote ? '"' + object + '"' : object;
      }

      if (typeof object === "function" && !(object instanceof RegExp)) {
        return ascii.func(object);
      }

      processed = processed || [];

      if (isCircular(object, processed)) { return "[Circular]"; }

      if (Object.prototype.toString.call(object) === "[object Array]") {
        return ascii.array.call(f, object, processed);
      }

      if (!object) { return String((1/object) === -Infinity ? "-0" : object); }
      if (samsam.isElement(object)) { return ascii.element(object); }

      if (typeof object.toString === "function" &&
          object.toString !== Object.prototype.toString) {
        return object.toString();
      }

      var i, l;
      for (i = 0, l = specialObjects.length; i < l; i++) {
        if (object === specialObjects[i].object) {
          return specialObjects[i].value;
        }
      }

      return ascii.object.call(f, object, processed, indent);
    }

    ascii.func = function (func) {
      return "function " + functionName(func) + "() {}";
    };

    ascii.array = function (array, processed) {
      processed = processed || [];
      processed.push(array);
      var i, l, pieces = [];
      for (i = 0, l = array.length; i < l; ++i) {
        pieces.push(ascii(this, array[i], processed));
      }
      return "[" + pieces.join(", ") + "]";
    };

    ascii.object = function (object, processed, indent) {
      processed = processed || [];
      processed.push(object);
      indent = indent || 0;
      var pieces = [], properties = samsam.keys(object).sort();
      var length = 3;
      var prop, str, obj, i, l;

      for (i = 0, l = properties.length; i < l; ++i) {
        prop = properties[i];
        obj = object[prop];

        if (isCircular(obj, processed)) {
          str = "[Circular]";
        } else {
          str = ascii(this, obj, processed, indent + 2);
        }

        str = (/\s/.test(prop) ? '"' + prop + '"' : prop) + ": " + str;
        length += str.length;
        pieces.push(str);
      }

      var cons = constructorName(this, object);
      var prefix = cons ? "[" + cons + "] " : "";
      var is = "";
      for (i = 0, l = indent; i < l; ++i) { is += " "; }

      if (length + indent > 80) {
        return prefix + "{\n  " + is + pieces.join(",\n  " + is) + "\n" +
            is + "}";
      }
      return prefix + "{ " + pieces.join(", ") + " }";
    };

    ascii.element = function (element) {
      var tagName = element.tagName.toLowerCase();
      var attrs = element.attributes, attr, pairs = [], attrName, i, l, val;

      for (i = 0, l = attrs.length; i < l; ++i) {
        attr = attrs.item(i);
        attrName = attr.nodeName.toLowerCase().replace("html:", "");
        val = attr.nodeValue;
        if (attrName !== "contenteditable" || val !== "inherit") {
          if (!!val) { pairs.push(attrName + "=\"" + val + "\""); }
        }
      }

      var formatted = "<" + tagName + (pairs.length > 0 ? " " : "");
      var content = element.innerHTML;

      if (content.length > 20) {
        content = content.substr(0, 20) + "[...]";
      }

      var res = formatted + pairs.join(" ") + ">" + content +
          "</" + tagName + ">";

      return res.replace(/ contentEditable="inherit"/, "");
    };

    function Formatio(options) {
      for (var opt in options) {
        this[opt] = options[opt];
      }
    }

    Formatio.prototype = {
      functionName: functionName,

      configure: function (options) {
        return new Formatio(options);
      },

      constructorName: function (object) {
        return constructorName(this, object);
      },

      ascii: function (object, processed, indent) {
        return ascii(this, object, processed, indent);
      }
    };

    return Formatio.prototype;
  });
  /*jslint eqeqeq: false, onevar: false, forin: true, nomen: false, regexp: false, plusplus: false*/
  /*global module, require, __dirname, document*/
  /**
   * Sinon core utilities. For internal use only.
   *
   * @author Christian Johansen (christian@cjohansen.no)
   * @license BSD
   *
   * Copyright (c) 2010-2013 Christian Johansen
   */

  var sinon = (function (formatio) {
    var div = typeof document != "undefined" && document.createElement("div");
    var hasOwn = Object.prototype.hasOwnProperty;

    function isDOMNode(obj) {
      var success = false;

      try {
        obj.appendChild(div);
        success = div.parentNode == obj;
      } catch (e) {
        return false;
      } finally {
        try {
          obj.removeChild(div);
        } catch (e) {
          // Remove failed, not much we can do about that
        }
      }

      return success;
    }

    function isElement(obj) {
      return div && obj && obj.nodeType === 1 && isDOMNode(obj);
    }

    function isFunction(obj) {
      return typeof obj === "function" || !!(obj && obj.constructor && obj.call && obj.apply);
    }

    function mirrorProperties(target, source) {
      for (var prop in source) {
        if (!hasOwn.call(target, prop)) {
          target[prop] = source[prop];
        }
      }
    }

    function isRestorable (obj) {
      return typeof obj === "function" && typeof obj.restore === "function" && obj.restore.sinon;
    }

    var sinon = {
      wrapMethod: function wrapMethod(object, property, method) {
        if (!object) {
          throw new TypeError("Should wrap property of object");
        }

        if (typeof method != "function") {
          throw new TypeError("Method wrapper should be function");
        }

        var wrappedMethod = object[property],
            error;

        if (!isFunction(wrappedMethod)) {
          error = new TypeError("Attempted to wrap " + (typeof wrappedMethod) + " property " +
              property + " as function");
        }

        if (wrappedMethod.restore && wrappedMethod.restore.sinon) {
          error = new TypeError("Attempted to wrap " + property + " which is already wrapped");
        }

        if (wrappedMethod.calledBefore) {
          var verb = !!wrappedMethod.returns ? "stubbed" : "spied on";
          error = new TypeError("Attempted to wrap " + property + " which is already " + verb);
        }

        if (error) {
          if (wrappedMethod._stack) {
            error.stack += '\n--------------\n' + wrappedMethod._stack;
          }
          throw error;
        }

        // IE 8 does not support hasOwnProperty on the window object and Firefox has a problem
        // when using hasOwn.call on objects from other frames.
        var owned = object.hasOwnProperty ? object.hasOwnProperty(property) : hasOwn.call(object, property);
        object[property] = method;
        method.displayName = property;
        // Set up a stack trace which can be used later to find what line of
        // code the original method was created on.
        method._stack = (new Error('Stack Trace for original')).stack;

        method.restore = function () {
          // For prototype properties try to reset by delete first.
          // If this fails (ex: localStorage on mobile safari) then force a reset
          // via direct assignment.
          if (!owned) {
            delete object[property];
          }
          if (object[property] === method) {
            object[property] = wrappedMethod;
          }
        };

        method.restore.sinon = true;
        mirrorProperties(method, wrappedMethod);

        return method;
      },

      extend: function extend(target) {
        for (var i = 1, l = arguments.length; i < l; i += 1) {
          for (var prop in arguments[i]) {
            if (arguments[i].hasOwnProperty(prop)) {
              target[prop] = arguments[i][prop];
            }

            // DONT ENUM bug, only care about toString
            if (arguments[i].hasOwnProperty("toString") &&
                arguments[i].toString != target.toString) {
              target.toString = arguments[i].toString;
            }
          }
        }

        return target;
      },

      create: function create(proto) {
        var F = function () {};
        F.prototype = proto;
        return new F();
      },

      deepEqual: function deepEqual(a, b) {
        if (sinon.match && sinon.match.isMatcher(a)) {
          return a.test(b);
        }
        if (typeof a != "object" || typeof b != "object") {
          return a === b;
        }

        if (isElement(a) || isElement(b)) {
          return a === b;
        }

        if (a === b) {
          return true;
        }

        if ((a === null && b !== null) || (a !== null && b === null)) {
          return false;
        }

        if (a instanceof RegExp && b instanceof RegExp) {
          return (a.source === b.source) && (a.global === b.global) &&
              (a.ignoreCase === b.ignoreCase) && (a.multiline === b.multiline);
        }

        var aString = Object.prototype.toString.call(a);
        if (aString != Object.prototype.toString.call(b)) {
          return false;
        }

        if (aString == "[object Date]") {
          return a.valueOf() === b.valueOf();
        }

        var prop, aLength = 0, bLength = 0;

        if (aString == "[object Array]" && a.length !== b.length) {
          return false;
        }

        for (prop in a) {
          aLength += 1;

          if (!deepEqual(a[prop], b[prop])) {
            return false;
          }
        }

        for (prop in b) {
          bLength += 1;
        }

        return aLength == bLength;
      },

      functionName: function functionName(func) {
        var name = func.displayName || func.name;

        // Use function decomposition as a last resort to get function
        // name. Does not rely on function decomposition to work - if it
        // doesn't debugging will be slightly less informative
        // (i.e. toString will say 'spy' rather than 'myFunc').
        if (!name) {
          var matches = func.toString().match(/function ([^\s\(]+)/);
          name = matches && matches[1];
        }

        return name;
      },

      functionToString: function toString() {
        if (this.getCall && this.callCount) {
          var thisValue, prop, i = this.callCount;

          while (i--) {
            thisValue = this.getCall(i).thisValue;

            for (prop in thisValue) {
              if (thisValue[prop] === this) {
                return prop;
              }
            }
          }
        }

        return this.displayName || "sinon fake";
      },

      getConfig: function (custom) {
        var config = {};
        custom = custom || {};
        var defaults = sinon.defaultConfig;

        for (var prop in defaults) {
          if (defaults.hasOwnProperty(prop)) {
            config[prop] = custom.hasOwnProperty(prop) ? custom[prop] : defaults[prop];
          }
        }

        return config;
      },

      format: function (val) {
        return "" + val;
      },

      defaultConfig: {
        injectIntoThis: true,
        injectInto: null,
        properties: ["spy", "stub", "mock", "clock", "server", "requests"],
        useFakeTimers: true,
        useFakeServer: true
      },

      timesInWords: function timesInWords(count) {
        return count == 1 && "once" ||
            count == 2 && "twice" ||
            count == 3 && "thrice" ||
            (count || 0) + " times";
      },

      calledInOrder: function (spies) {
        for (var i = 1, l = spies.length; i < l; i++) {
          if (!spies[i - 1].calledBefore(spies[i]) || !spies[i].called) {
            return false;
          }
        }

        return true;
      },

      orderByFirstCall: function (spies) {
        return spies.sort(function (a, b) {
          // uuid, won't ever be equal
          var aCall = a.getCall(0);
          var bCall = b.getCall(0);
          var aId = aCall && aCall.callId || -1;
          var bId = bCall && bCall.callId || -1;

          return aId < bId ? -1 : 1;
        });
      },

      log: function () {},

      logError: function (label, err) {
        var msg = label + " threw exception: ";
        sinon.log(msg + "[" + err.name + "] " + err.message);
        if (err.stack) { sinon.log(err.stack); }

        setTimeout(function () {
          err.message = msg + err.message;
          throw err;
        }, 0);
      },

      typeOf: function (value) {
        if (value === null) {
          return "null";
        }
        else if (value === undefined) {
          return "undefined";
        }
        var string = Object.prototype.toString.call(value);
        return string.substring(8, string.length - 1).toLowerCase();
      },

      createStubInstance: function (constructor) {
        if (typeof constructor !== "function") {
          throw new TypeError("The constructor should be a function.");
        }
        return sinon.stub(sinon.create(constructor.prototype));
      },

      restore: function (object) {
        if (object !== null && typeof object === "object") {
          for (var prop in object) {
            if (isRestorable(object[prop])) {
              object[prop].restore();
            }
          }
        }
        else if (isRestorable(object)) {
          object.restore();
        }
      }
    };

    var isNode = typeof module !== "undefined" && module.exports;
    var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd;

    if (isAMD) {
      define(function(){
        return sinon;
      });
    } else if (isNode) {
      try {
        formatio = require("formatio");
      } catch (e) {}
      module.exports = sinon;
      module.exports.spy = require("./sinon/spy");
      module.exports.spyCall = require("./sinon/call");
      module.exports.behavior = require("./sinon/behavior");
      module.exports.stub = require("./sinon/stub");
      module.exports.mock = require("./sinon/mock");
      module.exports.collection = require("./sinon/collection");
      module.exports.assert = require("./sinon/assert");
      module.exports.sandbox = require("./sinon/sandbox");
      module.exports.test = require("./sinon/test");
      module.exports.testCase = require("./sinon/test_case");
      module.exports.assert = require("./sinon/assert");
      module.exports.match = require("./sinon/match");
    }

    if (formatio) {
      var formatter = formatio.configure({ quoteStrings: false });
      sinon.format = function () {
        return formatter.ascii.apply(formatter, arguments);
      };
    } else if (isNode) {
      try {
        var util = require("util");
        sinon.format = function (value) {
          return typeof value == "object" && value.toString === Object.prototype.toString ? util.inspect(value) : value;
        };
      } catch (e) {
        /* Node, but no util module - would be very old, but better safe than
         sorry */
      }
    }

    return sinon;
  }(typeof formatio == "object" && formatio));

  /* @depend ../sinon.js */
  /*jslint eqeqeq: false, onevar: false, plusplus: false*/
  /*global module, require, sinon*/
  /**
   * Match functions
   *
   * @author Maximilian Antoni (mail@maxantoni.de)
   * @license BSD
   *
   * Copyright (c) 2012 Maximilian Antoni
   */

  (function (sinon) {
    var commonJSModule = typeof module !== 'undefined' && module.exports;

    if (!sinon && commonJSModule) {
      sinon = require("../sinon");
    }

    if (!sinon) {
      return;
    }

    function assertType(value, type, name) {
      var actual = sinon.typeOf(value);
      if (actual !== type) {
        throw new TypeError("Expected type of " + name + " to be " +
            type + ", but was " + actual);
      }
    }

    var matcher = {
      toString: function () {
        return this.message;
      }
    };

    function isMatcher(object) {
      return matcher.isPrototypeOf(object);
    }

    function matchObject(expectation, actual) {
      if (actual === null || actual === undefined) {
        return false;
      }
      for (var key in expectation) {
        if (expectation.hasOwnProperty(key)) {
          var exp = expectation[key];
          var act = actual[key];
          if (match.isMatcher(exp)) {
            if (!exp.test(act)) {
              return false;
            }
          } else if (sinon.typeOf(exp) === "object") {
            if (!matchObject(exp, act)) {
              return false;
            }
          } else if (!sinon.deepEqual(exp, act)) {
            return false;
          }
        }
      }
      return true;
    }

    matcher.or = function (m2) {
      if (!arguments.length) {
        throw new TypeError("Matcher expected");
      } else if (!isMatcher(m2)) {
        m2 = match(m2);
      }
      var m1 = this;
      var or = sinon.create(matcher);
      or.test = function (actual) {
        return m1.test(actual) || m2.test(actual);
      };
      or.message = m1.message + ".or(" + m2.message + ")";
      return or;
    };

    matcher.and = function (m2) {
      if (!arguments.length) {
        throw new TypeError("Matcher expected");
      } else if (!isMatcher(m2)) {
        m2 = match(m2);
      }
      var m1 = this;
      var and = sinon.create(matcher);
      and.test = function (actual) {
        return m1.test(actual) && m2.test(actual);
      };
      and.message = m1.message + ".and(" + m2.message + ")";
      return and;
    };

    var match = function (expectation, message) {
      var m = sinon.create(matcher);
      var type = sinon.typeOf(expectation);
      switch (type) {
        case "object":
          if (typeof expectation.test === "function") {
            m.test = function (actual) {
              return expectation.test(actual) === true;
            };
            m.message = "match(" + sinon.functionName(expectation.test) + ")";
            return m;
          }
          var str = [];
          for (var key in expectation) {
            if (expectation.hasOwnProperty(key)) {
              str.push(key + ": " + expectation[key]);
            }
          }
          m.test = function (actual) {
            return matchObject(expectation, actual);
          };
          m.message = "match(" + str.join(", ") + ")";
          break;
        case "number":
          m.test = function (actual) {
            return expectation == actual;
          };
          break;
        case "string":
          m.test = function (actual) {
            if (typeof actual !== "string") {
              return false;
            }
            return actual.indexOf(expectation) !== -1;
          };
          m.message = "match(\"" + expectation + "\")";
          break;
        case "regexp":
          m.test = function (actual) {
            if (typeof actual !== "string") {
              return false;
            }
            return expectation.test(actual);
          };
          break;
        case "function":
          m.test = expectation;
          if (message) {
            m.message = message;
          } else {
            m.message = "match(" + sinon.functionName(expectation) + ")";
          }
          break;
        default:
          m.test = function (actual) {
            return sinon.deepEqual(expectation, actual);
          };
      }
      if (!m.message) {
        m.message = "match(" + expectation + ")";
      }
      return m;
    };

    match.isMatcher = isMatcher;

    match.any = match(function () {
      return true;
    }, "any");

    match.defined = match(function (actual) {
      return actual !== null && actual !== undefined;
    }, "defined");

    match.truthy = match(function (actual) {
      return !!actual;
    }, "truthy");

    match.falsy = match(function (actual) {
      return !actual;
    }, "falsy");

    match.same = function (expectation) {
      return match(function (actual) {
        return expectation === actual;
      }, "same(" + expectation + ")");
    };

    match.typeOf = function (type) {
      assertType(type, "string", "type");
      return match(function (actual) {
        return sinon.typeOf(actual) === type;
      }, "typeOf(\"" + type + "\")");
    };

    match.instanceOf = function (type) {
      assertType(type, "function", "type");
      return match(function (actual) {
        return actual instanceof type;
      }, "instanceOf(" + sinon.functionName(type) + ")");
    };

    function createPropertyMatcher(propertyTest, messagePrefix) {
      return function (property, value) {
        assertType(property, "string", "property");
        var onlyProperty = arguments.length === 1;
        var message = messagePrefix + "(\"" + property + "\"";
        if (!onlyProperty) {
          message += ", " + value;
        }
        message += ")";
        return match(function (actual) {
          if (actual === undefined || actual === null ||
              !propertyTest(actual, property)) {
            return false;
          }
          return onlyProperty || sinon.deepEqual(value, actual[property]);
        }, message);
      };
    }

    match.has = createPropertyMatcher(function (actual, property) {
      if (typeof actual === "object") {
        return property in actual;
      }
      return actual[property] !== undefined;
    }, "has");

    match.hasOwn = createPropertyMatcher(function (actual, property) {
      return actual.hasOwnProperty(property);
    }, "hasOwn");

    match.bool = match.typeOf("boolean");
    match.number = match.typeOf("number");
    match.string = match.typeOf("string");
    match.object = match.typeOf("object");
    match.func = match.typeOf("function");
    match.array = match.typeOf("array");
    match.regexp = match.typeOf("regexp");
    match.date = match.typeOf("date");

    if (commonJSModule) {
      module.exports = match;
    } else {
      sinon.match = match;
    }
  }(typeof sinon == "object" && sinon || null));

  /**
   * @depend ../sinon.js
   * @depend match.js
   */
  /*jslint eqeqeq: false, onevar: false, plusplus: false*/
  /*global module, require, sinon*/
  /**
   * Spy calls
   *
   * @author Christian Johansen (christian@cjohansen.no)
   * @author Maximilian Antoni (mail@maxantoni.de)
   * @license BSD
   *
   * Copyright (c) 2010-2013 Christian Johansen
   * Copyright (c) 2013 Maximilian Antoni
   */

  (function (sinon) {
    var commonJSModule = typeof module !== 'undefined' && module.exports;
    if (!sinon && commonJSModule) {
      sinon = require("../sinon");
    }

    if (!sinon) {
      return;
    }

    function throwYieldError(proxy, text, args) {
      var msg = sinon.functionName(proxy) + text;
      if (args.length) {
        msg += " Received [" + slice.call(args).join(", ") + "]";
      }
      throw new Error(msg);
    }

    var slice = Array.prototype.slice;

    var callProto = {
      calledOn: function calledOn(thisValue) {
        if (sinon.match && sinon.match.isMatcher(thisValue)) {
          return thisValue.test(this.thisValue);
        }
        return this.thisValue === thisValue;
      },

      calledWith: function calledWith() {
        for (var i = 0, l = arguments.length; i < l; i += 1) {
          if (!sinon.deepEqual(arguments[i], this.args[i])) {
            return false;
          }
        }

        return true;
      },

      calledWithMatch: function calledWithMatch() {
        for (var i = 0, l = arguments.length; i < l; i += 1) {
          var actual = this.args[i];
          var expectation = arguments[i];
          if (!sinon.match || !sinon.match(expectation).test(actual)) {
            return false;
          }
        }
        return true;
      },

      calledWithExactly: function calledWithExactly() {
        return arguments.length == this.args.length &&
            this.calledWith.apply(this, arguments);
      },

      notCalledWith: function notCalledWith() {
        return !this.calledWith.apply(this, arguments);
      },

      notCalledWithMatch: function notCalledWithMatch() {
        return !this.calledWithMatch.apply(this, arguments);
      },

      returned: function returned(value) {
        return sinon.deepEqual(value, this.returnValue);
      },

      threw: function threw(error) {
        if (typeof error === "undefined" || !this.exception) {
          return !!this.exception;
        }

        return this.exception === error || this.exception.name === error;
      },

      calledWithNew: function calledWithNew() {
        return this.proxy.prototype && this.thisValue instanceof this.proxy;
      },

      calledBefore: function (other) {
        return this.callId < other.callId;
      },

      calledAfter: function (other) {
        return this.callId > other.callId;
      },

      callArg: function (pos) {
        this.args[pos]();
      },

      callArgOn: function (pos, thisValue) {
        this.args[pos].apply(thisValue);
      },

      callArgWith: function (pos) {
        this.callArgOnWith.apply(this, [pos, null].concat(slice.call(arguments, 1)));
      },

      callArgOnWith: function (pos, thisValue) {
        var args = slice.call(arguments, 2);
        this.args[pos].apply(thisValue, args);
      },

      "yield": function () {
        this.yieldOn.apply(this, [null].concat(slice.call(arguments, 0)));
      },

      yieldOn: function (thisValue) {
        var args = this.args;
        for (var i = 0, l = args.length; i < l; ++i) {
          if (typeof args[i] === "function") {
            args[i].apply(thisValue, slice.call(arguments, 1));
            return;
          }
        }
        throwYieldError(this.proxy, " cannot yield since no callback was passed.", args);
      },

      yieldTo: function (prop) {
        this.yieldToOn.apply(this, [prop, null].concat(slice.call(arguments, 1)));
      },

      yieldToOn: function (prop, thisValue) {
        var args = this.args;
        for (var i = 0, l = args.length; i < l; ++i) {
          if (args[i] && typeof args[i][prop] === "function") {
            args[i][prop].apply(thisValue, slice.call(arguments, 2));
            return;
          }
        }
        throwYieldError(this.proxy, " cannot yield to '" + prop +
            "' since no callback was passed.", args);
      },

      toString: function () {
        var callStr = this.proxy.toString() + "(";
        var args = [];

        for (var i = 0, l = this.args.length; i < l; ++i) {
          args.push(sinon.format(this.args[i]));
        }

        callStr = callStr + args.join(", ") + ")";

        if (typeof this.returnValue != "undefined") {
          callStr += " => " + sinon.format(this.returnValue);
        }

        if (this.exception) {
          callStr += " !" + this.exception.name;

          if (this.exception.message) {
            callStr += "(" + this.exception.message + ")";
          }
        }

        return callStr;
      }
    };

    callProto.invokeCallback = callProto.yield;

    function createSpyCall(spy, thisValue, args, returnValue, exception, id) {
      if (typeof id !== "number") {
        throw new TypeError("Call id is not a number");
      }
      var proxyCall = sinon.create(callProto);
      proxyCall.proxy = spy;
      proxyCall.thisValue = thisValue;
      proxyCall.args = args;
      proxyCall.returnValue = returnValue;
      proxyCall.exception = exception;
      proxyCall.callId = id;

      return proxyCall;
    }
    createSpyCall.toString = callProto.toString; // used by mocks

    if (commonJSModule) {
      module.exports = createSpyCall;
    } else {
      sinon.spyCall = createSpyCall;
    }
  }(typeof sinon == "object" && sinon || null));


  /**
   * @depend ../sinon.js
   * @depend call.js
   */
  /*jslint eqeqeq: false, onevar: false, plusplus: false*/
  /*global module, require, sinon*/
  /**
   * Spy functions
   *
   * @author Christian Johansen (christian@cjohansen.no)
   * @license BSD
   *
   * Copyright (c) 2010-2013 Christian Johansen
   */

  (function (sinon) {
    var commonJSModule = typeof module !== 'undefined' && module.exports;
    var push = Array.prototype.push;
    var slice = Array.prototype.slice;
    var callId = 0;

    if (!sinon && commonJSModule) {
      sinon = require("../sinon");
    }

    if (!sinon) {
      return;
    }

    function spy(object, property) {
      if (!property && typeof object == "function") {
        return spy.create(object);
      }

      if (!object && !property) {
        return spy.create(function () { });
      }

      var method = object[property];
      return sinon.wrapMethod(object, property, spy.create(method));
    }

    function matchingFake(fakes, args, strict) {
      if (!fakes) {
        return;
      }

      for (var i = 0, l = fakes.length; i < l; i++) {
        if (fakes[i].matches(args, strict)) {
          return fakes[i];
        }
      }
    }

    function incrementCallCount() {
      this.called = true;
      this.callCount += 1;
      this.notCalled = false;
      this.calledOnce = this.callCount == 1;
      this.calledTwice = this.callCount == 2;
      this.calledThrice = this.callCount == 3;
    }

    function createCallProperties() {
      this.firstCall = this.getCall(0);
      this.secondCall = this.getCall(1);
      this.thirdCall = this.getCall(2);
      this.lastCall = this.getCall(this.callCount - 1);
    }

    var vars = "a,b,c,d,e,f,g,h,i,j,k,l";
    function createProxy(func) {
      // Retain the function length:
      var p;
      if (func.length) {
        eval("p = (function proxy(" + vars.substring(0, func.length * 2 - 1) +
            ") { return p.invoke(func, this, slice.call(arguments)); });");
      }
      else {
        p = function proxy() {
          return p.invoke(func, this, slice.call(arguments));
        };
      }
      return p;
    }

    var uuid = 0;

    // Public API
    var spyApi = {
      reset: function () {
        this.called = false;
        this.notCalled = true;
        this.calledOnce = false;
        this.calledTwice = false;
        this.calledThrice = false;
        this.callCount = 0;
        this.firstCall = null;
        this.secondCall = null;
        this.thirdCall = null;
        this.lastCall = null;
        this.args = [];
        this.returnValues = [];
        this.thisValues = [];
        this.exceptions = [];
        this.callIds = [];
        if (this.fakes) {
          for (var i = 0; i < this.fakes.length; i++) {
            this.fakes[i].reset();
          }
        }
      },

      create: function create(func) {
        var name;

        if (typeof func != "function") {
          func = function () { };
        } else {
          name = sinon.functionName(func);
        }

        var proxy = createProxy(func);

        sinon.extend(proxy, spy);
        delete proxy.create;
        sinon.extend(proxy, func);

        proxy.reset();
        proxy.prototype = func.prototype;
        proxy.displayName = name || "spy";
        proxy.toString = sinon.functionToString;
        proxy._create = sinon.spy.create;
        proxy.id = "spy#" + uuid++;

        return proxy;
      },

      invoke: function invoke(func, thisValue, args) {
        var matching = matchingFake(this.fakes, args);
        var exception, returnValue;

        incrementCallCount.call(this);
        push.call(this.thisValues, thisValue);
        push.call(this.args, args);
        push.call(this.callIds, callId++);

        try {
          if (matching) {
            returnValue = matching.invoke(func, thisValue, args);
          } else {
            returnValue = (this.func || func).apply(thisValue, args);
          }

          var thisCall = this.getCall(this.callCount - 1);
          if (thisCall.calledWithNew() && typeof returnValue !== 'object') {
            returnValue = thisValue;
          }
        } catch (e) {
          exception = e;
        }

        push.call(this.exceptions, exception);
        push.call(this.returnValues, returnValue);

        createCallProperties.call(this);

        if (exception !== undefined) {
          throw exception;
        }

        return returnValue;
      },

      getCall: function getCall(i) {
        if (i < 0 || i >= this.callCount) {
          return null;
        }

        return sinon.spyCall(this, this.thisValues[i], this.args[i],
            this.returnValues[i], this.exceptions[i],
            this.callIds[i]);
      },

      getCalls: function () {
        var calls = [];
        var i;

        for (i = 0; i < this.callCount; i++) {
          calls.push(this.getCall(i));
        }

        return calls;
      },

      calledBefore: function calledBefore(spyFn) {
        if (!this.called) {
          return false;
        }

        if (!spyFn.called) {
          return true;
        }

        return this.callIds[0] < spyFn.callIds[spyFn.callIds.length - 1];
      },

      calledAfter: function calledAfter(spyFn) {
        if (!this.called || !spyFn.called) {
          return false;
        }

        return this.callIds[this.callCount - 1] > spyFn.callIds[spyFn.callCount - 1];
      },

      withArgs: function () {
        var args = slice.call(arguments);

        if (this.fakes) {
          var match = matchingFake(this.fakes, args, true);

          if (match) {
            return match;
          }
        } else {
          this.fakes = [];
        }

        var original = this;
        var fake = this._create();
        fake.matchingAguments = args;
        fake.parent = this;
        push.call(this.fakes, fake);

        fake.withArgs = function () {
          return original.withArgs.apply(original, arguments);
        };

        for (var i = 0; i < this.args.length; i++) {
          if (fake.matches(this.args[i])) {
            incrementCallCount.call(fake);
            push.call(fake.thisValues, this.thisValues[i]);
            push.call(fake.args, this.args[i]);
            push.call(fake.returnValues, this.returnValues[i]);
            push.call(fake.exceptions, this.exceptions[i]);
            push.call(fake.callIds, this.callIds[i]);
          }
        }
        createCallProperties.call(fake);

        return fake;
      },

      matches: function (args, strict) {
        var margs = this.matchingAguments;

        if (margs.length <= args.length &&
            sinon.deepEqual(margs, args.slice(0, margs.length))) {
          return !strict || margs.length == args.length;
        }
      },

      printf: function (format) {
        var spy = this;
        var args = slice.call(arguments, 1);
        var formatter;

        return (format || "").replace(/%(.)/g, function (match, specifyer) {
          formatter = spyApi.formatters[specifyer];

          if (typeof formatter == "function") {
            return formatter.call(null, spy, args);
          } else if (!isNaN(parseInt(specifyer, 10))) {
            return sinon.format(args[specifyer - 1]);
          }

          return "%" + specifyer;
        });
      }
    };

    function delegateToCalls(method, matchAny, actual, notCalled) {
      spyApi[method] = function () {
        if (!this.called) {
          if (notCalled) {
            return notCalled.apply(this, arguments);
          }
          return false;
        }

        var currentCall;
        var matches = 0;

        for (var i = 0, l = this.callCount; i < l; i += 1) {
          currentCall = this.getCall(i);

          if (currentCall[actual || method].apply(currentCall, arguments)) {
            matches += 1;

            if (matchAny) {
              return true;
            }
          }
        }

        return matches === this.callCount;
      };
    }

    delegateToCalls("calledOn", true);
    delegateToCalls("alwaysCalledOn", false, "calledOn");
    delegateToCalls("calledWith", true);
    delegateToCalls("calledWithMatch", true);
    delegateToCalls("alwaysCalledWith", false, "calledWith");
    delegateToCalls("alwaysCalledWithMatch", false, "calledWithMatch");
    delegateToCalls("calledWithExactly", true);
    delegateToCalls("alwaysCalledWithExactly", false, "calledWithExactly");
    delegateToCalls("neverCalledWith", false, "notCalledWith",
        function () { return true; });
    delegateToCalls("neverCalledWithMatch", false, "notCalledWithMatch",
        function () { return true; });
    delegateToCalls("threw", true);
    delegateToCalls("alwaysThrew", false, "threw");
    delegateToCalls("returned", true);
    delegateToCalls("alwaysReturned", false, "returned");
    delegateToCalls("calledWithNew", true);
    delegateToCalls("alwaysCalledWithNew", false, "calledWithNew");
    delegateToCalls("callArg", false, "callArgWith", function () {
      throw new Error(this.toString() + " cannot call arg since it was not yet invoked.");
    });
    spyApi.callArgWith = spyApi.callArg;
    delegateToCalls("callArgOn", false, "callArgOnWith", function () {
      throw new Error(this.toString() + " cannot call arg since it was not yet invoked.");
    });
    spyApi.callArgOnWith = spyApi.callArgOn;
    delegateToCalls("yield", false, "yield", function () {
      throw new Error(this.toString() + " cannot yield since it was not yet invoked.");
    });
    // "invokeCallback" is an alias for "yield" since "yield" is invalid in strict mode.
    spyApi.invokeCallback = spyApi.yield;
    delegateToCalls("yieldOn", false, "yieldOn", function () {
      throw new Error(this.toString() + " cannot yield since it was not yet invoked.");
    });
    delegateToCalls("yieldTo", false, "yieldTo", function (property) {
      throw new Error(this.toString() + " cannot yield to '" + property +
          "' since it was not yet invoked.");
    });
    delegateToCalls("yieldToOn", false, "yieldToOn", function (property) {
      throw new Error(this.toString() + " cannot yield to '" + property +
          "' since it was not yet invoked.");
    });

    spyApi.formatters = {
      "c": function (spy) {
        return sinon.timesInWords(spy.callCount);
      },

      "n": function (spy) {
        return spy.toString();
      },

      "C": function (spy) {
        var calls = [];

        for (var i = 0, l = spy.callCount; i < l; ++i) {
          var stringifiedCall = "    " + spy.getCall(i).toString();
          if (/\n/.test(calls[i - 1])) {
            stringifiedCall = "\n" + stringifiedCall;
          }
          push.call(calls, stringifiedCall);
        }

        return calls.length > 0 ? "\n" + calls.join("\n") : "";
      },

      "t": function (spy) {
        var objects = [];

        for (var i = 0, l = spy.callCount; i < l; ++i) {
          push.call(objects, sinon.format(spy.thisValues[i]));
        }

        return objects.join(", ");
      },

      "*": function (spy, args) {
        var formatted = [];

        for (var i = 0, l = args.length; i < l; ++i) {
          push.call(formatted, sinon.format(args[i]));
        }

        return formatted.join(", ");
      }
    };

    sinon.extend(spy, spyApi);

    spy.spyCall = sinon.spyCall;

    if (commonJSModule) {
      module.exports = spy;
    } else {
      sinon.spy = spy;
    }
  }(typeof sinon == "object" && sinon || null));

  /**
   * @depend ../sinon.js
   */
  /*jslint eqeqeq: false, onevar: false*/
  /*global module, require, sinon, process, setImmediate, setTimeout*/
  /**
   * Stub behavior
   *
   * @author Christian Johansen (christian@cjohansen.no)
   * @author Tim Fischbach (mail@timfischbach.de)
   * @license BSD
   *
   * Copyright (c) 2010-2013 Christian Johansen
   */

  (function (sinon) {
    var commonJSModule = typeof module !== 'undefined' && module.exports;

    if (!sinon && commonJSModule) {
      sinon = require("../sinon");
    }

    if (!sinon) {
      return;
    }

    var slice = Array.prototype.slice;
    var join = Array.prototype.join;
    var proto;

    var nextTick = (function () {
      if (typeof process === "object" && typeof process.nextTick === "function") {
        return process.nextTick;
      } else if (typeof setImmediate === "function") {
        return setImmediate;
      } else {
        return function (callback) {
          setTimeout(callback, 0);
        };
      }
    })();

    function throwsException(error, message) {
      if (typeof error == "string") {
        this.exception = new Error(message || "");
        this.exception.name = error;
      } else if (!error) {
        this.exception = new Error("Error");
      } else {
        this.exception = error;
      }

      return this;
    }

    function getCallback(behavior, args) {
      var callArgAt = behavior.callArgAt;

      if (callArgAt < 0) {
        var callArgProp = behavior.callArgProp;

        for (var i = 0, l = args.length; i < l; ++i) {
          if (!callArgProp && typeof args[i] == "function") {
            return args[i];
          }

          if (callArgProp && args[i] &&
              typeof args[i][callArgProp] == "function") {
            return args[i][callArgProp];
          }
        }

        return null;
      }

      return args[callArgAt];
    }

    function getCallbackError(behavior, func, args) {
      if (behavior.callArgAt < 0) {
        var msg;

        if (behavior.callArgProp) {
          msg = sinon.functionName(behavior.stub) +
              " expected to yield to '" + behavior.callArgProp +
              "', but no object with such a property was passed.";
        } else {
          msg = sinon.functionName(behavior.stub) +
              " expected to yield, but no callback was passed.";
        }

        if (args.length > 0) {
          msg += " Received [" + join.call(args, ", ") + "]";
        }

        return msg;
      }

      return "argument at index " + behavior.callArgAt + " is not a function: " + func;
    }

    function callCallback(behavior, args) {
      if (typeof behavior.callArgAt == "number") {
        var func = getCallback(behavior, args);

        if (typeof func != "function") {
          throw new TypeError(getCallbackError(behavior, func, args));
        }

        if (behavior.callbackAsync) {
          nextTick(function() {
            func.apply(behavior.callbackContext, behavior.callbackArguments);
          });
        } else {
          func.apply(behavior.callbackContext, behavior.callbackArguments);
        }
      }
    }

    proto = {
      create: function(stub) {
        var behavior = sinon.extend({}, sinon.behavior);
        delete behavior.create;
        behavior.stub = stub;

        return behavior;
      },

      isPresent: function() {
        return (typeof this.callArgAt == 'number' ||
            this.exception ||
            typeof this.returnArgAt == 'number' ||
            this.returnThis ||
            this.returnValueDefined);
      },

      invoke: function(context, args) {
        callCallback(this, args);

        if (this.exception) {
          throw this.exception;
        } else if (typeof this.returnArgAt == 'number') {
          return args[this.returnArgAt];
        } else if (this.returnThis) {
          return context;
        }

        return this.returnValue;
      },

      onCall: function(index) {
        return this.stub.onCall(index);
      },

      onFirstCall: function() {
        return this.stub.onFirstCall();
      },

      onSecondCall: function() {
        return this.stub.onSecondCall();
      },

      onThirdCall: function() {
        return this.stub.onThirdCall();
      },

      withArgs: function(/* arguments */) {
        throw new Error('Defining a stub by invoking "stub.onCall(...).withArgs(...)" is not supported. ' +
            'Use "stub.withArgs(...).onCall(...)" to define sequential behavior for calls with certain arguments.');
      },

      callsArg: function callsArg(pos) {
        if (typeof pos != "number") {
          throw new TypeError("argument index is not number");
        }

        this.callArgAt = pos;
        this.callbackArguments = [];
        this.callbackContext = undefined;
        this.callArgProp = undefined;
        this.callbackAsync = false;

        return this;
      },

      callsArgOn: function callsArgOn(pos, context) {
        if (typeof pos != "number") {
          throw new TypeError("argument index is not number");
        }
        if (typeof context != "object") {
          throw new TypeError("argument context is not an object");
        }

        this.callArgAt = pos;
        this.callbackArguments = [];
        this.callbackContext = context;
        this.callArgProp = undefined;
        this.callbackAsync = false;

        return this;
      },

      callsArgWith: function callsArgWith(pos) {
        if (typeof pos != "number") {
          throw new TypeError("argument index is not number");
        }

        this.callArgAt = pos;
        this.callbackArguments = slice.call(arguments, 1);
        this.callbackContext = undefined;
        this.callArgProp = undefined;
        this.callbackAsync = false;

        return this;
      },

      callsArgOnWith: function callsArgWith(pos, context) {
        if (typeof pos != "number") {
          throw new TypeError("argument index is not number");
        }
        if (typeof context != "object") {
          throw new TypeError("argument context is not an object");
        }

        this.callArgAt = pos;
        this.callbackArguments = slice.call(arguments, 2);
        this.callbackContext = context;
        this.callArgProp = undefined;
        this.callbackAsync = false;

        return this;
      },

      yields: function () {
        this.callArgAt = -1;
        this.callbackArguments = slice.call(arguments, 0);
        this.callbackContext = undefined;
        this.callArgProp = undefined;
        this.callbackAsync = false;

        return this;
      },

      yieldsOn: function (context) {
        if (typeof context != "object") {
          throw new TypeError("argument context is not an object");
        }

        this.callArgAt = -1;
        this.callbackArguments = slice.call(arguments, 1);
        this.callbackContext = context;
        this.callArgProp = undefined;
        this.callbackAsync = false;

        return this;
      },

      yieldsTo: function (prop) {
        this.callArgAt = -1;
        this.callbackArguments = slice.call(arguments, 1);
        this.callbackContext = undefined;
        this.callArgProp = prop;
        this.callbackAsync = false;

        return this;
      },

      yieldsToOn: function (prop, context) {
        if (typeof context != "object") {
          throw new TypeError("argument context is not an object");
        }

        this.callArgAt = -1;
        this.callbackArguments = slice.call(arguments, 2);
        this.callbackContext = context;
        this.callArgProp = prop;
        this.callbackAsync = false;

        return this;
      },


      "throws": throwsException,
      throwsException: throwsException,

      returns: function returns(value) {
        this.returnValue = value;
        this.returnValueDefined = true;

        return this;
      },

      returnsArg: function returnsArg(pos) {
        if (typeof pos != "number") {
          throw new TypeError("argument index is not number");
        }

        this.returnArgAt = pos;

        return this;
      },

      returnsThis: function returnsThis() {
        this.returnThis = true;

        return this;
      }
    };

    // create asynchronous versions of callsArg* and yields* methods
    for (var method in proto) {
      // need to avoid creating anotherasync versions of the newly added async methods
      if (proto.hasOwnProperty(method) &&
          method.match(/^(callsArg|yields)/) &&
          !method.match(/Async/)) {
        proto[method + 'Async'] = (function (syncFnName) {
          return function () {
            var result = this[syncFnName].apply(this, arguments);
            this.callbackAsync = true;
            return result;
          };
        })(method);
      }
    }

    if (commonJSModule) {
      module.exports = proto;
    } else {
      sinon.behavior = proto;
    }
  }(typeof sinon == "object" && sinon || null));
  /**
   * @depend ../sinon.js
   * @depend spy.js
   * @depend behavior.js
   */
  /*jslint eqeqeq: false, onevar: false*/
  /*global module, require, sinon*/
  /**
   * Stub functions
   *
   * @author Christian Johansen (christian@cjohansen.no)
   * @license BSD
   *
   * Copyright (c) 2010-2013 Christian Johansen
   */

  (function (sinon) {
    var commonJSModule = typeof module !== 'undefined' && module.exports;

    if (!sinon && commonJSModule) {
      sinon = require("../sinon");
    }

    if (!sinon) {
      return;
    }

    function stub(object, property, func) {
      if (!!func && typeof func != "function") {
        throw new TypeError("Custom stub should be function");
      }

      var wrapper;

      if (func) {
        wrapper = sinon.spy && sinon.spy.create ? sinon.spy.create(func) : func;
      } else {
        wrapper = stub.create();
      }

      if (!object && typeof property === "undefined") {
        return sinon.stub.create();
      }

      if (typeof property === "undefined" && typeof object == "object") {
        for (var prop in object) {
          if (typeof object[prop] === "function") {
            stub(object, prop);
          }
        }

        return object;
      }

      return sinon.wrapMethod(object, property, wrapper);
    }

    function getDefaultBehavior(stub) {
      return stub.defaultBehavior || getParentBehaviour(stub) || sinon.behavior.create(stub);
    }

    function getParentBehaviour(stub) {
      return (stub.parent && getCurrentBehavior(stub.parent));
    }

    function getCurrentBehavior(stub) {
      var behavior = stub.behaviors[stub.callCount - 1];
      return behavior && behavior.isPresent() ? behavior : getDefaultBehavior(stub);
    }

    var uuid = 0;

    sinon.extend(stub, (function () {
      var proto = {
        create: function create() {
          var functionStub = function () {
            return getCurrentBehavior(functionStub).invoke(this, arguments);
          };

          functionStub.id = "stub#" + uuid++;
          var orig = functionStub;
          functionStub = sinon.spy.create(functionStub);
          functionStub.func = orig;

          sinon.extend(functionStub, stub);
          functionStub._create = sinon.stub.create;
          functionStub.displayName = "stub";
          functionStub.toString = sinon.functionToString;

          functionStub.defaultBehavior = null;
          functionStub.behaviors = [];

          return functionStub;
        },

        resetBehavior: function () {
          var i;

          this.defaultBehavior = null;
          this.behaviors = [];

          delete this.returnValue;
          delete this.returnArgAt;
          this.returnThis = false;

          if (this.fakes) {
            for (i = 0; i < this.fakes.length; i++) {
              this.fakes[i].resetBehavior();
            }
          }
        },

        onCall: function(index) {
          if (!this.behaviors[index]) {
            this.behaviors[index] = sinon.behavior.create(this);
          }

          return this.behaviors[index];
        },

        onFirstCall: function() {
          return this.onCall(0);
        },

        onSecondCall: function() {
          return this.onCall(1);
        },

        onThirdCall: function() {
          return this.onCall(2);
        }
      };

      for (var method in sinon.behavior) {
        if (sinon.behavior.hasOwnProperty(method) &&
            !proto.hasOwnProperty(method) &&
            method != 'create' &&
            method != 'withArgs' &&
            method != 'invoke') {
          proto[method] = (function(behaviorMethod) {
            return function() {
              this.defaultBehavior = this.defaultBehavior || sinon.behavior.create(this);
              this.defaultBehavior[behaviorMethod].apply(this.defaultBehavior, arguments);
              return this;
            };
          }(method));
        }
      }

      return proto;
    }()));

    if (commonJSModule) {
      module.exports = stub;
    } else {
      sinon.stub = stub;
    }
  }(typeof sinon == "object" && sinon || null));

  /**
   * @depend ../sinon.js
   * @depend stub.js
   */
  /*jslint eqeqeq: false, onevar: false, nomen: false*/
  /*global module, require, sinon*/
  /**
   * Mock functions.
   *
   * @author Christian Johansen (christian@cjohansen.no)
   * @license BSD
   *
   * Copyright (c) 2010-2013 Christian Johansen
   */

  (function (sinon) {
    var commonJSModule = typeof module !== 'undefined' && module.exports;
    var push = [].push;
    var match;

    if (!sinon && commonJSModule) {
      sinon = require("../sinon");
    }

    if (!sinon) {
      return;
    }

    match = sinon.match;

    if (!match && commonJSModule) {
      match = require("./match");
    }

    function mock(object) {
      if (!object) {
        return sinon.expectation.create("Anonymous mock");
      }

      return mock.create(object);
    }

    sinon.mock = mock;

    sinon.extend(mock, (function () {
      function each(collection, callback) {
        if (!collection) {
          return;
        }

        for (var i = 0, l = collection.length; i < l; i += 1) {
          callback(collection[i]);
        }
      }

      return {
        create: function create(object) {
          if (!object) {
            throw new TypeError("object is null");
          }

          var mockObject = sinon.extend({}, mock);
          mockObject.object = object;
          delete mockObject.create;

          return mockObject;
        },

        expects: function expects(method) {
          if (!method) {
            throw new TypeError("method is falsy");
          }

          if (!this.expectations) {
            this.expectations = {};
            this.proxies = [];
          }

          if (!this.expectations[method]) {
            this.expectations[method] = [];
            var mockObject = this;

            sinon.wrapMethod(this.object, method, function () {
              return mockObject.invokeMethod(method, this, arguments);
            });

            push.call(this.proxies, method);
          }

          var expectation = sinon.expectation.create(method);
          push.call(this.expectations[method], expectation);

          return expectation;
        },

        restore: function restore() {
          var object = this.object;

          each(this.proxies, function (proxy) {
            if (typeof object[proxy].restore == "function") {
              object[proxy].restore();
            }
          });
        },

        verify: function verify() {
          var expectations = this.expectations || {};
          var messages = [], met = [];

          each(this.proxies, function (proxy) {
            each(expectations[proxy], function (expectation) {
              if (!expectation.met()) {
                push.call(messages, expectation.toString());
              } else {
                push.call(met, expectation.toString());
              }
            });
          });

          this.restore();

          if (messages.length > 0) {
            sinon.expectation.fail(messages.concat(met).join("\n"));
          } else {
            sinon.expectation.pass(messages.concat(met).join("\n"));
          }

          return true;
        },

        invokeMethod: function invokeMethod(method, thisValue, args) {
          var expectations = this.expectations && this.expectations[method];
          var length = expectations && expectations.length || 0, i;

          for (i = 0; i < length; i += 1) {
            if (!expectations[i].met() &&
                expectations[i].allowsCall(thisValue, args)) {
              return expectations[i].apply(thisValue, args);
            }
          }

          var messages = [], available, exhausted = 0;

          for (i = 0; i < length; i += 1) {
            if (expectations[i].allowsCall(thisValue, args)) {
              available = available || expectations[i];
            } else {
              exhausted += 1;
            }
            push.call(messages, "    " + expectations[i].toString());
          }

          if (exhausted === 0) {
            return available.apply(thisValue, args);
          }

          messages.unshift("Unexpected call: " + sinon.spyCall.toString.call({
            proxy: method,
            args: args
          }));

          sinon.expectation.fail(messages.join("\n"));
        }
      };
    }()));

    var times = sinon.timesInWords;

    sinon.expectation = (function () {
      var slice = Array.prototype.slice;
      var _invoke = sinon.spy.invoke;

      function callCountInWords(callCount) {
        if (callCount == 0) {
          return "never called";
        } else {
          return "called " + times(callCount);
        }
      }

      function expectedCallCountInWords(expectation) {
        var min = expectation.minCalls;
        var max = expectation.maxCalls;

        if (typeof min == "number" && typeof max == "number") {
          var str = times(min);

          if (min != max) {
            str = "at least " + str + " and at most " + times(max);
          }

          return str;
        }

        if (typeof min == "number") {
          return "at least " + times(min);
        }

        return "at most " + times(max);
      }

      function receivedMinCalls(expectation) {
        var hasMinLimit = typeof expectation.minCalls == "number";
        return !hasMinLimit || expectation.callCount >= expectation.minCalls;
      }

      function receivedMaxCalls(expectation) {
        if (typeof expectation.maxCalls != "number") {
          return false;
        }

        return expectation.callCount == expectation.maxCalls;
      }

      function verifyMatcher(possibleMatcher, arg){
        if (match && match.isMatcher(possibleMatcher)) {
          return possibleMatcher.test(arg);
        } else {
          return true;
        }
      }

      return {
        minCalls: 1,
        maxCalls: 1,

        create: function create(methodName) {
          var expectation = sinon.extend(sinon.stub.create(), sinon.expectation);
          delete expectation.create;
          expectation.method = methodName;

          return expectation;
        },

        invoke: function invoke(func, thisValue, args) {
          this.verifyCallAllowed(thisValue, args);

          return _invoke.apply(this, arguments);
        },

        atLeast: function atLeast(num) {
          if (typeof num != "number") {
            throw new TypeError("'" + num + "' is not number");
          }

          if (!this.limitsSet) {
            this.maxCalls = null;
            this.limitsSet = true;
          }

          this.minCalls = num;

          return this;
        },

        atMost: function atMost(num) {
          if (typeof num != "number") {
            throw new TypeError("'" + num + "' is not number");
          }

          if (!this.limitsSet) {
            this.minCalls = null;
            this.limitsSet = true;
          }

          this.maxCalls = num;

          return this;
        },

        never: function never() {
          return this.exactly(0);
        },

        once: function once() {
          return this.exactly(1);
        },

        twice: function twice() {
          return this.exactly(2);
        },

        thrice: function thrice() {
          return this.exactly(3);
        },

        exactly: function exactly(num) {
          if (typeof num != "number") {
            throw new TypeError("'" + num + "' is not a number");
          }

          this.atLeast(num);
          return this.atMost(num);
        },

        met: function met() {
          return !this.failed && receivedMinCalls(this);
        },

        verifyCallAllowed: function verifyCallAllowed(thisValue, args) {
          if (receivedMaxCalls(this)) {
            this.failed = true;
            sinon.expectation.fail(this.method + " already called " + times(this.maxCalls));
          }

          if ("expectedThis" in this && this.expectedThis !== thisValue) {
            sinon.expectation.fail(this.method + " called with " + thisValue + " as thisValue, expected " +
                this.expectedThis);
          }

          if (!("expectedArguments" in this)) {
            return;
          }

          if (!args) {
            sinon.expectation.fail(this.method + " received no arguments, expected " +
                sinon.format(this.expectedArguments));
          }

          if (args.length < this.expectedArguments.length) {
            sinon.expectation.fail(this.method + " received too few arguments (" + sinon.format(args) +
                "), expected " + sinon.format(this.expectedArguments));
          }

          if (this.expectsExactArgCount &&
              args.length != this.expectedArguments.length) {
            sinon.expectation.fail(this.method + " received too many arguments (" + sinon.format(args) +
                "), expected " + sinon.format(this.expectedArguments));
          }

          for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {

            if (!verifyMatcher(this.expectedArguments[i],args[i])) {
              sinon.expectation.fail(this.method + " received wrong arguments " + sinon.format(args) +
                  ", didn't match " + this.expectedArguments.toString());
            }

            if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {
              sinon.expectation.fail(this.method + " received wrong arguments " + sinon.format(args) +
                  ", expected " + sinon.format(this.expectedArguments));
            }
          }
        },

        allowsCall: function allowsCall(thisValue, args) {
          if (this.met() && receivedMaxCalls(this)) {
            return false;
          }

          if ("expectedThis" in this && this.expectedThis !== thisValue) {
            return false;
          }

          if (!("expectedArguments" in this)) {
            return true;
          }

          args = args || [];

          if (args.length < this.expectedArguments.length) {
            return false;
          }

          if (this.expectsExactArgCount &&
              args.length != this.expectedArguments.length) {
            return false;
          }

          for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {
            if (!verifyMatcher(this.expectedArguments[i],args[i])) {
              return false;
            }

            if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {
              return false;
            }
          }

          return true;
        },

        withArgs: function withArgs() {
          this.expectedArguments = slice.call(arguments);
          return this;
        },

        withExactArgs: function withExactArgs() {
          this.withArgs.apply(this, arguments);
          this.expectsExactArgCount = true;
          return this;
        },

        on: function on(thisValue) {
          this.expectedThis = thisValue;
          return this;
        },

        toString: function () {
          var args = (this.expectedArguments || []).slice();

          if (!this.expectsExactArgCount) {
            push.call(args, "[...]");
          }

          var callStr = sinon.spyCall.toString.call({
            proxy: this.method || "anonymous mock expectation",
            args: args
          });

          var message = callStr.replace(", [...", "[, ...") + " " +
              expectedCallCountInWords(this);

          if (this.met()) {
            return "Expectation met: " + message;
          }

          return "Expected " + message + " (" +
              callCountInWords(this.callCount) + ")";
        },

        verify: function verify() {
          if (!this.met()) {
            sinon.expectation.fail(this.toString());
          } else {
            sinon.expectation.pass(this.toString());
          }

          return true;
        },

        pass: function(message) {
          sinon.assert.pass(message);
        },
        fail: function (message) {
          var exception = new Error(message);
          exception.name = "ExpectationError";

          throw exception;
        }
      };
    }());

    if (commonJSModule) {
      module.exports = mock;
    } else {
      sinon.mock = mock;
    }
  }(typeof sinon == "object" && sinon || null));

  /**
   * @depend ../sinon.js
   * @depend stub.js
   * @depend mock.js
   */
  /*jslint eqeqeq: false, onevar: false, forin: true*/
  /*global module, require, sinon*/
  /**
   * Collections of stubs, spies and mocks.
   *
   * @author Christian Johansen (christian@cjohansen.no)
   * @license BSD
   *
   * Copyright (c) 2010-2013 Christian Johansen
   */

  (function (sinon) {
    var commonJSModule = typeof module !== 'undefined' && module.exports;
    var push = [].push;
    var hasOwnProperty = Object.prototype.hasOwnProperty;

    if (!sinon && commonJSModule) {
      sinon = require("../sinon");
    }

    if (!sinon) {
      return;
    }

    function getFakes(fakeCollection) {
      if (!fakeCollection.fakes) {
        fakeCollection.fakes = [];
      }

      return fakeCollection.fakes;
    }

    function each(fakeCollection, method) {
      var fakes = getFakes(fakeCollection);

      for (var i = 0, l = fakes.length; i < l; i += 1) {
        if (typeof fakes[i][method] == "function") {
          fakes[i][method]();
        }
      }
    }

    function compact(fakeCollection) {
      var fakes = getFakes(fakeCollection);
      var i = 0;
      while (i < fakes.length) {
        fakes.splice(i, 1);
      }
    }

    var collection = {
      verify: function resolve() {
        each(this, "verify");
      },

      restore: function restore() {
        each(this, "restore");
        compact(this);
      },

      verifyAndRestore: function verifyAndRestore() {
        var exception;

        try {
          this.verify();
        } catch (e) {
          exception = e;
        }

        this.restore();

        if (exception) {
          throw exception;
        }
      },

      add: function add(fake) {
        push.call(getFakes(this), fake);
        return fake;
      },

      spy: function spy() {
        return this.add(sinon.spy.apply(sinon, arguments));
      },

      stub: function stub(object, property, value) {
        if (property) {
          var original = object[property];

          if (typeof original != "function") {
            if (!hasOwnProperty.call(object, property)) {
              throw new TypeError("Cannot stub non-existent own property " + property);
            }

            object[property] = value;

            return this.add({
              restore: function () {
                object[property] = original;
              }
            });
          }
        }
        if (!property && !!object && typeof object == "object") {
          var stubbedObj = sinon.stub.apply(sinon, arguments);

          for (var prop in stubbedObj) {
            if (typeof stubbedObj[prop] === "function") {
              this.add(stubbedObj[prop]);
            }
          }

          return stubbedObj;
        }

        return this.add(sinon.stub.apply(sinon, arguments));
      },

      mock: function mock() {
        return this.add(sinon.mock.apply(sinon, arguments));
      },

      inject: function inject(obj) {
        var col = this;

        obj.spy = function () {
          return col.spy.apply(col, arguments);
        };

        obj.stub = function () {
          return col.stub.apply(col, arguments);
        };

        obj.mock = function () {
          return col.mock.apply(col, arguments);
        };

        return obj;
      }
    };

    if (commonJSModule) {
      module.exports = collection;
    } else {
      sinon.collection = collection;
    }
  }(typeof sinon == "object" && sinon || null));

  /*jslint eqeqeq: false, plusplus: false, evil: true, onevar: false, browser: true, forin: false*/
  /*global module, require, window*/
  /**
   * Fake timer API
   * setTimeout
   * setInterval
   * clearTimeout
   * clearInterval
   * tick
   * reset
   * Date
   *
   * Inspired by jsUnitMockTimeOut from JsUnit
   *
   * @author Christian Johansen (christian@cjohansen.no)
   * @license BSD
   *
   * Copyright (c) 2010-2013 Christian Johansen
   */

  if (typeof sinon == "undefined") {
    var sinon = {};
  }

  (function (global) {
    var id = 1;

    function addTimer(args, recurring) {
      if (args.length === 0) {
        throw new Error("Function requires at least 1 parameter");
      }

      if (typeof args[0] === "undefined") {
        throw new Error("Callback must be provided to timer calls");
      }

      var toId = id++;
      var delay = args[1] || 0;

      if (!this.timeouts) {
        this.timeouts = {};
      }

      this.timeouts[toId] = {
        id: toId,
        func: args[0],
        callAt: this.now + delay,
        invokeArgs: Array.prototype.slice.call(args, 2)
      };

      if (recurring === true) {
        this.timeouts[toId].interval = delay;
      }

      return toId;
    }

    function parseTime(str) {
      if (!str) {
        return 0;
      }

      var strings = str.split(":");
      var l = strings.length, i = l;
      var ms = 0, parsed;

      if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
        throw new Error("tick only understands numbers and 'h:m:s'");
      }

      while (i--) {
        parsed = parseInt(strings[i], 10);

        if (parsed >= 60) {
          throw new Error("Invalid time " + str);
        }

        ms += parsed * Math.pow(60, (l - i - 1));
      }

      return ms * 1000;
    }

    function createObject(object) {
      var newObject;

      if (Object.create) {
        newObject = Object.create(object);
      } else {
        var F = function () {};
        F.prototype = object;
        newObject = new F();
      }

      newObject.Date.clock = newObject;
      return newObject;
    }

    sinon.clock = {
      now: 0,

      create: function create(now) {
        var clock = createObject(this);

        if (typeof now == "number") {
          clock.now = now;
        }

        if (!!now && typeof now == "object") {
          throw new TypeError("now should be milliseconds since UNIX epoch");
        }

        return clock;
      },

      setTimeout: function setTimeout(callback, timeout) {
        return addTimer.call(this, arguments, false);
      },

      clearTimeout: function clearTimeout(timerId) {
        if (!this.timeouts) {
          this.timeouts = [];
        }

        if (timerId in this.timeouts) {
          delete this.timeouts[timerId];
        }
      },

      setInterval: function setInterval(callback, timeout) {
        return addTimer.call(this, arguments, true);
      },

      clearInterval: function clearInterval(timerId) {
        this.clearTimeout(timerId);
      },

      setImmediate: function setImmediate(callback) {
        var passThruArgs = Array.prototype.slice.call(arguments, 1);

        return addTimer.call(this, [callback, 0].concat(passThruArgs), false);
      },

      clearImmediate: function clearImmediate(timerId) {
        this.clearTimeout(timerId);
      },

      tick: function tick(ms) {
        ms = typeof ms == "number" ? ms : parseTime(ms);
        var tickFrom = this.now, tickTo = this.now + ms, previous = this.now;
        var timer = this.firstTimerInRange(tickFrom, tickTo);

        var firstException;
        while (timer && tickFrom <= tickTo) {
          if (this.timeouts[timer.id]) {
            tickFrom = this.now = timer.callAt;
            try {
              this.callTimer(timer);
            } catch (e) {
              firstException = firstException || e;
            }
          }

          timer = this.firstTimerInRange(previous, tickTo);
          previous = tickFrom;
        }

        this.now = tickTo;

        if (firstException) {
          throw firstException;
        }

        return this.now;
      },

      firstTimerInRange: function (from, to) {
        var timer, smallest = null, originalTimer;

        for (var id in this.timeouts) {
          if (this.timeouts.hasOwnProperty(id)) {
            if (this.timeouts[id].callAt < from || this.timeouts[id].callAt > to) {
              continue;
            }

            if (smallest === null || this.timeouts[id].callAt < smallest) {
              originalTimer = this.timeouts[id];
              smallest = this.timeouts[id].callAt;

              timer = {
                func: this.timeouts[id].func,
                callAt: this.timeouts[id].callAt,
                interval: this.timeouts[id].interval,
                id: this.timeouts[id].id,
                invokeArgs: this.timeouts[id].invokeArgs
              };
            }
          }
        }

        return timer || null;
      },

      callTimer: function (timer) {
        if (typeof timer.interval == "number") {
          this.timeouts[timer.id].callAt += timer.interval;
        } else {
          delete this.timeouts[timer.id];
        }

        try {
          if (typeof timer.func == "function") {
            timer.func.apply(null, timer.invokeArgs);
          } else {
            eval(timer.func);
          }
        } catch (e) {
          var exception = e;
        }

        if (!this.timeouts[timer.id]) {
          if (exception) {
            throw exception;
          }
          return;
        }

        if (exception) {
          throw exception;
        }
      },

      reset: function reset() {
        this.timeouts = {};
      },

      Date: (function () {
        var NativeDate = Date;

        function ClockDate(year, month, date, hour, minute, second, ms) {
          // Defensive and verbose to avoid potential harm in passing
          // explicit undefined when user does not pass argument
          switch (arguments.length) {
            case 0:
              return new NativeDate(ClockDate.clock.now);
            case 1:
              return new NativeDate(year);
            case 2:
              return new NativeDate(year, month);
            case 3:
              return new NativeDate(year, month, date);
            case 4:
              return new NativeDate(year, month, date, hour);
            case 5:
              return new NativeDate(year, month, date, hour, minute);
            case 6:
              return new NativeDate(year, month, date, hour, minute, second);
            default:
              return new NativeDate(year, month, date, hour, minute, second, ms);
          }
        }

        return mirrorDateProperties(ClockDate, NativeDate);
      }())
    };

    function mirrorDateProperties(target, source) {
      if (source.now) {
        target.now = function now() {
          return target.clock.now;
        };
      } else {
        delete target.now;
      }

      if (source.toSource) {
        target.toSource = function toSource() {
          return source.toSource();
        };
      } else {
        delete target.toSource;
      }

      target.toString = function toString() {
        return source.toString();
      };

      target.prototype = source.prototype;
      target.parse = source.parse;
      target.UTC = source.UTC;
      target.prototype.toUTCString = source.prototype.toUTCString;

      for (var prop in source) {
        if (source.hasOwnProperty(prop)) {
          target[prop] = source[prop];
        }
      }

      return target;
    }

    var methods = ["Date", "setTimeout", "setInterval",
      "clearTimeout", "clearInterval"];

    if (typeof global.setImmediate !== "undefined") {
      methods.push("setImmediate");
    }

    if (typeof global.clearImmediate !== "undefined") {
      methods.push("clearImmediate");
    }

    function restore() {
      var method;

      for (var i = 0, l = this.methods.length; i < l; i++) {
        method = this.methods[i];

        if (global[method].hadOwnProperty) {
          global[method] = this["_" + method];
        } else {
          try {
            delete global[method];
          } catch (e) {}
        }
      }

      // Prevent multiple executions which will completely remove these props
      this.methods = [];
    }

    function stubGlobal(method, clock) {
      clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(global, method);
      clock["_" + method] = global[method];

      if (method == "Date") {
        var date = mirrorDateProperties(clock[method], global[method]);
        global[method] = date;
      } else {
        global[method] = function () {
          return clock[method].apply(clock, arguments);
        };

        for (var prop in clock[method]) {
          if (clock[method].hasOwnProperty(prop)) {
            global[method][prop] = clock[method][prop];
          }
        }
      }

      global[method].clock = clock;
    }

    sinon.useFakeTimers = function useFakeTimers(now) {
      var clock = sinon.clock.create(now);
      clock.restore = restore;
      clock.methods = Array.prototype.slice.call(arguments,
          typeof now == "number" ? 1 : 0);

      if (clock.methods.length === 0) {
        clock.methods = methods;
      }

      for (var i = 0, l = clock.methods.length; i < l; i++) {
        stubGlobal(clock.methods[i], clock);
      }

      return clock;
    };
  }(typeof global != "undefined" && typeof global !== "function" ? global : this));

  sinon.timers = {
    setTimeout: setTimeout,
    clearTimeout: clearTimeout,
    setImmediate: (typeof setImmediate !== "undefined" ? setImmediate : undefined),
    clearImmediate: (typeof clearImmediate !== "undefined" ? clearImmediate: undefined),
    setInterval: setInterval,
    clearInterval: clearInterval,
    Date: Date
  };

  if (typeof module !== 'undefined' && module.exports) {
    module.exports = sinon;
  }

  /*jslint eqeqeq: false, onevar: false*/
  /*global sinon, module, require, ActiveXObject, XMLHttpRequest, DOMParser*/
  /**
   * Minimal Event interface implementation
   *
   * Original implementation by Sven Fuchs: https://gist.github.com/995028
   * Modifications and tests by Christian Johansen.
   *
   * @author Sven Fuchs (svenfuchs@artweb-design.de)
   * @author Christian Johansen (christian@cjohansen.no)
   * @license BSD
   *
   * Copyright (c) 2011 Sven Fuchs, Christian Johansen
   */

  if (typeof sinon == "undefined") {
    this.sinon = {};
  }

  (function () {
    var push = [].push;

    sinon.Event = function Event(type, bubbles, cancelable, target) {
      this.initEvent(type, bubbles, cancelable, target);
    };

    sinon.Event.prototype = {
      initEvent: function(type, bubbles, cancelable, target) {
        this.type = type;
        this.bubbles = bubbles;
        this.cancelable = cancelable;
        this.target = target;
      },

      stopPropagation: function () {},

      preventDefault: function () {
        this.defaultPrevented = true;
      }
    };

    sinon.ProgressEvent = function ProgressEvent(type, progressEventRaw, target) {
      this.initEvent(type, false, false, target);
      this.loaded = progressEventRaw.loaded || null;
      this.total = progressEventRaw.total || null;
    };

    sinon.ProgressEvent.prototype = new sinon.Event();

    sinon.ProgressEvent.prototype.constructor =  sinon.ProgressEvent;

    sinon.CustomEvent = function CustomEvent(type, customData, target) {
      this.initEvent(type, false, false, target);
      this.detail = customData.detail || null;
    };

    sinon.CustomEvent.prototype = new sinon.Event();

    sinon.CustomEvent.prototype.constructor =  sinon.CustomEvent;

    sinon.EventTarget = {
      addEventListener: function addEventListener(event, listener) {
        this.eventListeners = this.eventListeners || {};
        this.eventListeners[event] = this.eventListeners[event] || [];
        push.call(this.eventListeners[event], listener);
      },

      removeEventListener: function removeEventListener(event, listener) {
        var listeners = this.eventListeners && this.eventListeners[event] || [];

        for (var i = 0, l = listeners.length; i < l; ++i) {
          if (listeners[i] == listener) {
            return listeners.splice(i, 1);
          }
        }
      },

      dispatchEvent: function dispatchEvent(event) {
        var type = event.type;
        var listeners = this.eventListeners && this.eventListeners[type] || [];

        for (var i = 0; i < listeners.length; i++) {
          if (typeof listeners[i] == "function") {
            listeners[i].call(this, event);
          } else {
            listeners[i].handleEvent(event);
          }
        }

        return !!event.defaultPrevented;
      }
    };
  }());

  /**
   * @depend ../../sinon.js
   * @depend event.js
   */
  /*jslint eqeqeq: false, onevar: false*/
  /*global sinon, module, require, ActiveXObject, XMLHttpRequest, DOMParser*/
  /**
   * Fake XMLHttpRequest object
   *
   * @author Christian Johansen (christian@cjohansen.no)
   * @license BSD
   *
   * Copyright (c) 2010-2013 Christian Johansen
   */

// wrapper for global
  (function(global) {
    if (typeof sinon === "undefined") {
      global.sinon = {};
    }

    var supportsProgress = typeof ProgressEvent !== "undefined";
    var supportsCustomEvent = typeof CustomEvent !== "undefined";
    sinon.xhr = { XMLHttpRequest: global.XMLHttpRequest };
    var xhr = sinon.xhr;
    xhr.GlobalXMLHttpRequest = global.XMLHttpRequest;
    xhr.GlobalActiveXObject = global.ActiveXObject;
    xhr.supportsActiveX = typeof xhr.GlobalActiveXObject != "undefined";
    xhr.supportsXHR = typeof xhr.GlobalXMLHttpRequest != "undefined";
    xhr.workingXHR = xhr.supportsXHR ? xhr.GlobalXMLHttpRequest : xhr.supportsActiveX
        ? function() { return new xhr.GlobalActiveXObject("MSXML2.XMLHTTP.3.0") } : false;
    xhr.supportsCORS = 'withCredentials' in (new sinon.xhr.GlobalXMLHttpRequest());

    /*jsl:ignore*/
    var unsafeHeaders = {
      "Accept-Charset": true,
      "Accept-Encoding": true,
      "Connection": true,
      "Content-Length": true,
      "Cookie": true,
      "Cookie2": true,
      "Content-Transfer-Encoding": true,
      "Date": true,
      "Expect": true,
      "Host": true,
      "Keep-Alive": true,
      "Referer": true,
      "TE": true,
      "Trailer": true,
      "Transfer-Encoding": true,
      "Upgrade": true,
      "User-Agent": true,
      "Via": true
    };
    /*jsl:end*/

    function FakeXMLHttpRequest() {
      this.readyState = FakeXMLHttpRequest.UNSENT;
      this.requestHeaders = {};
      this.requestBody = null;
      this.status = 0;
      this.statusText = "";
      this.upload = new UploadProgress();
      if (sinon.xhr.supportsCORS) {
        this.withCredentials = false;
      }


      var xhr = this;
      var events = ["loadstart", "load", "abort", "loadend"];

      function addEventListener(eventName) {
        xhr.addEventListener(eventName, function (event) {
          var listener = xhr["on" + eventName];

          if (listener && typeof listener == "function") {
            listener.call(this, event);
          }
        });
      }

      for (var i = events.length - 1; i >= 0; i--) {
        addEventListener(events[i]);
      }

      if (typeof FakeXMLHttpRequest.onCreate == "function") {
        FakeXMLHttpRequest.onCreate(this);
      }
    }

    // An upload object is created for each
    // FakeXMLHttpRequest and allows upload
    // events to be simulated using uploadProgress
    // and uploadError.
    function UploadProgress() {
      this.eventListeners = {
        "progress": [],
        "load": [],
        "abort": [],
        "error": []
      }
    }

    UploadProgress.prototype.addEventListener = function(event, listener) {
      this.eventListeners[event].push(listener);
    };

    UploadProgress.prototype.removeEventListener = function(event, listener) {
      var listeners = this.eventListeners[event] || [];

      for (var i = 0, l = listeners.length; i < l; ++i) {
        if (listeners[i] == listener) {
          return listeners.splice(i, 1);
        }
      }
    };

    UploadProgress.prototype.dispatchEvent = function(event) {
      var listeners = this.eventListeners[event.type] || [];

      for (var i = 0, listener; (listener = listeners[i]) != null; i++) {
        listener(event);
      }
    };

    function verifyState(xhr) {
      if (xhr.readyState !== FakeXMLHttpRequest.OPENED) {
        throw new Error("INVALID_STATE_ERR");
      }

      if (xhr.sendFlag) {
        throw new Error("INVALID_STATE_ERR");
      }
    }

    // filtering to enable a white-list version of Sinon FakeXhr,
    // where whitelisted requests are passed through to real XHR
    function each(collection, callback) {
      if (!collection) return;
      for (var i = 0, l = collection.length; i < l; i += 1) {
        callback(collection[i]);
      }
    }
    function some(collection, callback) {
      for (var index = 0; index < collection.length; index++) {
        if(callback(collection[index]) === true) return true;
      }
      return false;
    }
    // largest arity in XHR is 5 - XHR#open
    var apply = function(obj,method,args) {
      switch(args.length) {
        case 0: return obj[method]();
        case 1: return obj[method](args[0]);
        case 2: return obj[method](args[0],args[1]);
        case 3: return obj[method](args[0],args[1],args[2]);
        case 4: return obj[method](args[0],args[1],args[2],args[3]);
        case 5: return obj[method](args[0],args[1],args[2],args[3],args[4]);
      }
    };

    FakeXMLHttpRequest.filters = [];
    FakeXMLHttpRequest.addFilter = function(fn) {
      this.filters.push(fn)
    };
    var IE6Re = /MSIE 6/;
    FakeXMLHttpRequest.defake = function(fakeXhr,xhrArgs) {
      var xhr = new sinon.xhr.workingXHR();
      each(["open","setRequestHeader","send","abort","getResponseHeader",
        "getAllResponseHeaders","addEventListener","overrideMimeType","removeEventListener"],
          function(method) {
            fakeXhr[method] = function() {
              return apply(xhr,method,arguments);
            };
          });

      var copyAttrs = function(args) {
        each(args, function(attr) {
          try {
            fakeXhr[attr] = xhr[attr]
          } catch(e) {
            if(!IE6Re.test(navigator.userAgent)) throw e;
          }
        });
      };

      var stateChange = function() {
        fakeXhr.readyState = xhr.readyState;
        if(xhr.readyState >= FakeXMLHttpRequest.HEADERS_RECEIVED) {
          copyAttrs(["status","statusText"]);
        }
        if(xhr.readyState >= FakeXMLHttpRequest.LOADING) {
          copyAttrs(["responseText"]);
        }
        if(xhr.readyState === FakeXMLHttpRequest.DONE) {
          copyAttrs(["responseXML"]);
        }
        if(fakeXhr.onreadystatechange) fakeXhr.onreadystatechange.call(fakeXhr, { target: fakeXhr });
      };
      if(xhr.addEventListener) {
        for(var event in fakeXhr.eventListeners) {
          if(fakeXhr.eventListeners.hasOwnProperty(event)) {
            each(fakeXhr.eventListeners[event],function(handler) {
              xhr.addEventListener(event, handler);
            });
          }
        }
        xhr.addEventListener("readystatechange",stateChange);
      } else {
        xhr.onreadystatechange = stateChange;
      }
      apply(xhr,"open",xhrArgs);
    };
    FakeXMLHttpRequest.useFilters = false;

    function verifyRequestOpened(xhr) {
      if (xhr.readyState != FakeXMLHttpRequest.OPENED) {
        throw new Error("INVALID_STATE_ERR - " + xhr.readyState);
      }
    }

    function verifyRequestSent(xhr) {
      if (xhr.readyState == FakeXMLHttpRequest.DONE) {
        throw new Error("Request done");
      }
    }

    function verifyHeadersReceived(xhr) {
      if (xhr.async && xhr.readyState != FakeXMLHttpRequest.HEADERS_RECEIVED) {
        throw new Error("No headers received");
      }
    }

    function verifyResponseBodyType(body) {
      if (typeof body != "string") {
        var error = new Error("Attempted to respond to fake XMLHttpRequest with " +
            body + ", which is not a string.");
        error.name = "InvalidBodyException";
        throw error;
      }
    }

    sinon.extend(FakeXMLHttpRequest.prototype, sinon.EventTarget, {
      async: true,

      open: function open(method, url, async, username, password) {
        this.method = method;
        this.url = url;
        this.async = typeof async == "boolean" ? async : true;
        this.username = username;
        this.password = password;
        this.responseText = null;
        this.responseXML = null;
        this.requestHeaders = {};
        this.sendFlag = false;
        if(sinon.FakeXMLHttpRequest.useFilters === true) {
          var xhrArgs = arguments;
          var defake = some(FakeXMLHttpRequest.filters,function(filter) {
            return filter.apply(this,xhrArgs)
          });
          if (defake) {
            return sinon.FakeXMLHttpRequest.defake(this,arguments);
          }
        }
        this.readyStateChange(FakeXMLHttpRequest.OPENED);
      },

      readyStateChange: function readyStateChange(state) {
        this.readyState = state;

        if (typeof this.onreadystatechange == "function") {
          try {
            this.onreadystatechange();
          } catch (e) {
            sinon.logError("Fake XHR onreadystatechange handler", e);
          }
        }

        this.dispatchEvent(new sinon.Event("readystatechange"));

        switch (this.readyState) {
          case FakeXMLHttpRequest.DONE:
            this.dispatchEvent(new sinon.Event("load", false, false, this));
            this.dispatchEvent(new sinon.Event("loadend", false, false, this));
            this.upload.dispatchEvent(new sinon.Event("load", false, false, this));
            if (supportsProgress) {
              this.upload.dispatchEvent(new sinon.ProgressEvent('progress', {loaded: 100, total: 100}));
            }
            break;
        }
      },

      setRequestHeader: function setRequestHeader(header, value) {
        verifyState(this);

        if (unsafeHeaders[header] || /^(Sec-|Proxy-)/.test(header)) {
          throw new Error("Refused to set unsafe header \"" + header + "\"");
        }

        if (this.requestHeaders[header]) {
          this.requestHeaders[header] += "," + value;
        } else {
          this.requestHeaders[header] = value;
        }
      },

      // Helps testing
      setResponseHeaders: function setResponseHeaders(headers) {
        verifyRequestOpened(this);
        this.responseHeaders = {};

        for (var header in headers) {
          if (headers.hasOwnProperty(header)) {
            this.responseHeaders[header] = headers[header];
          }
        }

        if (this.async) {
          this.readyStateChange(FakeXMLHttpRequest.HEADERS_RECEIVED);
        } else {
          this.readyState = FakeXMLHttpRequest.HEADERS_RECEIVED;
        }
      },

      // Currently treats ALL data as a DOMString (i.e. no Document)
      send: function send(data) {
        verifyState(this);

        if (!/^(get|head)$/i.test(this.method)) {
          if (this.requestHeaders["Content-Type"]) {
            var value = this.requestHeaders["Content-Type"].split(";");
            this.requestHeaders["Content-Type"] = value[0] + ";charset=utf-8";
          } else {
            this.requestHeaders["Content-Type"] = "text/plain;charset=utf-8";
          }

          this.requestBody = data;
        }

        this.errorFlag = false;
        this.sendFlag = this.async;
        this.readyStateChange(FakeXMLHttpRequest.OPENED);

        if (typeof this.onSend == "function") {
          this.onSend(this);
        }

        this.dispatchEvent(new sinon.Event("loadstart", false, false, this));
      },

      abort: function abort() {
        this.aborted = true;
        this.responseText = null;
        this.errorFlag = true;
        this.requestHeaders = {};

        if (this.readyState > sinon.FakeXMLHttpRequest.UNSENT && this.sendFlag) {
          this.readyStateChange(sinon.FakeXMLHttpRequest.DONE);
          this.sendFlag = false;
        }

        this.readyState = sinon.FakeXMLHttpRequest.UNSENT;

        this.dispatchEvent(new sinon.Event("abort", false, false, this));

        this.upload.dispatchEvent(new sinon.Event("abort", false, false, this));

        if (typeof this.onerror === "function") {
          this.onerror();
        }
      },

      getResponseHeader: function getResponseHeader(header) {
        if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {
          return null;
        }

        if (/^Set-Cookie2?$/i.test(header)) {
          return null;
        }

        header = header.toLowerCase();

        for (var h in this.responseHeaders) {
          if (h.toLowerCase() == header) {
            return this.responseHeaders[h];
          }
        }

        return null;
      },

      getAllResponseHeaders: function getAllResponseHeaders() {
        if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {
          return "";
        }

        var headers = "";

        for (var header in this.responseHeaders) {
          if (this.responseHeaders.hasOwnProperty(header) &&
              !/^Set-Cookie2?$/i.test(header)) {
            headers += header + ": " + this.responseHeaders[header] + "\r\n";
          }
        }

        return headers;
      },

      setResponseBody: function setResponseBody(body) {
        verifyRequestSent(this);
        verifyHeadersReceived(this);
        verifyResponseBodyType(body);

        var chunkSize = this.chunkSize || 10;
        var index = 0;
        this.responseText = "";

        do {
          if (this.async) {
            this.readyStateChange(FakeXMLHttpRequest.LOADING);
          }

          this.responseText += body.substring(index, index + chunkSize);
          index += chunkSize;
        } while (index < body.length);

        var type = this.getResponseHeader("Content-Type");

        if (this.responseText &&
            (!type || /(text\/xml)|(application\/xml)|(\+xml)/.test(type))) {
          try {
            this.responseXML = FakeXMLHttpRequest.parseXML(this.responseText);
          } catch (e) {
            // Unable to parse XML - no biggie
          }
        }

        if (this.async) {
          this.readyStateChange(FakeXMLHttpRequest.DONE);
        } else {
          this.readyState = FakeXMLHttpRequest.DONE;
        }
      },

      respond: function respond(status, headers, body) {
        this.status = typeof status == "number" ? status : 200;
        this.statusText = FakeXMLHttpRequest.statusCodes[this.status];
        this.setResponseHeaders(headers || {});
        this.setResponseBody(body || "");
      },

      uploadProgress: function uploadProgress(progressEventRaw) {
        if (supportsProgress) {
          this.upload.dispatchEvent(new sinon.ProgressEvent("progress", progressEventRaw));
        }
      },

      uploadError: function uploadError(error) {
        if (supportsCustomEvent) {
          this.upload.dispatchEvent(new sinon.CustomEvent("error", {"detail": error}));
        }
      }
    });

    sinon.extend(FakeXMLHttpRequest, {
      UNSENT: 0,
      OPENED: 1,
      HEADERS_RECEIVED: 2,
      LOADING: 3,
      DONE: 4
    });

    // Borrowed from JSpec
    FakeXMLHttpRequest.parseXML = function parseXML(text) {
      var xmlDoc;

      if (typeof DOMParser != "undefined") {
        var parser = new DOMParser();
        xmlDoc = parser.parseFromString(text, "text/xml");
      } else {
        xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
        xmlDoc.async = "false";
        xmlDoc.loadXML(text);
      }

      return xmlDoc;
    };

    FakeXMLHttpRequest.statusCodes = {
      100: "Continue",
      101: "Switching Protocols",
      200: "OK",
      201: "Created",
      202: "Accepted",
      203: "Non-Authoritative Information",
      204: "No Content",
      205: "Reset Content",
      206: "Partial Content",
      300: "Multiple Choice",
      301: "Moved Permanently",
      302: "Found",
      303: "See Other",
      304: "Not Modified",
      305: "Use Proxy",
      307: "Temporary Redirect",
      400: "Bad Request",
      401: "Unauthorized",
      402: "Payment Required",
      403: "Forbidden",
      404: "Not Found",
      405: "Method Not Allowed",
      406: "Not Acceptable",
      407: "Proxy Authentication Required",
      408: "Request Timeout",
      409: "Conflict",
      410: "Gone",
      411: "Length Required",
      412: "Precondition Failed",
      413: "Request Entity Too Large",
      414: "Request-URI Too Long",
      415: "Unsupported Media Type",
      416: "Requested Range Not Satisfiable",
      417: "Expectation Failed",
      422: "Unprocessable Entity",
      500: "Internal Server Error",
      501: "Not Implemented",
      502: "Bad Gateway",
      503: "Service Unavailable",
      504: "Gateway Timeout",
      505: "HTTP Version Not Supported"
    };

    sinon.useFakeXMLHttpRequest = function () {
      sinon.FakeXMLHttpRequest.restore = function restore(keepOnCreate) {
        if (xhr.supportsXHR) {
          global.XMLHttpRequest = xhr.GlobalXMLHttpRequest;
        }

        if (xhr.supportsActiveX) {
          global.ActiveXObject = xhr.GlobalActiveXObject;
        }

        delete sinon.FakeXMLHttpRequest.restore;

        if (keepOnCreate !== true) {
          delete sinon.FakeXMLHttpRequest.onCreate;
        }
      };
      if (xhr.supportsXHR) {
        global.XMLHttpRequest = sinon.FakeXMLHttpRequest;
      }

      if (xhr.supportsActiveX) {
        global.ActiveXObject = function ActiveXObject(objId) {
          if (objId == "Microsoft.XMLHTTP" || /^Msxml2\.XMLHTTP/i.test(objId)) {

            return new sinon.FakeXMLHttpRequest();
          }

          return new xhr.GlobalActiveXObject(objId);
        };
      }

      return sinon.FakeXMLHttpRequest;
    };

    sinon.FakeXMLHttpRequest = FakeXMLHttpRequest;

  })(typeof global === "object" ? global : this);

  if (typeof module !== 'undefined' && module.exports) {
    module.exports = sinon;
  }

  /**
   * @depend fake_xml_http_request.js
   */
  /*jslint eqeqeq: false, onevar: false, regexp: false, plusplus: false*/
  /*global module, require, window*/
  /**
   * The Sinon "server" mimics a web server that receives requests from
   * sinon.FakeXMLHttpRequest and provides an API to respond to those requests,
   * both synchronously and asynchronously. To respond synchronuously, canned
   * answers have to be provided upfront.
   *
   * @author Christian Johansen (christian@cjohansen.no)
   * @license BSD
   *
   * Copyright (c) 2010-2013 Christian Johansen
   */

  if (typeof sinon == "undefined") {
    var sinon = {};
  }

  sinon.fakeServer = (function () {
    var push = [].push;
    function F() {}

    function create(proto) {
      F.prototype = proto;
      return new F();
    }

    function responseArray(handler) {
      var response = handler;

      if (Object.prototype.toString.call(handler) != "[object Array]") {
        response = [200, {}, handler];
      }

      if (typeof response[2] != "string") {
        throw new TypeError("Fake server response body should be string, but was " +
            typeof response[2]);
      }

      return response;
    }

    var wloc = typeof window !== "undefined" ? window.location : {};
    var rCurrLoc = new RegExp("^" + wloc.protocol + "//" + wloc.host);

    function matchOne(response, reqMethod, reqUrl) {
      var rmeth = response.method;
      var matchMethod = !rmeth || rmeth.toLowerCase() == reqMethod.toLowerCase();
      var url = response.url;
      var matchUrl = !url || url == reqUrl || (typeof url.test == "function" && url.test(reqUrl));

      return matchMethod && matchUrl;
    }

    function match(response, request) {
      var requestUrl = request.url;

      if (!/^https?:\/\//.test(requestUrl) || rCurrLoc.test(requestUrl)) {
        requestUrl = requestUrl.replace(rCurrLoc, "");
      }

      if (matchOne(response, this.getHTTPMethod(request), requestUrl)) {
        if (typeof response.response == "function") {
          var ru = response.url;
          var args = [request].concat(ru && typeof ru.exec == "function" ? ru.exec(requestUrl).slice(1) : []);
          return response.response.apply(response, args);
        }

        return true;
      }

      return false;
    }

    function log(response, request) {
      var str;

      str =  "Request:\n"  + sinon.format(request)  + "\n\n";
      str += "Response:\n" + sinon.format(response) + "\n\n";

      sinon.log(str);
    }

    return {
      create: function () {
        var server = create(this);
        this.xhr = sinon.useFakeXMLHttpRequest();
        server.requests = [];

        this.xhr.onCreate = function (xhrObj) {
          server.addRequest(xhrObj);
        };

        return server;
      },

      addRequest: function addRequest(xhrObj) {
        var server = this;
        push.call(this.requests, xhrObj);

        xhrObj.onSend = function () {
          server.handleRequest(this);

          if (server.autoRespond && !server.responding) {
            setTimeout(function () {
              server.responding = false;
              server.respond();
            }, server.autoRespondAfter || 10);

            server.responding = true;
          }
        };
      },

      getHTTPMethod: function getHTTPMethod(request) {
        if (this.fakeHTTPMethods && /post/i.test(request.method)) {
          var matches = (request.requestBody || "").match(/_method=([^\b;]+)/);
          return !!matches ? matches[1] : request.method;
        }

        return request.method;
      },

      handleRequest: function handleRequest(xhr) {
        if (xhr.async) {
          if (!this.queue) {
            this.queue = [];
          }

          push.call(this.queue, xhr);
        } else {
          this.processRequest(xhr);
        }
      },

      respondWith: function respondWith(method, url, body) {
        if (arguments.length == 1 && typeof method != "function") {
          this.response = responseArray(method);
          return;
        }

        if (!this.responses) { this.responses = []; }

        if (arguments.length == 1) {
          body = method;
          url = method = null;
        }

        if (arguments.length == 2) {
          body = url;
          url = method;
          method = null;
        }

        push.call(this.responses, {
          method: method,
          url: url,
          response: typeof body == "function" ? body : responseArray(body)
        });
      },

      respond: function respond() {
        if (arguments.length > 0) this.respondWith.apply(this, arguments);
        var queue = this.queue || [];
        var requests = queue.splice(0);
        var request;

        while(request = requests.shift()) {
          this.processRequest(request);
        }
      },

      processRequest: function processRequest(request) {
        try {
          if (request.aborted) {
            return;
          }

          var response = this.response || [404, {}, ""];

          if (this.responses) {
            for (var l = this.responses.length, i = l - 1; i >= 0; i--) {
              if (match.call(this, this.responses[i], request)) {
                response = this.responses[i].response;
                break;
              }
            }
          }

          if (request.readyState != 4) {
            log(response, request);

            request.respond(response[0], response[1], response[2]);
          }
        } catch (e) {
          sinon.logError("Fake server request processing", e);
        }
      },

      restore: function restore() {
        return this.xhr.restore && this.xhr.restore.apply(this.xhr, arguments);
      }
    };
  }());

  if (typeof module !== 'undefined' && module.exports) {
    module.exports = sinon;
  }

  /**
   * @depend fake_server.js
   * @depend fake_timers.js
   */
  /*jslint browser: true, eqeqeq: false, onevar: false*/
  /*global sinon*/
  /**
   * Add-on for sinon.fakeServer that automatically handles a fake timer along with
   * the FakeXMLHttpRequest. The direct inspiration for this add-on is jQuery
   * 1.3.x, which does not use xhr object's onreadystatehandler at all - instead,
   * it polls the object for completion with setInterval. Dispite the direct
   * motivation, there is nothing jQuery-specific in this file, so it can be used
   * in any environment where the ajax implementation depends on setInterval or
   * setTimeout.
   *
   * @author Christian Johansen (christian@cjohansen.no)
   * @license BSD
   *
   * Copyright (c) 2010-2013 Christian Johansen
   */

  (function () {
    function Server() {}
    Server.prototype = sinon.fakeServer;

    sinon.fakeServerWithClock = new Server();

    sinon.fakeServerWithClock.addRequest = function addRequest(xhr) {
      if (xhr.async) {
        if (typeof setTimeout.clock == "object") {
          this.clock = setTimeout.clock;
        } else {
          this.clock = sinon.useFakeTimers();
          this.resetClock = true;
        }

        if (!this.longestTimeout) {
          var clockSetTimeout = this.clock.setTimeout;
          var clockSetInterval = this.clock.setInterval;
          var server = this;

          this.clock.setTimeout = function (fn, timeout) {
            server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);

            return clockSetTimeout.apply(this, arguments);
          };

          this.clock.setInterval = function (fn, timeout) {
            server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);

            return clockSetInterval.apply(this, arguments);
          };
        }
      }

      return sinon.fakeServer.addRequest.call(this, xhr);
    };

    sinon.fakeServerWithClock.respond = function respond() {
      var returnVal = sinon.fakeServer.respond.apply(this, arguments);

      if (this.clock) {
        this.clock.tick(this.longestTimeout || 0);
        this.longestTimeout = 0;

        if (this.resetClock) {
          this.clock.restore();
          this.resetClock = false;
        }
      }

      return returnVal;
    };

    sinon.fakeServerWithClock.restore = function restore() {
      if (this.clock) {
        this.clock.restore();
      }

      return sinon.fakeServer.restore.apply(this, arguments);
    };
  }());

  /**
   * @depend ../sinon.js
   * @depend collection.js
   * @depend util/fake_timers.js
   * @depend util/fake_server_with_clock.js
   */
  /*jslint eqeqeq: false, onevar: false, plusplus: false*/
  /*global require, module*/
  /**
   * Manages fake collections as well as fake utilities such as Sinon's
   * timers and fake XHR implementation in one convenient object.
   *
   * @author Christian Johansen (christian@cjohansen.no)
   * @license BSD
   *
   * Copyright (c) 2010-2013 Christian Johansen
   */

  if (typeof module !== 'undefined' && module.exports) {
    var sinon = require("../sinon");
    sinon.extend(sinon, require("./util/fake_timers"));
  }

  (function () {
    var push = [].push;

    function exposeValue(sandbox, config, key, value) {
      if (!value) {
        return;
      }

      if (config.injectInto && !(key in config.injectInto)) {
        config.injectInto[key] = value;
        sandbox.injectedKeys.push(key);
      } else {
        push.call(sandbox.args, value);
      }
    }

    function prepareSandboxFromConfig(config) {
      var sandbox = sinon.create(sinon.sandbox);

      if (config.useFakeServer) {
        if (typeof config.useFakeServer == "object") {
          sandbox.serverPrototype = config.useFakeServer;
        }

        sandbox.useFakeServer();
      }

      if (config.useFakeTimers) {
        if (typeof config.useFakeTimers == "object") {
          sandbox.useFakeTimers.apply(sandbox, config.useFakeTimers);
        } else {
          sandbox.useFakeTimers();
        }
      }

      return sandbox;
    }

    sinon.sandbox = sinon.extend(sinon.create(sinon.collection), {
      useFakeTimers: function useFakeTimers() {
        this.clock = sinon.useFakeTimers.apply(sinon, arguments);

        return this.add(this.clock);
      },

      serverPrototype: sinon.fakeServer,

      useFakeServer: function useFakeServer() {
        var proto = this.serverPrototype || sinon.fakeServer;

        if (!proto || !proto.create) {
          return null;
        }

        this.server = proto.create();
        return this.add(this.server);
      },

      inject: function (obj) {
        sinon.collection.inject.call(this, obj);

        if (this.clock) {
          obj.clock = this.clock;
        }

        if (this.server) {
          obj.server = this.server;
          obj.requests = this.server.requests;
        }

        return obj;
      },

      restore: function () {
        sinon.collection.restore.apply(this, arguments);
        this.restoreContext();
      },

      restoreContext: function () {
        if (this.injectedKeys) {
          for (var i = 0, j = this.injectedKeys.length; i < j; i++) {
            delete this.injectInto[this.injectedKeys[i]];
          }
          this.injectedKeys = [];
        }
      },

      create: function (config) {
        if (!config) {
          return sinon.create(sinon.sandbox);
        }

        var sandbox = prepareSandboxFromConfig(config);
        sandbox.args = sandbox.args || [];
        sandbox.injectedKeys = [];
        sandbox.injectInto = config.injectInto;
        var prop, value, exposed = sandbox.inject({});

        if (config.properties) {
          for (var i = 0, l = config.properties.length; i < l; i++) {
            prop = config.properties[i];
            value = exposed[prop] || prop == "sandbox" && sandbox;
            exposeValue(sandbox, config, prop, value);
          }
        } else {
          exposeValue(sandbox, config, "sandbox", value);
        }

        return sandbox;
      }
    });

    sinon.sandbox.useFakeXMLHttpRequest = sinon.sandbox.useFakeServer;

    if (typeof module !== 'undefined' && module.exports) {
      module.exports = sinon.sandbox;
    }
  }());

  /**
   * @depend ../sinon.js
   * @depend stub.js
   * @depend mock.js
   * @depend sandbox.js
   */
  /*jslint eqeqeq: false, onevar: false, forin: true, plusplus: false*/
  /*global module, require, sinon*/
  /**
   * Test function, sandboxes fakes
   *
   * @author Christian Johansen (christian@cjohansen.no)
   * @license BSD
   *
   * Copyright (c) 2010-2013 Christian Johansen
   */

  (function (sinon) {
    var commonJSModule = typeof module !== 'undefined' && module.exports;

    if (!sinon && commonJSModule) {
      sinon = require("../sinon");
    }

    if (!sinon) {
      return;
    }

    function test(callback) {
      var type = typeof callback;

      if (type != "function") {
        throw new TypeError("sinon.test needs to wrap a test function, got " + type);
      }

      return function () {
        var config = sinon.getConfig(sinon.config);
        config.injectInto = config.injectIntoThis && this || config.injectInto;
        var sandbox = sinon.sandbox.create(config);
        var exception, result;
        var args = Array.prototype.slice.call(arguments).concat(sandbox.args);

        try {
          result = callback.apply(this, args);
        } catch (e) {
          exception = e;
        }

        if (typeof exception !== "undefined") {
          sandbox.restore();
          throw exception;
        }
        else {
          sandbox.verifyAndRestore();
        }

        return result;
      };
    }

    test.config = {
      injectIntoThis: true,
      injectInto: null,
      properties: ["spy", "stub", "mock", "clock", "server", "requests"],
      useFakeTimers: true,
      useFakeServer: true
    };

    if (commonJSModule) {
      module.exports = test;
    } else {
      sinon.test = test;
    }
  }(typeof sinon == "object" && sinon || null));

  /**
   * @depend ../sinon.js
   * @depend test.js
   */
  /*jslint eqeqeq: false, onevar: false, eqeqeq: false*/
  /*global module, require, sinon*/
  /**
   * Test case, sandboxes all test functions
   *
   * @author Christian Johansen (christian@cjohansen.no)
   * @license BSD
   *
   * Copyright (c) 2010-2013 Christian Johansen
   */

  (function (sinon) {
    var commonJSModule = typeof module !== 'undefined' && module.exports;

    if (!sinon && commonJSModule) {
      sinon = require("../sinon");
    }

    if (!sinon || !Object.prototype.hasOwnProperty) {
      return;
    }

    function createTest(property, setUp, tearDown) {
      return function () {
        if (setUp) {
          setUp.apply(this, arguments);
        }

        var exception, result;

        try {
          result = property.apply(this, arguments);
        } catch (e) {
          exception = e;
        }

        if (tearDown) {
          tearDown.apply(this, arguments);
        }

        if (exception) {
          throw exception;
        }

        return result;
      };
    }

    function testCase(tests, prefix) {
      /*jsl:ignore*/
      if (!tests || typeof tests != "object") {
        throw new TypeError("sinon.testCase needs an object with test functions");
      }
      /*jsl:end*/

      prefix = prefix || "test";
      var rPrefix = new RegExp("^" + prefix);
      var methods = {}, testName, property, method;
      var setUp = tests.setUp;
      var tearDown = tests.tearDown;

      for (testName in tests) {
        if (tests.hasOwnProperty(testName)) {
          property = tests[testName];

          if (/^(setUp|tearDown)$/.test(testName)) {
            continue;
          }

          if (typeof property == "function" && rPrefix.test(testName)) {
            method = property;

            if (setUp || tearDown) {
              method = createTest(property, setUp, tearDown);
            }

            methods[testName] = sinon.test(method);
          } else {
            methods[testName] = tests[testName];
          }
        }
      }

      return methods;
    }

    if (commonJSModule) {
      module.exports = testCase;
    } else {
      sinon.testCase = testCase;
    }
  }(typeof sinon == "object" && sinon || null));

  /**
   * @depend ../sinon.js
   * @depend stub.js
   */
  /*jslint eqeqeq: false, onevar: false, nomen: false, plusplus: false*/
  /*global module, require, sinon*/
  /**
   * Assertions matching the test spy retrieval interface.
   *
   * @author Christian Johansen (christian@cjohansen.no)
   * @license BSD
   *
   * Copyright (c) 2010-2013 Christian Johansen
   */

  (function (sinon, global) {
    var commonJSModule = typeof module !== "undefined" && module.exports;
    var slice = Array.prototype.slice;
    var assert;

    if (!sinon && commonJSModule) {
      sinon = require("../sinon");
    }

    if (!sinon) {
      return;
    }

    function verifyIsStub() {
      var method;

      for (var i = 0, l = arguments.length; i < l; ++i) {
        method = arguments[i];

        if (!method) {
          assert.fail("fake is not a spy");
        }

        if (typeof method != "function") {
          assert.fail(method + " is not a function");
        }

        if (typeof method.getCall != "function") {
          assert.fail(method + " is not stubbed");
        }
      }
    }

    function failAssertion(object, msg) {
      object = object || global;
      var failMethod = object.fail || assert.fail;
      failMethod.call(object, msg);
    }

    function mirrorPropAsAssertion(name, method, message) {
      if (arguments.length == 2) {
        message = method;
        method = name;
      }

      assert[name] = function (fake) {
        verifyIsStub(fake);

        var args = slice.call(arguments, 1);
        var failed = false;

        if (typeof method == "function") {
          failed = !method(fake);
        } else {
          failed = typeof fake[method] == "function" ?
              !fake[method].apply(fake, args) : !fake[method];
        }

        if (failed) {
          failAssertion(this, fake.printf.apply(fake, [message].concat(args)));
        } else {
          assert.pass(name);
        }
      };
    }

    function exposedName(prefix, prop) {
      return !prefix || /^fail/.test(prop) ? prop :
          prefix + prop.slice(0, 1).toUpperCase() + prop.slice(1);
    }

    assert = {
      failException: "AssertError",

      fail: function fail(message) {
        var error = new Error(message);
        error.name = this.failException || assert.failException;

        throw error;
      },

      pass: function pass(assertion) {},

      callOrder: function assertCallOrder() {
        verifyIsStub.apply(null, arguments);
        var expected = "", actual = "";

        if (!sinon.calledInOrder(arguments)) {
          try {
            expected = [].join.call(arguments, ", ");
            var calls = slice.call(arguments);
            var i = calls.length;
            while (i) {
              if (!calls[--i].called) {
                calls.splice(i, 1);
              }
            }
            actual = sinon.orderByFirstCall(calls).join(", ");
          } catch (e) {
            // If this fails, we'll just fall back to the blank string
          }

          failAssertion(this, "expected " + expected + " to be " +
              "called in order but were called as " + actual);
        } else {
          assert.pass("callOrder");
        }
      },

      callCount: function assertCallCount(method, count) {
        verifyIsStub(method);

        if (method.callCount != count) {
          var msg = "expected %n to be called " + sinon.timesInWords(count) +
              " but was called %c%C";
          failAssertion(this, method.printf(msg));
        } else {
          assert.pass("callCount");
        }
      },

      expose: function expose(target, options) {
        if (!target) {
          throw new TypeError("target is null or undefined");
        }

        var o = options || {};
        var prefix = typeof o.prefix == "undefined" && "assert" || o.prefix;
        var includeFail = typeof o.includeFail == "undefined" || !!o.includeFail;

        for (var method in this) {
          if (method != "export" && (includeFail || !/^(fail)/.test(method))) {
            target[exposedName(prefix, method)] = this[method];
          }
        }

        return target;
      },

      match: function match(actual, expectation) {
        var matcher = sinon.match(expectation);
        if (matcher.test(actual)) {
          assert.pass("match");
        } else {
          var formatted = [
            "expected value to match",
            "    expected = " + sinon.format(expectation),
            "    actual = " + sinon.format(actual)
          ]
          failAssertion(this, formatted.join("\n"));
        }
      }
    };

    mirrorPropAsAssertion("called", "expected %n to have been called at least once but was never called");
    mirrorPropAsAssertion("notCalled", function (spy) { return !spy.called; },
        "expected %n to not have been called but was called %c%C");
    mirrorPropAsAssertion("calledOnce", "expected %n to be called once but was called %c%C");
    mirrorPropAsAssertion("calledTwice", "expected %n to be called twice but was called %c%C");
    mirrorPropAsAssertion("calledThrice", "expected %n to be called thrice but was called %c%C");
    mirrorPropAsAssertion("calledOn", "expected %n to be called with %1 as this but was called with %t");
    mirrorPropAsAssertion("alwaysCalledOn", "expected %n to always be called with %1 as this but was called with %t");
    mirrorPropAsAssertion("calledWithNew", "expected %n to be called with new");
    mirrorPropAsAssertion("alwaysCalledWithNew", "expected %n to always be called with new");
    mirrorPropAsAssertion("calledWith", "expected %n to be called with arguments %*%C");
    mirrorPropAsAssertion("calledWithMatch", "expected %n to be called with match %*%C");
    mirrorPropAsAssertion("alwaysCalledWith", "expected %n to always be called with arguments %*%C");
    mirrorPropAsAssertion("alwaysCalledWithMatch", "expected %n to always be called with match %*%C");
    mirrorPropAsAssertion("calledWithExactly", "expected %n to be called with exact arguments %*%C");
    mirrorPropAsAssertion("alwaysCalledWithExactly", "expected %n to always be called with exact arguments %*%C");
    mirrorPropAsAssertion("neverCalledWith", "expected %n to never be called with arguments %*%C");
    mirrorPropAsAssertion("neverCalledWithMatch", "expected %n to never be called with match %*%C");
    mirrorPropAsAssertion("threw", "%n did not throw exception%C");
    mirrorPropAsAssertion("alwaysThrew", "%n did not always throw exception%C");

    if (commonJSModule) {
      module.exports = assert;
    } else {
      sinon.assert = assert;
    }
  }(typeof sinon == "object" && sinon || null, typeof window != "undefined" ? window : (typeof self != "undefined") ? self : global));

  return sinon;}.call(typeof window != 'undefined' && window || {}));
(function (sinonChai) {
  "use strict";

  // Module systems magic dance.

  if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
    // NodeJS
    module.exports = sinonChai;
  } else if (typeof define === "function" && define.amd) {
    // AMD
    define(function () {
      return sinonChai;
    });
  } else {
    // Other environment (usually <script> tag): plug in to global chai instance directly.
    chai.use(sinonChai);
  }
}(function sinonChai(chai, utils) {
  "use strict";

  var slice = Array.prototype.slice;

  function isSpy(putativeSpy) {
    return typeof putativeSpy === "function" &&
        typeof putativeSpy.getCall === "function" &&
        typeof putativeSpy.calledWithExactly === "function";
  }

  function timesInWords(count) {
    return count === 1 ? "once" :
        count === 2 ? "twice" :
            count === 3 ? "thrice" :
                (count || 0) + " times";
  }

  function isCall(putativeCall) {
    return putativeCall && isSpy(putativeCall.proxy);
  }

  function assertCanWorkWith(assertion) {
    if (!isSpy(assertion._obj) && !isCall(assertion._obj)) {
      throw new TypeError(utils.inspect(assertion._obj) + " is not a spy or a call to a spy!");
    }
  }

  function getMessages(spy, action, nonNegatedSuffix, always, args) {
    var verbPhrase = always ? "always have " : "have ";
    nonNegatedSuffix = nonNegatedSuffix || "";
    if (isSpy(spy.proxy)) {
      spy = spy.proxy;
    }

    function printfArray(array) {
      return spy.printf.apply(spy, array);
    }

    return {
      affirmative: printfArray(["expected %n to " + verbPhrase + action + nonNegatedSuffix].concat(args)),
      negative: printfArray(["expected %n to not " + verbPhrase + action].concat(args))
    };
  }

  function sinonProperty(name, action, nonNegatedSuffix) {
    utils.addProperty(chai.Assertion.prototype, name, function () {
      assertCanWorkWith(this);

      var messages = getMessages(this._obj, action, nonNegatedSuffix, false);
      this.assert(this._obj[name], messages.affirmative, messages.negative);
    });
  }

  function sinonPropertyAsBooleanMethod(name, action, nonNegatedSuffix) {
    utils.addMethod(chai.Assertion.prototype, name, function (arg) {
      assertCanWorkWith(this);

      var messages = getMessages(this._obj, action, nonNegatedSuffix, false, [timesInWords(arg)]);
      this.assert(this._obj[name] === arg, messages.affirmative, messages.negative);
    });
  }

  function createSinonMethodHandler(sinonName, action, nonNegatedSuffix) {
    return function () {
      assertCanWorkWith(this);

      var alwaysSinonMethod = "always" + sinonName[0].toUpperCase() + sinonName.substring(1);
      var shouldBeAlways = utils.flag(this, "always") && typeof this._obj[alwaysSinonMethod] === "function";
      var sinonMethod = shouldBeAlways ? alwaysSinonMethod : sinonName;

      var messages = getMessages(this._obj, action, nonNegatedSuffix, shouldBeAlways, slice.call(arguments));
      this.assert(this._obj[sinonMethod].apply(this._obj, arguments), messages.affirmative, messages.negative);
    };
  }

  function sinonMethodAsProperty(name, action, nonNegatedSuffix) {
    var handler = createSinonMethodHandler(name, action, nonNegatedSuffix);
    utils.addProperty(chai.Assertion.prototype, name, handler);
  }

  function exceptionalSinonMethod(chaiName, sinonName, action, nonNegatedSuffix) {
    var handler = createSinonMethodHandler(sinonName, action, nonNegatedSuffix);
    utils.addMethod(chai.Assertion.prototype, chaiName, handler);
  }

  function sinonMethod(name, action, nonNegatedSuffix) {
    exceptionalSinonMethod(name, name, action, nonNegatedSuffix);
  }

  utils.addProperty(chai.Assertion.prototype, "always", function () {
    utils.flag(this, "always", true);
  });

  sinonProperty("called", "been called", " at least once, but it was never called");
  sinonPropertyAsBooleanMethod("callCount", "been called exactly %1", ", but it was called %c%C");
  sinonProperty("calledOnce", "been called exactly once", ", but it was called %c%C");
  sinonProperty("calledTwice", "been called exactly twice", ", but it was called %c%C");
  sinonProperty("calledThrice", "been called exactly thrice", ", but it was called %c%C");
  sinonMethodAsProperty("calledWithNew", "been called with new");
  sinonMethod("calledBefore", "been called before %1");
  sinonMethod("calledAfter", "been called after %1");
  sinonMethod("calledOn", "been called with %1 as this", ", but it was called with %t instead");
  sinonMethod("calledWith", "been called with arguments %*", "%C");
  sinonMethod("calledWithExactly", "been called with exact arguments %*", "%C");
  sinonMethod("calledWithMatch", "been called with arguments matching %*", "%C");
  sinonMethod("returned", "returned %1");
  exceptionalSinonMethod("thrown", "threw", "thrown %1");
}));
// Teaspoon includes some support files, but you can use anything from your own support path too.
// require support/expect
// require support/sinon
// require support/chai
// require support/your-support-file
//
// PhantomJS (Teaspoons default driver) doesn't have support for Function.prototype.bind, which has caused confusion.
// Use this polyfill to avoid the confusion.

//
// Deferring execution
// If you're using CommonJS, RequireJS or some other asynchronous library you can defer execution. Call
// Teaspoon.execute() after everything has been loaded. Simple example of a timeout:
//
// Teaspoon.defer = true
// setTimeout(Teaspoon.execute, 1000)
//
// Matching files
// By default Teaspoon will look for files that match _spec.{js,js.coffee,.coffee}. Add a filename_spec.js file in your
// spec path and it'll be included in the default suite automatically. If you want to customize suites, check out the
// configuration in config/initializers/teaspoon.rb
//
// Manifest
// If you'd rather require your spec files manually (to control order for instance) you can disable the suite matcher in
// the configuration and use this file as a manifest.
//
// For more information: http://github.com/modeset/teaspoon
//
// Chai
// If you're using Chai, you'll probably want to initialize your preferred assertion style. You can read more about Chai
// at: http://chaijs.com/guide/styles
//
// window.assert = chai.assert;
// window.expect = chai.expect;
// window.should = chai.should();
//
// You can require your own javascript files here. By default this will include everything in application, however you
// may get better load performance if you require the specific files that are being used in the spec that tests them.


window.expect = chai.expect;

var spies;
var stubs;
var xhr;
var requests;

function spyOn(object, method, returnValue) {
  var spy = sinon.spy(object, method);
  spies.push(spy);
  return spy;
}

function stub(object, method, retVal) {
  var stubObj;
  if (_.isFunction(retVal)) {
    stubObj = sinon.stub(object, method, retVal);
  } else {
    stubObj = sinon.stub(object, method).returns(retVal);
  }
  stubs.push(stubObj);
  return stubObj;
}

function findByClassName(className) {
  return document.getElementsByClassName(className)[0];
}

function testFixtureContainer() {
  return findByClassName('magic-lamp');
}

function removeNode(node) {
  if (!!node && node.parentNode) {
    node.parentNode.removeChild(node);
  }
}

function stubNetwork() {
  xhr = sinon.useFakeXMLHttpRequest();
  xhr.onCreate = function(xhr) {
    requests.push(xhr);
  };
}

beforeEach(function() {
  spies = [];
  stubs = [];
  requests = [];
});

afterEach(function() {
  _(spies).each(function(spy) {
    spy.restore();
  });

  _(stubs).each(function(stub) {
    stub.restore();
  });

  xhr && xhr.restore();

  requests = undefined;
  xhr = undefined;
  subject = undefined;
});
; TI"required_assets_digest; TI"%daaff2fad1d50f3b231abbde57313c79; FI"_version; TI"%d978939c91fa8a88b4612c4140ee433d; F