(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
var YList;

YList = (function() {
  function YList(list) {
    if (list == null) {
      this._list = [];
    } else if (list.constructor === Array) {
      this._list = list;
    } else {
      throw new Error("Y.List expects an Array as a parameter");
    }
  }

  YList.prototype._name = "List";

  YList.prototype._getModel = function(types, ops) {
    if (this._model == null) {
      this._model = new ops.ListManager(this).execute();
      this._model.insert(0, this._list);
    }
    delete this._list;
    return this._model;
  };

  YList.prototype._setModel = function(_model) {
    this._model = _model;
    return delete this._list;
  };

  YList.prototype.val = function() {
    return this._model.val.apply(this._model, arguments);
  };

  YList.prototype.ref = function() {
    return this._model.ref.apply(this._model, arguments);
  };

  YList.prototype.observe = function() {
    this._model.observe.apply(this._model, arguments);
    return this;
  };

  YList.prototype.unobserve = function() {
    this._model.unobserve.apply(this._model, arguments);
    return this;
  };

  YList.prototype.insert = function(position, content) {
    if (typeof position !== "number") {
      throw new Error("Y.List.insert expects a Number as the first parameter!");
    }
    this._model.insert(position, [content]);
    return this;
  };

  YList.prototype.insertContents = function(position, contents) {
    if (typeof position !== "number") {
      throw new Error("Y.List.insert expects a Number as the first parameter!");
    }
    this._model.insert(position, contents);
    return this;
  };

  YList.prototype["delete"] = function(position, length) {
    this._model["delete"](position, length);
    return this;
  };

  YList.prototype.push = function(content) {
    this._model.push(content);
    return this;
  };

  return YList;

})();

if (typeof window !== "undefined" && window !== null) {
  if (window.Y != null) {
    window.Y.List = YList;
  } else {
    throw new Error("You must first import Y!");
  }
}

if (typeof module !== "undefined" && module !== null) {
  module.exports = YList;
}


},{}],2:[function(require,module,exports){
var YSelections, compare_objects;

compare_objects = function(o, p, doAgain) {
  var n, v;
  if (doAgain == null) {
    doAgain = true;
  }
  for (n in o) {
    v = o[n];
    if (!((p[n] != null) && p[n] === v)) {
      return false;
    }
  }
  if (doAgain) {
    return compare_objects(p, o, false);
  } else {
    return true;
  }
};

YSelections = (function() {
  function YSelections() {
    this._listeners = [];
    this._composition_value = [];
    this._lists = [];
  }

  YSelections.prototype._name = "Selections";

  YSelections.prototype._getModel = function(Y, Operation) {
    if (this._model == null) {
      this._model = new Operation.Composition(this, []).execute();
    }
    return this._model;
  };

  YSelections.prototype._setModel = function(_model) {
    this._model = _model;
  };

  YSelections.prototype._getCompositionValue = function() {
    var composition_value, composition_value_operations, i, v;
    composition_value_operations = {};
    composition_value = (function() {
      var _i, _len, _ref, _results;
      _ref = this._composition_value;
      _results = [];
      for (i = _i = 0, _len = _ref.length; _i < _len; i = ++_i) {
        v = _ref[i];
        composition_value_operations["" + i + "/from"] = v.from;
        composition_value_operations["" + i + "/to"] = v.to;
        _results.push({
          attrs: v.attrs
        });
      }
      return _results;
    }).call(this);
    return {
      composition_value: composition_value,
      composition_value_operations: composition_value_operations
    };
  };

  YSelections.prototype._setCompositionValue = function(composition_value) {
    var v, _i, _len, _results;
    _results = [];
    for (_i = 0, _len = composition_value.length; _i < _len; _i++) {
      v = composition_value[_i];
      v.type = "select";
      _results.push(this._apply(v));
    }
    return _results;
  };

  YSelections.prototype._apply = function(delta) {
    var a, attr, attr_list, createSelection, cut_off_from, cut_off_to, delta_has_attrs, end, extendSelection, from, l, n, o, o_next, observer_call, p, parent, parent_exists, selection, selection_is_empty, start, to, to_next, undos, v, _i, _j, _len, _len1, _ref, _ref1, _ref2;
    undos = [];
    if (delta.from.isDeleted()) {
      delta.from = delta.from.getNext();
    }
    if (delta.to.isDeleted()) {
      delta.to = delta.to.getPrev();
    }
    from = delta.from;
    to = delta.to;
    if (from.getPrev() === to) {
      return undos;
    }
    if (delta.type === "select") {
      parent = from.getParent();
      parent_exists = false;
      _ref = this._lists;
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        p = _ref[_i];
        if (parent === this._lists[p]) {
          parent_exists = true;
          break;
        }
      }
      if (!parent_exists) {
        this._lists.push(parent);
        parent.observe((function(_this) {
          return function(events) {
            var event, next, prev, ref, sel, _j, _len1, _results;
            _results = [];
            for (_j = 0, _len1 = events.length; _j < _len1; _j++) {
              event = events[_j];
              if (event.type === "delete") {
                if (event.reference.selection != null) {
                  ref = event.reference;
                  sel = ref.selection;
                  delete ref.selection;
                  if (sel.from === ref && sel.to === ref) {
                    _this._removeFromCompositionValue(sel);
                  } else if (sel.from === ref) {
                    prev = ref.getNext();
                    sel.from = prev;
                    prev.selection = sel;
                  } else if (sel.to === ref) {
                    next = ref.getPrev();
                    sel.to = next;
                    next.selection = sel;
                  } else {
                    throw new Error("Found weird inconsistency! Y.Selections is no longer safe to use!");
                  }
                }
                next = event.reference.getNext();
                if (next.selection != null) {
                  _results.push(_this._combine_selection_to_left(next.selection));
                } else {
                  _results.push(void 0);
                }
              } else {
                _results.push(void 0);
              }
            }
            return _results;
          };
        })(this));
      }
    }
    observer_call = {
      from: from,
      to: to,
      type: delta.type,
      attrs: delta.attrs
    };
    _ref1 = this._listeners;
    for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
      l = _ref1[_j];
      l.call(this, observer_call);
    }
    createSelection = (function(_this) {
      return function(from, to, attrs) {
        var n, new_attrs, new_sel, v;
        new_attrs = {};
        for (n in attrs) {
          v = attrs[n];
          new_attrs[n] = v;
        }
        new_sel = {
          from: from,
          to: to,
          attrs: new_attrs
        };
        _this._composition_value.push(new_sel);
        return new_sel;
      };
    })(this);
    extendSelection = function(selection) {
      var n, undo_attrs, undo_attrs_list, undo_need_select, undo_need_unselect, v, _k, _len2, _ref2, _ref3, _ref4;
      if (delta.type === "unselect") {
        undo_attrs = {};
        _ref2 = delta.attrs;
        for (_k = 0, _len2 = _ref2.length; _k < _len2; _k++) {
          n = _ref2[_k];
          if (selection.attrs[n] != null) {
            undo_attrs[n] = selection.attrs[n];
          }
          delete selection.attrs[n];
        }
        return undos.push({
          from: delta.from,
          to: delta.to,
          attrs: undo_attrs,
          type: "select"
        });
      } else {
        undo_attrs = {};
        undo_attrs_list = [];
        undo_need_unselect = false;
        undo_need_select = false;
        if ((delta.overwrite != null) && delta.overwrite) {
          _ref3 = selection.attrs;
          for (n in _ref3) {
            v = _ref3[n];
            if (delta.attrs[n] == null) {
              undo_need_select = true;
              undo_attrs[n] = v;
            }
          }
          for (n in undo_attrs) {
            v = undo_attrs[n];
            delete selection.attrs[n];
          }
        }
        _ref4 = delta.attrs;
        for (n in _ref4) {
          v = _ref4[n];
          if (selection.attrs[n] != null) {
            undo_attrs[n] = selection.attrs[n];
            undo_need_select = true;
          } else {
            undo_attrs_list.push(n);
            undo_need_unselect = true;
          }
          selection.attrs[n] = v;
        }
        if (undo_need_select) {
          undos.push({
            from: selection.from,
            to: selection.to,
            attrs: undo_attrs,
            type: "select"
          });
        }
        if (undo_need_unselect) {
          return undos.push({
            from: selection.from,
            to: selection.to,
            attrs: undo_attrs_list,
            type: "unselect"
          });
        }
      }
    };
    cut_off_from = function() {
      var new_selection, o, old_selection, opt_selection;
      if ((from.selection != null) && from.selection.from === from) {
        return;
      }
      o = from.getPrev();
      while ((o.selection == null) && (o.type !== "Delimiter")) {
        o = o.getPrev();
      }
      if ((o.selection == null) || o.selection.to === o) {
        return;
      }
      old_selection = o.selection;
      o = from;
      while ((o !== old_selection.to) && (o !== to)) {
        o = o.getNext();
      }
      if (o === old_selection.to) {
        new_selection = createSelection(from, old_selection.to, old_selection.attrs);
        old_selection.to = from.getPrev();
        old_selection.to.selection = old_selection;
        new_selection.from.selection = new_selection;
        return new_selection.to.selection = new_selection;
      } else {
        new_selection = createSelection(from, to, old_selection.attrs);
        opt_selection = createSelection(to.getNext(), old_selection.to, old_selection.attrs);
        old_selection.to = from.getPrev();
        old_selection.to.selection = old_selection;
        opt_selection.from.selection = opt_selection;
        opt_selection.to.selection = opt_selection;
        new_selection.from.selection = new_selection;
        return new_selection.to.selection = new_selection;
      }
    };
    cut_off_from();
    cut_off_to = function() {
      var new_selection, o, old_selection;
      if ((to.selection != null) && to.selection.to === to) {
        return;
      }
      o = to;
      while ((o.selection == null) && (o !== from)) {
        o = o.getPrev();
      }
      if ((o.selection == null) || o.selection["to"] === o) {
        return;
      }
      old_selection = o.selection;
      new_selection = createSelection(to.getNext(), old_selection.to, old_selection.attrs);
      old_selection.to = to;
      old_selection.to.selection = old_selection;
      new_selection.from.selection = new_selection;
      return new_selection.to.selection = new_selection;
    };
    cut_off_to();
    delta_has_attrs = false;
    for (a in delta.attrs) {
      delta_has_attrs = true;
      break;
    }
    o = from;
    to_next = to.getNext();
    while (o !== to_next) {
      if (o.selection != null) {
        extendSelection(o.selection, delta);
        selection = o.selection;
        this._combine_selection_to_left(selection);
        o = selection.to.getNext();
        selection_is_empty = true;
        for (attr in selection.attrs) {
          selection_is_empty = false;
          break;
        }
        if (selection_is_empty) {
          this._removeFromCompositionValue(selection);
        }
      } else {
        start = o;
        o_next = o.getNext();
        while ((o_next.selection == null) && (o !== to)) {
          o = o_next;
          o_next = o.getNext();
        }
        end = o;
        if (delta.type !== "unselect" && delta_has_attrs) {
          attr_list = [];
          _ref2 = delta.attrs;
          for (n in _ref2) {
            v = _ref2[n];
            attr_list.push(n);
          }
          undos.push({
            from: start,
            to: end,
            attrs: attr_list,
            type: "unselect"
          });
          selection = createSelection(start, end, delta.attrs);
          start.selection = selection;
          end.selection = selection;
          this._combine_selection_to_left(o.selection);
        }
        o = o.getNext();
      }
    }
    if (o.selection != null) {
      this._combine_selection_to_left(o.selection);
    }
    if (from.selection != null) {
      this._combine_selection_to_left(from.selection);
    }
    return undos;
  };

  YSelections.prototype._removeFromCompositionValue = function(sel) {
    this._composition_value = this._composition_value.filter(function(o) {
      return o !== sel;
    });
    delete sel.from.selection;
    return delete sel.to.selection;
  };

  YSelections.prototype._combine_selection_to_left = function(sel) {
    var first_o, new_from;
    first_o = sel.from.getPrev();
    if (first_o.selection == null) {

    } else {
      if (compare_objects(first_o.selection.attrs, sel.attrs)) {
        new_from = first_o.selection.from;
        this._removeFromCompositionValue(first_o.selection);
        if (sel.from !== sel.to) {
          delete sel.from.selection;
        }
        sel.from = new_from;
        return new_from.selection = sel;
      } else {

      }
    }
  };

  YSelections.prototype._unapply = function(deltas) {
    var delta, _i, _len;
    for (_i = 0, _len = deltas.length; _i < _len; _i++) {
      delta = deltas[_i];
      this._apply(delta);
    }
  };

  YSelections.prototype.select = function(from, to, attrs, overwrite) {
    var a, delta, delta_operations, length;
    length = 0;
    for (a in attrs) {
      length++;
      break;
    }
    if (length <= 0 && !((overwrite != null) && overwrite)) {
      return;
    }
    delta_operations = {
      from: from,
      to: to
    };
    delta = {
      attrs: attrs,
      type: "select"
    };
    if ((overwrite != null) && overwrite) {
      delta.overwrite = true;
    }
    return this._model.applyDelta(delta, delta_operations);
  };

  YSelections.prototype.unselectAll = function(from, to) {
    return select(from, to, {}, true);
  };

  YSelections.prototype.unselect = function(from, to, attrs) {
    var delta, delta_operations;
    if (typeof attrs === "string") {
      attrs = [attrs];
    }
    if (attrs.constructor !== Array) {
      throw new Error("Y.Selections.prototype.unselect expects an Array or String as the third parameter (attributes)!");
    }
    if (attrs.length <= 0) {
      return;
    }
    delta_operations = {
      from: from,
      to: to
    };
    delta = {
      attrs: attrs,
      type: "unselect"
    };
    return this._model.applyDelta(delta, delta_operations);
  };

  YSelections.prototype.getSelections = function(list) {
    var attrs, n, number_of_attrs, o, pos, result, sel_start, v, _ref;
    o = list.ref(0);
    if (o == null) {
      return [];
    }
    sel_start = null;
    pos = 0;
    result = [];
    while (o.next_cl != null) {
      if (o.isDeleted()) {
        if (o.selection != null) {
          console.log("You forgot to delete the selection from this operation! Please write an issue how to reproduce this bug! (it could lead to inconsistencies!)");
        }
        o = o.next_cl;
        continue;
      }
      if (o.selection != null) {
        if (o.selection.from === o) {
          if (sel_start != null) {
            throw new Error("Found two consecutive from elements. The selections are no longer safe to use! (contact the owner of the repository)");
          } else {
            sel_start = pos;
          }
        }
        if (o.selection.to === o) {
          if (sel_start != null) {
            number_of_attrs = 0;
            attrs = {};
            _ref = o.selection.attrs;
            for (n in _ref) {
              v = _ref[n];
              attrs[n] = v;
            }
            result.push({
              from: sel_start,
              to: pos,
              attrs: attrs
            });
            sel_start = null;
          } else {
            throw new Error("Found two consecutive to elements. The selections are no longer safe to use! (contact the owner of the repository)");
          }
        } else if (o.selection.from !== o) {
          throw new Error("This reference should not point to this selection, because the selection does not point to the reference. The selections are no longer safe to use! (contact the owner of the repository)");
        }
      }
      pos++;
      o = o.next_cl;
    }
    return result;
  };

  YSelections.prototype.observe = function(f) {
    return this._listeners.push(f);
  };

  YSelections.prototype.unobserve = function(f) {
    return this._listeners = this._listeners.filter(function(g) {
      return f !== g;
    });
  };

  return YSelections;

})();

if (typeof window !== "undefined" && window !== null) {
  if (window.Y != null) {
    window.Y.Selections = YSelections;
  } else {
    throw new Error("You must first import Y!");
  }
}

if (typeof module !== "undefined" && module !== null) {
  module.exports = YSelections;
}


},{}],3:[function(require,module,exports){
module.exports = require('./lib/chai');

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

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

/*!
 * Chai version
 */

exports.version = '2.2.0';

/*!
 * 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;
};

/*!
 * Utility Functions
 */

exports.util = util;

/*!
 * Configuration
 */

var config = require('./chai/config');
exports.config = config;

/*!
 * 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);

},{"./chai/assertion":5,"./chai/config":6,"./chai/core/assertions":7,"./chai/interface/assert":8,"./chai/interface/expect":9,"./chai/interface/should":10,"./chai/utils":23,"assertion-error":32}],5:[function(require,module,exports){
/*!
 * chai
 * http://chaijs.com
 * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */

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

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);
  }

  Object.defineProperty(Assertion, 'includeStack', {
    get: function() {
      console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.');
      return config.includeStack;
    },
    set: function(value) {
      console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.');
      config.includeStack = value;
    }
  });

  Object.defineProperty(Assertion, 'showDiff', {
    get: function() {
      console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.');
      return config.showDiff;
    },
    set: function(value) {
      console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.');
      config.showDiff = value;
    }
  });

  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 or Function} message or function that returns message to display if expression fails
   * @param {String or Function} negatedMessage or function that returns 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`
   * @param {Boolean} showDiff (optional) when set to `true`, assert will display a diff in addition to the message if expression fails
   * @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 !== config.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
      }, (config.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);
      }
  });
};

},{"./config":6}],6:[function(require,module,exports){
module.exports = {

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

   includeStack: false,

  /**
   * ### config.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.
   *
   * @param {Boolean}
   * @api public
   */

  showDiff: true,

  /**
   * ### config.truncateThreshold
   *
   * User configurable property, sets length threshold for actual and
   * expected values in assertion errors. If this threshold is exceeded, for
   * example for large data structures, the value is replaced with something
   * like `[ Array(3) ]` or `{ Object (prop1, prop2) }`.
   *
   * Set it to zero if you want to disable truncating altogether.
   *
   * This is especially userful when doing assertions on arrays: having this
   * set to a reasonable large value makes the failure messages readily
   * inspectable.
   *
   *     chai.config.truncateThreshold = 0;  // disable truncating
   *
   * @param {Number}
   * @api public
   */

  truncateThreshold: 40

};

},{}],7:[function(require,module,exports){
/*!
 * 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 testing capabilities unless they
   * have been overwritten by a plugin.
   *
   * **Chains**
   *
   * - to
   * - be
   * - been
   * - is
   * - that
   * - which
   * - and
   * - has
   * - have
   * - with
   * - at
   * - of
   * - same
   *
   * @name language chains
   * @api public
   */

  [ 'to', 'be', 'been'
  , 'is', 'and', 'has', 'have'
  , 'with', 'that', 'which', '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');
   *
   * `.deep.property` special characters can be escaped
   * by adding two slashes before the `.` or `[]`.
   *
   *     var deepCss = { '.link': { '[target]': 42 }};
   *     expect(deepCss).to.have.deep.property('\\.link.\\[target\\]', 42);
   *
   * @name deep
   * @api public
   */

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

  /**
   * ### .any
   *
   * Sets the `any` flag, (opposite of the `all` flag)
   * later used in the `keys` assertion. 
   *
   *     expect(foo).to.have.any.keys('bar', 'baz');
   *
   * @name any
   * @api public
   */

  Assertion.addProperty('any', function () {
    flag(this, 'any', true);
    flag(this, 'all', false)
  });


  /**
   * ### .all
   *
   * Sets the `all` flag (opposite of the `any` flag) 
   * later used by the `keys` assertion.
   *
   *     expect(foo).to.have.all.keys('bar', 'baz');
   *
   * @name all
   * @api public
   */

  Assertion.addProperty('all', function () {
    flag(this, 'all', true);
    flag(this, 'any', false);
  });

  /**
   * ### .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 `contains` 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
   * @alias includes
   * @alias contains
   * @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');
    var expected = false;
    if (_.type(obj) === 'array' && _.type(val) === 'object') {
      for (var i in obj) {
        if (_.eql(obj[i], val)) {
          expected = true;
          break;
        }
      }
    } else 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];
      expected = _.eql(subset, val);
    } else {
      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);
  Assertion.addChainableMethod('contains', include, includeChainingBehavior);
  Assertion.addChainableMethod('includes', 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 and strings, 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' });
   *
   * Note that dots and bracket in `name` must be backslash-escaped when
   * the `deep` flag is set, while they must NOT be escaped when the `deep`
   * flag is not set.
   *
   *     // simple referencing
   *     var css = { '.link[target]': 42 };
   *     expect(css).to.have.property('.link[target]', 42);
   *
   *     // deep referencing
   *     var deepCss = { '.link': { '[target]': 42 }};
   *     expect(deepCss).to.have.deep.property('\\.link.\\[target\\]', 42);
   *
   * @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 isDeep = !!flag(this, 'deep')
      , descriptor = isDeep ? 'deep property ' : 'property '
      , negate = flag(this, 'negate')
      , obj = flag(this, 'object')
      , pathInfo = isDeep ? _.getPathInfo(name, obj) : null
      , hasProperty = isDeep
        ? pathInfo.exists
        : _.hasProperty(name, obj)
      , value = isDeep
        ? pathInfo.value
        : 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(
          hasProperty
        , '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);

  /**
   * ### .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 contains any or all of the passed-in keys.
   * Use in combination with `any`, `all`, `contains`, or `have` will affect 
   * what will pass.
   * 
   * When used in conjunction with `any`, at least one key that is passed 
   * in must exist in the target object. This is regardless whether or not 
   * the `have` or `contain` qualifiers are used. Note, either `any` or `all`
   * should be used in the assertion. If neither are used, the assertion is
   * defaulted to `all`.
   * 
   * When both `all` and `contain` are used, the target object must have at 
   * least all of the passed-in keys but may have more keys not listed.
   * 
   * When both `all` and `have` are used, the target object must both contain
   * all of the passed-in keys AND the number of keys in the target object must
   * match the number of keys passed in (in other words, a target object must 
   * have all and only all of the passed-in keys).
   * 
   *     expect({ foo: 1, bar: 2 }).to.have.any.keys('foo', 'baz');
   *     expect({ foo: 1, bar: 2 }).to.have.any.keys('foo');
   *     expect({ foo: 1, bar: 2 }).to.contain.any.keys('bar', 'baz');
   *     expect({ foo: 1, bar: 2 }).to.contain.any.keys(['foo']);
   *     expect({ foo: 1, bar: 2 }).to.contain.any.keys({'foo': 6});
   *     expect({ foo: 1, bar: 2 }).to.have.all.keys(['bar', 'foo']);
   *     expect({ foo: 1, bar: 2 }).to.have.all.keys({'bar': 6, 'foo', 7});
   *     expect({ foo: 1, bar: 2, baz: 3 }).to.contain.all.keys(['bar', 'foo']);
   *     expect({ foo: 1, bar: 2, baz: 3 }).to.contain.all.keys([{'bar': 6}}]);
   *
   *
   * @name keys
   * @alias key
   * @param {String...|Array|Object} keys
   * @api public
   */

  function assertKeys (keys) {
    var obj = flag(this, 'object')
      , str
      , ok = true
      , mixedArgsMsg = 'keys must be given single argument of Array|Object|String, or multiple String arguments';

    switch (_.type(keys)) {
      case "array":
        if (arguments.length > 1) throw (new Error(mixedArgsMsg));
        break;
      case "object":
        if (arguments.length > 1) throw (new Error(mixedArgsMsg));
        keys = Object.keys(keys);
        break;
      default:
        keys = Array.prototype.slice.call(arguments);
    }

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

    var actual = Object.keys(obj)
      , expected = keys
      , len = keys.length
      , any = flag(this, 'any')
      , all = flag(this, 'all');

    if (!any && !all) {
      all = true;
    }

    // Has any
    if (any) {
      var intersection = expected.filter(function(key) {
        return ~actual.indexOf(key);
      });
      ok = intersection.length > 0;
    }

    // Has all
    if (all) {
      ok = keys.every(function(key){
        return ~actual.indexOf(key);
      });
      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();
      if (all) {
        str = keys.join(', ') + ', and ' + last;
      }
      if (any) {
        str = keys.join(', ') + ', or ' + 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
      , expected.slice(0).sort()
      , actual.sort()
      , true
    );
  }

  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');
    var result = matcher(obj);
    this.assert(
        result
      , 'expected #{this} to satisfy ' + _.objDisplay(matcher)
      , 'expected #{this} to not satisfy' + _.objDisplay(matcher)
      , this.negate ? false : true
      , result
    );
  });

  /**
   * ### .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');

    new Assertion(obj, msg).is.a('number');
    if (_.type(expected) !== 'number' || _.type(delta) !== 'number') {
      throw new Error('the arguments to closeTo must be numbers');
    }

    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, cmp) {
    return subset.every(function(elem) {
      if (!cmp) return superset.indexOf(elem) !== -1;

      return superset.some(function(elem2) {
        return cmp(elem, elem2);
      });
    })
  }

  /**
   * ### .members(set)
   *
   * Asserts that the target is a superset of `set`,
   * or that the target and `set` have the same strictly-equal (===) members.
   * Alternately, if the `deep` flag is set, set members are compared for deep
   * equality.
   *
   *     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]);
   *
   *     expect([{ id: 1 }]).to.deep.include.members([{ id: 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');

    var cmp = flag(this, 'deep') ? _.eql : undefined;

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

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

  /**
   * ### .change(function)
   *
   * Asserts that a function changes an object property
   *
   *     var obj = { val: 10 };
   *     var fn = function() { obj.val += 3 };
   *     var noChangeFn = function() { return 'foo' + 'bar'; }
   *     expect(fn).to.change(obj, 'val');
   *     expect(noChangFn).to.not.change(obj, 'val')
   *
   * @name change
   * @alias changes
   * @alias Change
   * @param {String} object
   * @param {String} property name
   * @param {String} message _optional_
   * @api public
   */

  function assertChanges (object, prop, msg) {
    if (msg) flag(this, 'message', msg);
    var fn = flag(this, 'object');
    new Assertion(object, msg).to.have.property(prop);
    new Assertion(fn).is.a('function');

    var initial = object[prop];
    fn();

    this.assert(
      initial !== object[prop]
      , 'expected .' + prop + ' to change'
      , 'expected .' + prop + ' to not change'
    );
  }

  Assertion.addChainableMethod('change', assertChanges);
  Assertion.addChainableMethod('changes', assertChanges);

  /**
   * ### .increase(function)
   *
   * Asserts that a function increases an object property
   *
   *     var obj = { val: 10 };
   *     var fn = function() { obj.val = 15 };
   *     expect(fn).to.increase(obj, 'val');
   *
   * @name increase
   * @alias increases
   * @alias Increase
   * @param {String} object
   * @param {String} property name
   * @param {String} message _optional_
   * @api public
   */

  function assertIncreases (object, prop, msg) {
    if (msg) flag(this, 'message', msg);
    var fn = flag(this, 'object');
    new Assertion(object, msg).to.have.property(prop);
    new Assertion(fn).is.a('function');

    var initial = object[prop];
    fn();

    this.assert(
      object[prop] - initial > 0
      , 'expected .' + prop + ' to increase'
      , 'expected .' + prop + ' to not increase'
    );
  }

  Assertion.addChainableMethod('increase', assertIncreases);
  Assertion.addChainableMethod('increases', assertIncreases);

  /**
   * ### .decrease(function)
   *
   * Asserts that a function decreases an object property
   *
   *     var obj = { val: 10 };
   *     var fn = function() { obj.val = 5 };
   *     expect(fn).to.decrease(obj, 'val');
   *
   * @name decrease
   * @alias decreases
   * @alias Decrease
   * @param {String} object
   * @param {String} property name
   * @param {String} message _optional_
   * @api public
   */

  function assertDecreases (object, prop, msg) {
    if (msg) flag(this, 'message', msg);
    var fn = flag(this, 'object');
    new Assertion(object, msg).to.have.property(prop);
    new Assertion(fn).is.a('function');

    var initial = object[prop];
    fn();

    this.assert(
      object[prop] - initial < 0
      , 'expected .' + prop + ' to decrease'
      , 'expected .' + prop + ' to not decrease'
    );
  }

  Assertion.addChainableMethod('decrease', assertDecreases);
  Assertion.addChainableMethod('decreases', assertDecreases);

};

},{}],8:[function(require,module,exports){
/*!
 * 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, null, chai.assert);
    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, assert.equal);

    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, assert.notEqual);

    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.isAbove = function (val, abv, msg) {
    new Assertion(val, msg).to.be.above(abv);
  };

   /**
   * ### .isAbove(valueToCheck, valueToBeAbove, [message])
   *
   * Asserts `valueToCheck` is strictly greater than (>) `valueToBeAbove`
   *
   *     assert.isAbove(5, 2, '5 is strictly greater than 2');
   *
   * @name isAbove
   * @param {Mixed} valueToCheck
   * @param {Mixed} valueToBeAbove
   * @param {String} message
   * @api public
   */

  assert.isBelow = function (val, blw, msg) {
    new Assertion(val, msg).to.be.below(blw);
  };

   /**
   * ### .isBelow(valueToCheck, valueToBeBelow, [message])
   *
   * Asserts `valueToCheck` is strictly less than (<) `valueToBeBelow`
   *
   *     assert.isBelow(3, 6, '3 is strictly less than 6');
   *
   * @name isBelow
   * @param {Mixed} valueToCheck
   * @param {Mixed} valueToBeBelow
   * @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.isNotObject(selection, 'tea selection is not an object');
   *     assert.isNotObject(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, assert.include).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, assert.notInclude).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) {
    var ok;
    switch(operator) {
      case '==':
        ok = val == val2;
        break;
      case '===':
        ok = val === val2;
        break;
      case '>':
        ok = val > val2;
        break;
      case '>=':
        ok = val >= val2;
        break;
      case '<':
        ok = val < val2;
        break;
      case '<=':
        ok = val <= val2;
        break;
      case '!=':
        ok = val != val2;
        break;
      case '!==':
        ok = val !== val2;
        break;
      default:
        throw new Error('Invalid operator "' + operator + '"');
    }
    var test = new Assertion(ok, 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} set1
   * @param {Array} set2
   * @param {String} message
   * @api public
   */

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

  /**
   * ### .sameDeepMembers(set1, set2, [message])
   *
   * Asserts that `set1` and `set2` have the same members - using a deep equality checking.
   * Order is not taken into account.
   *
   *     assert.sameDeepMembers([ {b: 3}, {a: 2}, {c: 5} ], [ {c: 5}, {b: 3}, {a: 2} ], 'same deep members');
   *
   * @name sameDeepMembers
   * @param {Array} set1
   * @param {Array} set2
   * @param {String} message
   * @api public
   */

  assert.sameDeepMembers = function (set1, set2, msg) {
    new Assertion(set1, msg).to.have.same.deep.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);
  }

   /**
   * ### .changes(function, object, property)
   *
   * Asserts that a function changes the value of a property
   *
   *     var obj = { val: 10 };
   *     var fn = function() { obj.val = 22 };
   *     assert.changes(fn, obj, 'val');
   *
   * @name changes
   * @param {Function} modifier function
   * @param {Object} object
   * @param {String} property name
   * @param {String} message _optional_
   * @api public
   */

  assert.changes = function (fn, obj, prop) {
    new Assertion(fn).to.change(obj, prop);
  }

   /**
   * ### .doesNotChange(function, object, property)
   *
   * Asserts that a function does not changes the value of a property
   *
   *     var obj = { val: 10 };
   *     var fn = function() { console.log('foo'); };
   *     assert.doesNotChange(fn, obj, 'val');
   *
   * @name doesNotChange
   * @param {Function} modifier function
   * @param {Object} object
   * @param {String} property name
   * @param {String} message _optional_
   * @api public
   */

  assert.doesNotChange = function (fn, obj, prop) {
    new Assertion(fn).to.not.change(obj, prop);
  }

   /**
   * ### .increases(function, object, property)
   *
   * Asserts that a function increases an object property
   *
   *     var obj = { val: 10 };
   *     var fn = function() { obj.val = 13 };
   *     assert.increases(fn, obj, 'val');
   *
   * @name increases
   * @param {Function} modifier function
   * @param {Object} object
   * @param {String} property name
   * @param {String} message _optional_
   * @api public
   */

  assert.increases = function (fn, obj, prop) {
    new Assertion(fn).to.increase(obj, prop);
  }

   /**
   * ### .doesNotIncrease(function, object, property)
   *
   * Asserts that a function does not increase object property
   *
   *     var obj = { val: 10 };
   *     var fn = function() { obj.val = 8 };
   *     assert.doesNotIncrease(fn, obj, 'val');
   *
   * @name doesNotIncrease
   * @param {Function} modifier function
   * @param {Object} object
   * @param {String} property name
   * @param {String} message _optional_
   * @api public
   */

  assert.doesNotIncrease = function (fn, obj, prop) {
    new Assertion(fn).to.not.increase(obj, prop);
  }

   /**
   * ### .decreases(function, object, property)
   *
   * Asserts that a function decreases an object property
   *
   *     var obj = { val: 10 };
   *     var fn = function() { obj.val = 5 };
   *     assert.decreases(fn, obj, 'val');
   *
   * @name decreases
   * @param {Function} modifier function
   * @param {Object} object
   * @param {String} property name
   * @param {String} message _optional_
   * @api public
   */

  assert.decreases = function (fn, obj, prop) {
    new Assertion(fn).to.decrease(obj, prop);
  }

   /**
   * ### .doesNotDecrease(function, object, property)
   *
   * Asserts that a function does not decreases an object property
   *
   *     var obj = { val: 10 };
   *     var fn = function() { obj.val = 15 };
   *     assert.doesNotDecrease(fn, obj, 'val');
   *
   * @name doesNotDecrease
   * @param {Function} modifier function
   * @param {Object} object
   * @param {String} property name
   * @param {String} message _optional_
   * @api public
   */

  assert.doesNotDecrease = function (fn, obj, prop) {
    new Assertion(fn).to.not.decrease(obj, prop);
  }

  /*!
   * 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');
};

},{}],9:[function(require,module,exports){
/*!
 * 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);
  };

  /**
   * ### .fail(actual, expected, [message], [operator])
   *
   * Throw a failure.
   *
   * @name fail
   * @param {Mixed} actual
   * @param {Mixed} expected
   * @param {String} message
   * @param {String} operator
   * @api public
   */

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

},{}],10:[function(require,module,exports){
/*!
 * chai
 * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */

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

  function loadShould () {
    // explicitly define this method as function as to have it's name to include as `ssfi`
    function shouldGetter() {
      if (this instanceof String || this instanceof Number || this instanceof Boolean ) {
        return new Assertion(this.valueOf(), null, shouldGetter);
      }
      return new Assertion(this, null, shouldGetter);
    }
    function shouldSetter(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
      });
    }
    // modify Object.prototype to have `should`
    Object.defineProperty(Object.prototype, 'should', {
      set: shouldSetter
      , get: shouldGetter
      , configurable: true
    });

    var should = {};

    /**
     * ### .fail(actual, expected, [message], [operator])
     *
     * Throw a failure.
     *
     * @name fail
     * @param {Mixed} actual
     * @param {Mixed} expected
     * @param {String} message
     * @param {String} operator
     * @api public
     */

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

    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;
};

},{}],11:[function(require,module,exports){
/*!
 * Chai - addChainingMethod utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */

/*!
 * Module dependencies
 */

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

/*!
 * 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 assert() {
          var old_ssfi = flag(this, 'ssfi');
          if (old_ssfi && config.includeStack === false)
            flag(this, 'ssfi', assert);
          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
  });
};

},{"../config":6,"./flag":14,"./transferFlags":30}],12:[function(require,module,exports){
/*!
 * Chai - addMethod utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */

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

/**
 * ### .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
 */
var flag = require('./flag');

module.exports = function (ctx, name, method) {
  ctx[name] = function () {
    var old_ssfi = flag(this, 'ssfi');
    if (old_ssfi && config.includeStack === false)
      flag(this, 'ssfi', ctx[name]);
    var result = method.apply(this, arguments);
    return result === undefined ? this : result;
  };
};

},{"../config":6,"./flag":14}],13:[function(require,module,exports){
/*!
 * 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
  });
};

},{}],14:[function(require,module,exports){
/*!
 * 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];
  }
};

},{}],15:[function(require,module,exports){
/*!
 * 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) {
  return args.length > 4 ? args[4] : obj._obj;
};

},{}],16:[function(require,module,exports){
/*!
 * 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;
};

},{}],17:[function(require,module,exports){
/*!
 * 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');

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

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

},{"./flag":14,"./getActual":15,"./inspect":24,"./objDisplay":25}],18:[function(require,module,exports){
/*!
 * 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] : "";
};

},{}],19:[function(require,module,exports){
/*!
 * Chai - getPathInfo utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */

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

/**
 * ### .getPathInfo(path, object)
 *
 * This allows the retrieval of property info in an
 * object given a string path.
 *
 * The path info consists of an object with the
 * following properties:
 *
 * * parent - The parent object of the property referenced by `path`
 * * name - The name of the final property, a number if it was an array indexer
 * * value - The value of the property, if it exists, otherwise `undefined`
 * * exists - Whether the property exists or not
 *
 * @param {String} path
 * @param {Object} object
 * @returns {Object} info
 * @name getPathInfo
 * @api public
 */

module.exports = function getPathInfo(path, obj) {
  var parsed = parsePath(path),
      last = parsed[parsed.length - 1];

  var info = {
    parent: parsed.length > 1 ? _getPathValue(parsed, obj, parsed.length - 1) : obj,
    name: last.p || last.i,
    value: _getPathValue(parsed, obj),
  };
  info.exists = hasProperty(info.name, info.parent);

  return info;
};


/*!
 * ## 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`.
 * * Literal dots and brackets (not delimiter) must be backslash-escaped.
 *
 * @param {String} path
 * @returns {Object} parsed
 * @api private
 */

function parsePath (path) {
  var str = path.replace(/([^\\])\[/g, '$1.[')
    , 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.replace(/\\([.\[\]])/g, '$1') };
  });
}


/*!
 * ## _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
 * @param {Number} object to search against
 * @returns {Object|Undefined} value
 * @api private
 */

function _getPathValue (parsed, obj, index) {
  var tmp = obj
    , res;

  index = (index === undefined ? parsed.length : index);

  for (var i = 0, l = index; 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;
}

},{"./hasProperty":22}],20:[function(require,module,exports){
/*!
 * Chai - getPathValue utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * @see https://github.com/logicalparadox/filtr
 * MIT Licensed
 */

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

/**
 * ### .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
 */
module.exports = function(path, obj) {
  var info = getPathInfo(path, obj);
  return info.value;
}; 

},{"./getPathInfo":19}],21:[function(require,module,exports){
/*!
 * 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;
};

},{}],22:[function(require,module,exports){
/*!
 * Chai - hasProperty utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */

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

/**
 * ### .hasProperty(object, name)
 *
 * This allows checking whether an object has
 * named property or numeric array index.
 *
 * Basically does the same thing as the `in`
 * operator but works properly with natives
 * and null/undefined values.
 *
 *     var obj = {
 *         arr: ['a', 'b', 'c']
 *       , str: 'Hello'
 *     }
 *
 * The following would be the results.
 *
 *     hasProperty('str', obj);  // true
 *     hasProperty('constructor', obj);  // true
 *     hasProperty('bar', obj);  // false
 *     
 *     hasProperty('length', obj.str); // true
 *     hasProperty(1, obj.str);  // true
 *     hasProperty(5, obj.str);  // false
 *
 *     hasProperty('length', obj.arr);  // true
 *     hasProperty(2, obj.arr);  // true
 *     hasProperty(3, obj.arr);  // false
 *
 * @param {Objuect} object
 * @param {String|Number} name
 * @returns {Boolean} whether it exists
 * @name getPathInfo
 * @api public
 */

var literals = {
    'number': Number
  , 'string': String
};

module.exports = function hasProperty(name, obj) {
  var ot = type(obj);

  // Bad Object, obviously no props at all
  if(ot === 'null' || ot === 'undefined')
    return false;

  // The `in` operator does not work with certain literals
  // box these before the check
  if(literals[ot] && typeof obj !== 'object')
    obj = new literals[ot](obj);

  return name in obj;
};

},{"./type":31}],23:[function(require,module,exports){
/*!
 * 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');

/*!
 * Deep path info
 */

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

/*!
 * Check if a property exists
 */

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

/*!
 * 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');


},{"./addChainableMethod":11,"./addMethod":12,"./addProperty":13,"./flag":14,"./getActual":15,"./getMessage":17,"./getName":18,"./getPathInfo":19,"./getPathValue":20,"./hasProperty":22,"./inspect":24,"./objDisplay":25,"./overwriteChainableMethod":26,"./overwriteMethod":27,"./overwriteProperty":28,"./test":29,"./transferFlags":30,"./type":31,"deep-eql":33}],24:[function(require,module,exports){
// 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));
}

// 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 this is a DOM element, try to get the outer HTML.
  if (isDOMElement(value)) {
    if ('outerHTML' in value) {
      return value.outerHTML;
      // This value does not have an outerHTML attribute,
      //   it could still be an XML element
    } else {
      // Attempt to serialize it
      try {
        if (document.xmlVersion) {
          var xmlSerializer = new XMLSerializer();
          return xmlSerializer.serializeToString(value);
        } else {
          // Firefox 11- do not support outerHTML
          //   It does, however, support innerHTML
          //   Use the following to render the element
          var ns = "http://www.w3.org/1999/xhtml";
          var container = document.createElementNS(ns, '_');

          container.appendChild(value.cloneNode(false));
          html = container.innerHTML
            .replace('><', '>' + value.innerHTML + '<');
          container.innerHTML = '';
          return html;
        }
      } catch (err) {
        // This could be a non-native DOM implementation,
        //   continue with the normal flow:
        //   printing the element as if it is an object.
      }
    }
  }

  // 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':
      if (value === 0 && (1/value) === -Infinity) {
        return ctx.stylize('-0', '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);
}

},{"./getEnumerableProperties":16,"./getName":18,"./getProperties":21}],25:[function(require,module,exports){
/*!
 * Chai - flag utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */

/*!
 * Module dependancies
 */

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

/**
 * ### .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 (config.truncateThreshold && str.length >= config.truncateThreshold) {
    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;
  }
};

},{"../config":6,"./inspect":24}],26:[function(require,module,exports){
/*!
 * Chai - overwriteChainableMethod utility
 * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
 * MIT Licensed
 */

/**
 * ### overwriteChainableMethod (ctx, name, method, chainingBehavior)
 *
 * 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;
  };
};

},{}],27:[function(require,module,exports){
/*!
 * 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;
  }
};

},{}],28:[function(require,module,exports){
/*!
 * 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
  });
};

},{}],29:[function(require,module,exports){
/*!
 * 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;
};

},{"./flag":14}],30:[function(require,module,exports){
/*!
 * 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 to; usually a new assertion
 * @param {Boolean} includeAll
 * @name transferFlags
 * @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];
    }
  }
};

},{}],31:[function(require,module,exports){
/*!
 * 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;
};

},{}],32:[function(require,module,exports){
/*!
 * 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;
};

},{}],33:[function(require,module,exports){
module.exports = require('./lib/eql');

},{"./lib/eql":34}],34:[function(require,module,exports){
/*!
 * 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;
}

},{"buffer":110,"type-detect":35}],35:[function(require,module,exports){
module.exports = require('./lib/type');

},{"./lib/type":36}],36:[function(require,module,exports){
/*!
 * 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.');
  }
};

},{}],37:[function(require,module,exports){
(function (sinonChai) {
    "use strict";

    // Module systems magic dance.

    /* istanbul ignore else */
    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: function () {
                return printfArray(["expected %n to " + verbPhrase + action + nonNegatedSuffix].concat(args));
            },
            negative: function () {
                return 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");
}));

},{}],38:[function(require,module,exports){
/**
 * Sinon core utilities. For internal use only.
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */
"use strict";

var sinon = (function () {
    var sinon;
    var isNode = typeof module !== "undefined" && module.exports && typeof require === "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports, module) {
        sinon = module.exports = require("./sinon/util/core");
        require("./sinon/extend");
        require("./sinon/typeOf");
        require("./sinon/times_in_words");
        require("./sinon/spy");
        require("./sinon/call");
        require("./sinon/behavior");
        require("./sinon/stub");
        require("./sinon/mock");
        require("./sinon/collection");
        require("./sinon/assert");
        require("./sinon/sandbox");
        require("./sinon/test");
        require("./sinon/test_case");
        require("./sinon/match");
        require("./sinon/format");
        require("./sinon/log_error");
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
        sinon = module.exports;
    } else {
        sinon = {};
    }

    return sinon;
}());

},{"./sinon/assert":39,"./sinon/behavior":40,"./sinon/call":41,"./sinon/collection":42,"./sinon/extend":43,"./sinon/format":44,"./sinon/log_error":45,"./sinon/match":46,"./sinon/mock":47,"./sinon/sandbox":48,"./sinon/spy":49,"./sinon/stub":50,"./sinon/test":51,"./sinon/test_case":52,"./sinon/times_in_words":53,"./sinon/typeOf":54,"./sinon/util/core":55}],39:[function(require,module,exports){
(function (global){
/**
 * @depend times_in_words.js
 * @depend util/core.js
 * @depend match.js
 * @depend format.js
 */
/**
 * Assertions matching the test spy retrieval interface.
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */
"use strict";

(function (sinon, global) {
    var slice = Array.prototype.slice;

    function makeApi(sinon) {
        var assert;

        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 (method.proxy) {
                    verifyIsStub(method.proxy);
                } else {
                    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 || fake.proxy.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 != "expose" && (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");

        sinon.assert = assert;
        return assert;
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        require("./match");
        require("./format");
        module.exports = makeApi(sinon);
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }

}(typeof sinon == "object" && sinon || null, typeof window != "undefined" ? window : (typeof self != "undefined") ? self : global));

}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"./format":44,"./match":46,"./util/core":55}],40:[function(require,module,exports){
(function (process){
/**
 * @depend util/core.js
 * @depend extend.js
 */
/**
 * Stub behavior
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @author Tim Fischbach (mail@timfischbach.de)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */
"use strict";

(function (sinon) {
    var slice = Array.prototype.slice;
    var join = Array.prototype.join;
    var useLeftMostCallback = -1;
    var useRightMostCallback = -2;

    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) {
            return args[callArgAt];
        }

        var argumentList;

        if (callArgAt === useLeftMostCallback) {
            argumentList = args;
        }

        if (callArgAt === useRightMostCallback) {
            argumentList = slice.call(args).reverse();
        }

        var callArgProp = behavior.callArgProp;

        for (var i = 0, l = argumentList.length; i < l; ++i) {
            if (!callArgProp && typeof argumentList[i] == "function") {
                return argumentList[i];
            }

            if (callArgProp && argumentList[i] &&
                typeof argumentList[i][callArgProp] == "function") {
                return argumentList[i][callArgProp];
            }
        }

        return null;
    }

    function makeApi(sinon) {
        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);
                }
            }
        }

        var proto = {
            create: function create(stub) {
                var behavior = sinon.extend({}, sinon.behavior);
                delete behavior.create;
                behavior.stub = stub;

                return behavior;
            },

            isPresent: function isPresent() {
                return (typeof this.callArgAt == "number" ||
                        this.exception ||
                        typeof this.returnArgAt == "number" ||
                        this.returnThis ||
                        this.returnValueDefined);
            },

            invoke: function invoke(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 onCall(index) {
                return this.stub.onCall(index);
            },

            onFirstCall: function onFirstCall() {
                return this.stub.onFirstCall();
            },

            onSecondCall: function onSecondCall() {
                return this.stub.onSecondCall();
            },

            onThirdCall: function onThirdCall() {
                return this.stub.onThirdCall();
            },

            withArgs: function withArgs(/* 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 = useLeftMostCallback;
                this.callbackArguments = slice.call(arguments, 0);
                this.callbackContext = undefined;
                this.callArgProp = undefined;
                this.callbackAsync = false;

                return this;
            },

            yieldsRight: function () {
                this.callArgAt = useRightMostCallback;
                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 = useLeftMostCallback;
                this.callbackArguments = slice.call(arguments, 1);
                this.callbackContext = context;
                this.callArgProp = undefined;
                this.callbackAsync = false;

                return this;
            },

            yieldsTo: function (prop) {
                this.callArgAt = useLeftMostCallback;
                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 = useLeftMostCallback;
                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);
            }
        }

        sinon.behavior = proto;
        return proto;
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        require("./extend");
        module.exports = makeApi(sinon);
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }
}(typeof sinon == "object" && sinon || null));

}).call(this,require("1YiZ5S"))
},{"./extend":43,"./util/core":55,"1YiZ5S":114}],41:[function(require,module,exports){
/**
  * @depend util/core.js
  * @depend match.js
  * @depend format.js
  */
/**
  * 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
  */
"use strict";

(function (sinon) {
    function makeApi(sinon) {
        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() {
                var l = arguments.length;
                if (l > this.args.length) {
                    return false;
                }
                for (var i = 0; i < l; i += 1) {
                    if (!sinon.deepEqual(arguments[i], this.args[i])) {
                        return false;
                    }
                }

                return true;
            },

            calledWithMatch: function calledWithMatch() {
                var l = arguments.length;
                if (l > this.args.length) {
                    return false;
                }
                for (var i = 0; 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

        sinon.spyCall = createSpyCall;
        return createSpyCall;
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        require("./match");
        require("./format");
        module.exports = makeApi(sinon);
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }
}(typeof sinon == "object" && sinon || null));

},{"./format":44,"./match":46,"./util/core":55}],42:[function(require,module,exports){
/**
 * @depend util/core.js
 * @depend spy.js
 * @depend stub.js
 * @depend mock.js
 */
/**
 * Collections of stubs, spies and mocks.
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */
"use strict";

(function (sinon) {
    var push = [].push;
    var hasOwnProperty = Object.prototype.hasOwnProperty;

    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);
        }
    }

    function makeApi(sinon) {
        var collection = {
            verify: function resolve() {
                each(this, "verify");
            },

            restore: function restore() {
                each(this, "restore");
                compact(this);
            },

            reset: function restore() {
                each(this, "reset");
            },

            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;
            }
        };

        sinon.collection = collection;
        return collection;
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        require("./mock");
        require("./spy");
        require("./stub");
        module.exports = makeApi(sinon);
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }
}(typeof sinon == "object" && sinon || null));

},{"./mock":47,"./spy":49,"./stub":50,"./util/core":55}],43:[function(require,module,exports){
/**
 * @depend util/core.js
 */
"use strict";

(function (sinon) {
    function makeApi(sinon) {

        // Adapted from https://developer.mozilla.org/en/docs/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug
        var hasDontEnumBug = (function () {
            var obj = {
                constructor: function () {
                    return "0";
                },
                toString: function () {
                    return "1";
                },
                valueOf: function () {
                    return "2";
                },
                toLocaleString: function () {
                    return "3";
                },
                prototype: function () {
                    return "4";
                },
                isPrototypeOf: function () {
                    return "5";
                },
                propertyIsEnumerable: function () {
                    return "6";
                },
                hasOwnProperty: function () {
                    return "7";
                },
                length: function () {
                    return "8";
                },
                unique: function () {
                    return "9"
                }
            };

            var result = [];
            for (var prop in obj) {
                result.push(obj[prop]());
            }
            return result.join("") !== "0123456789";
        })();

        /* Public: Extend target in place with all (own) properties from sources in-order. Thus, last source will
         *         override properties in previous sources.
         *
         * target - The Object to extend
         * sources - Objects to copy properties from.
         *
         * Returns the extended target
         */
        function extend(target /*, sources */) {
            var sources = Array.prototype.slice.call(arguments, 1),
                source, i, prop;

            for (i = 0; i < sources.length; i++) {
                source = sources[i];

                for (prop in source) {
                    if (source.hasOwnProperty(prop)) {
                        target[prop] = source[prop];
                    }
                }

                // Make sure we copy (own) toString method even when in JScript with DontEnum bug
                // See https://developer.mozilla.org/en/docs/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug
                if (hasDontEnumBug && source.hasOwnProperty("toString") && source.toString !== target.toString) {
                    target.toString = source.toString;
                }
            }

            return target;
        };

        sinon.extend = extend;
        return sinon.extend;
    }

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        module.exports = makeApi(sinon);
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }
}(typeof sinon == "object" && sinon || null));

},{"./util/core":55}],44:[function(require,module,exports){
/**
 * @depend util/core.js
 */
/**
 * Format functions
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2014 Christian Johansen
 */
"use strict";

(function (sinon, formatio) {
    function makeApi(sinon) {
        function valueFormatter(value) {
            return "" + value;
        }

        function getFormatioFormatter() {
            var formatter = formatio.configure({
                    quoteStrings: false,
                    limitChildrenCount: 250
                });

            function format() {
                return formatter.ascii.apply(formatter, arguments);
            };

            return format;
        }

        function getNodeFormatter(value) {
            function format(value) {
                return typeof value == "object" && value.toString === Object.prototype.toString ? util.inspect(value) : value;
            };

            try {
                var util = require("util");
            } catch (e) {
                /* Node, but no util module - would be very old, but better safe than sorry */
            }

            return util ? format : valueFormatter;
        }

        var isNode = typeof module !== "undefined" && module.exports && typeof require == "function",
            formatter;

        if (isNode) {
            try {
                formatio = require("formatio");
            } catch (e) {}
        }

        if (formatio) {
            formatter = getFormatioFormatter()
        } else if (isNode) {
            formatter = getNodeFormatter();
        } else {
            formatter = valueFormatter;
        }

        sinon.format = formatter;
        return sinon.format;
    }

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        module.exports = makeApi(sinon);
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }
}(
    (typeof sinon == "object" && sinon || null),
    (typeof formatio == "object" && formatio)
));

},{"./util/core":55,"formatio":62,"util":116}],45:[function(require,module,exports){
/**
 * @depend util/core.js
 */
/**
 * Logs errors
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2014 Christian Johansen
 */
"use strict";

(function (sinon) {
    // cache a reference to setTimeout, so that our reference won't be stubbed out
    // when using fake timers and errors will still get logged
    // https://github.com/cjohansen/Sinon.JS/issues/381
    var realSetTimeout = setTimeout;

    function makeApi(sinon) {

        function log() {}

        function logError(label, err) {
            var msg = label + " threw exception: ";

            sinon.log(msg + "[" + err.name + "] " + err.message);

            if (err.stack) {
                sinon.log(err.stack);
            }

            logError.setTimeout(function () {
                err.message = msg + err.message;
                throw err;
            }, 0);
        };

        // wrap realSetTimeout with something we can stub in tests
        logError.setTimeout = function (func, timeout) {
            realSetTimeout(func, timeout);
        }

        var exports = {};
        exports.log = sinon.log = log;
        exports.logError = sinon.logError = logError;

        return exports;
    }

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        module.exports = makeApi(sinon);
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }
}(typeof sinon == "object" && sinon || null));

},{"./util/core":55}],46:[function(require,module,exports){
/**
 * @depend util/core.js
 * @depend typeOf.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
 */
"use strict";

(function (sinon) {
    function makeApi(sinon) {
        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");

        sinon.match = match;
        return match;
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        require("./typeOf");
        module.exports = makeApi(sinon);
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }
}(typeof sinon == "object" && sinon || null));

},{"./typeOf":54,"./util/core":55}],47:[function(require,module,exports){
/**
 * @depend times_in_words.js
 * @depend util/core.js
 * @depend call.js
 * @depend extend.js
 * @depend match.js
 * @depend spy.js
 * @depend stub.js
 * @depend format.js
 */
/**
 * Mock functions.
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */
"use strict";

(function (sinon) {
    function makeApi(sinon) {
        var push = [].push;
        var match = sinon.match;

        function mock(object) {
            if (!object) {
                return sinon.expectation.create("Anonymous mock");
            }

            return mock.create(object);
        }

        function each(collection, callback) {
            if (!collection) {
                return;
            }

            for (var i = 0, l = collection.length; i < l; i += 1) {
                callback(collection[i]);
            }
        }

        sinon.extend(mock, {
            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 if (met.length > 0) {
                    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;
        var slice = Array.prototype.slice;

        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;
            }
        }

        sinon.expectation = {
            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 sinon.spy.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 pass(message) {
                sinon.assert.pass(message);
            },

            fail: function fail(message) {
                var exception = new Error(message);
                exception.name = "ExpectationError";

                throw exception;
            }
        };

        sinon.mock = mock;
        return mock;
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        require("./times_in_words");
        require("./call");
        require("./extend");
        require("./match");
        require("./spy");
        require("./stub");
        require("./format");

        module.exports = makeApi(sinon);
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }
}(typeof sinon == "object" && sinon || null));

},{"./call":41,"./extend":43,"./format":44,"./match":46,"./spy":49,"./stub":50,"./times_in_words":53,"./util/core":55}],48:[function(require,module,exports){
/**
 * @depend util/core.js
 * @depend extend.js
 * @depend collection.js
 * @depend util/fake_timers.js
 * @depend util/fake_server_with_clock.js
 */
/**
 * 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
 */
"use strict";

(function () {
    function makeApi(sinon) {
        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;
                }

                obj.match = sinon.match;

                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;
            },

            match: sinon.match
        });

        sinon.sandbox.useFakeXMLHttpRequest = sinon.sandbox.useFakeServer;

        return sinon.sandbox;
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        require("./extend");
        require("./util/fake_server_with_clock");
        require("./util/fake_timers");
        require("./collection");
        module.exports = makeApi(sinon);
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }
}());

},{"./collection":42,"./extend":43,"./util/core":55,"./util/fake_server_with_clock":58,"./util/fake_timers":59}],49:[function(require,module,exports){
/**
  * @depend times_in_words.js
  * @depend util/core.js
  * @depend extend.js
  * @depend call.js
  * @depend format.js
  */
/**
  * Spy functions
  *
  * @author Christian Johansen (christian@cjohansen.no)
  * @license BSD
  *
  * Copyright (c) 2010-2013 Christian Johansen
  */
"use strict";

(function (sinon) {

    function makeApi(sinon) {
        var push = Array.prototype.push;
        var slice = Array.prototype.slice;
        var callId = 0;

        function spy(object, property, types) {
            if (!property && typeof object == "function") {
                return spy.create(object);
            }

            if (!object && !property) {
                return spy.create(function () { });
            }

            if (types) {
                var methodDesc = sinon.getPropertyDescriptor(object, property);
                for (var i = 0; i < types.length; i++) {
                    methodDesc[types[i]] = spy.create(methodDesc[types[i]]);
                }
                return sinon.wrapMethod(object, property, methodDesc);
            } else {
                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, proxyLength) {
            // Retain the function length:
            var p;
            if (proxyLength) {
                eval("p = (function proxy(" + vars.substring(0, proxyLength * 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 () {
                if (this.invoking) {
                    var err = new Error("Cannot reset Sinon function while invoking it. " +
                                        "Move the call to .reset outside of the callback.");
                    err.name = "InvalidResetException";
                    throw err;
                }

                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();
                    }
                }

                return this;
            },

            create: function create(func, spyLength) {
                var name;

                if (typeof func != "function") {
                    func = function () { };
                } else {
                    name = sinon.functionName(func);
                }

                if (!spyLength) {
                    spyLength = func.length;
                }

                var proxy = createProxy(func, spyLength);

                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.instantiateFake = 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++);

                // Make call properties available from within the spied function:
                createCallProperties.call(this);

                try {
                    this.invoking = true;

                    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;
                } finally {
                    delete this.invoking;
                }

                push.call(this.exceptions, exception);
                push.call(this.returnValues, returnValue);

                // Make return value and exception available in the calls:
                createCallProperties.call(this);

                if (exception !== undefined) {
                    throw exception;
                }

                return returnValue;
            },

            named: function named(name) {
                this.displayName = name;
                return this;
            },

            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.instantiateFake();
                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;
        sinon.spy = spy;

        return spy;
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        require("./call");
        require("./extend");
        require("./times_in_words");
        require("./format");
        module.exports = makeApi(sinon);
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }
}(typeof sinon == "object" && sinon || null));

},{"./call":41,"./extend":43,"./format":44,"./times_in_words":53,"./util/core":55}],50:[function(require,module,exports){
/**
 * @depend util/core.js
 * @depend extend.js
 * @depend spy.js
 * @depend behavior.js
 */
/**
 * Stub functions
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */
"use strict";

(function (sinon) {
    function makeApi(sinon) {
        function stub(object, property, func) {
            if (!!func && typeof func != "function" && typeof func != "object") {
                throw new TypeError("Custom stub should be a function or a property descriptor");
            }

            var wrapper;

            if (func) {
                if (typeof func == "function") {
                    wrapper = sinon.spy && sinon.spy.create ? sinon.spy.create(func) : func;
                } else {
                    wrapper = func;
                    if (sinon.spy && sinon.spy.create) {
                        var types = sinon.objectKeys(wrapper);
                        for (var i = 0; i < types.length; i++) {
                            wrapper[types[i]] = sinon.spy.create(wrapper[types[i]]);
                        }
                    }
                }
            } else {
                var stubLength = 0;
                if (typeof object == "object" && typeof object[property] == "function") {
                    stubLength = object[property].length;
                }
                wrapper = stub.create(stubLength);
            }

            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;

        var proto = {
            create: function create(stubLength) {
                var functionStub = function () {
                    return getCurrentBehavior(functionStub).invoke(this, arguments);
                };

                functionStub.id = "stub#" + uuid++;
                var orig = functionStub;
                functionStub = sinon.spy.create(functionStub, stubLength);
                functionStub.func = orig;

                sinon.extend(functionStub, stub);
                functionStub.instantiateFake = 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 onCall(index) {
                if (!this.behaviors[index]) {
                    this.behaviors[index] = sinon.behavior.create(this);
                }

                return this.behaviors[index];
            },

            onFirstCall: function onFirstCall() {
                return this.onCall(0);
            },

            onSecondCall: function onSecondCall() {
                return this.onCall(1);
            },

            onThirdCall: function onThirdCall() {
                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));
            }
        }

        sinon.extend(stub, proto);
        sinon.stub = stub;

        return stub;
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        require("./behavior");
        require("./spy");
        require("./extend");
        module.exports = makeApi(sinon);
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }
}(typeof sinon == "object" && sinon || null));

},{"./behavior":40,"./extend":43,"./spy":49,"./util/core":55}],51:[function(require,module,exports){
/**
 * @depend util/core.js
 * @depend sandbox.js
 */
/**
 * Test function, sandboxes fakes
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */
"use strict";

(function (sinon) {
    function makeApi(sinon) {
        var slice = Array.prototype.slice;

        function test(callback) {
            var type = typeof callback;

            if (type != "function") {
                throw new TypeError("sinon.test needs to wrap a test function, got " + type);
            }

            function sinonSandboxedTest() {
                var config = sinon.getConfig(sinon.config);
                config.injectInto = config.injectIntoThis && this || config.injectInto;
                var sandbox = sinon.sandbox.create(config);
                var args = slice.call(arguments);
                var oldDone = args.length && args[args.length - 1];
                var exception, result;

                if (typeof oldDone == "function") {
                    args[args.length - 1] = function sinonDone(result) {
                        if (result) {
                            sandbox.restore();
                            throw exception;
                        } else {
                            sandbox.verifyAndRestore();
                        }
                        oldDone(result);
                    };
                }

                try {
                    result = callback.apply(this, args.concat(sandbox.args));
                } catch (e) {
                    exception = e;
                }

                if (typeof oldDone != "function") {
                    if (typeof exception !== "undefined") {
                        sandbox.restore();
                        throw exception;
                    } else {
                        sandbox.verifyAndRestore();
                    }
                }

                return result;
            }

            if (callback.length) {
                return function sinonAsyncSandboxedTest(callback) {
                    return sinonSandboxedTest.apply(this, arguments);
                };
            }

            return sinonSandboxedTest;
        }

        test.config = {
            injectIntoThis: true,
            injectInto: null,
            properties: ["spy", "stub", "mock", "clock", "server", "requests"],
            useFakeTimers: true,
            useFakeServer: true
        };

        sinon.test = test;
        return test;
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        require("./sandbox");
        module.exports = makeApi(sinon);
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (sinon) {
        makeApi(sinon);
    }
}(typeof sinon == "object" && sinon || null));

},{"./sandbox":48,"./util/core":55}],52:[function(require,module,exports){
/**
 * @depend util/core.js
 * @depend test.js
 */
/**
 * Test case, sandboxes all test functions
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */
"use strict";

(function (sinon) {
    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 makeApi(sinon) {
        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;
        }

        sinon.testCase = testCase;
        return testCase;
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        require("./test");
        module.exports = makeApi(sinon);
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }
}(typeof sinon == "object" && sinon || null));

},{"./test":51,"./util/core":55}],53:[function(require,module,exports){
/**
 * @depend util/core.js
 */
"use strict";

(function (sinon) {
    function makeApi(sinon) {

        function timesInWords(count) {
            switch (count) {
                case 1:
                    return "once";
                case 2:
                    return "twice";
                case 3:
                    return "thrice";
                default:
                    return (count || 0) + " times";
            }
        }

        sinon.timesInWords = timesInWords;
        return sinon.timesInWords;
    }

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        module.exports = makeApi(sinon);
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }
}(typeof sinon == "object" && sinon || null));

},{"./util/core":55}],54:[function(require,module,exports){
/**
 * @depend util/core.js
 */
/**
 * Format functions
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2014 Christian Johansen
 */
"use strict";

(function (sinon, formatio) {
    function makeApi(sinon) {
        function typeOf(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();
        };

        sinon.typeOf = typeOf;
        return sinon.typeOf;
    }

    function loadDependencies(require, exports, module) {
        var sinon = require("./util/core");
        module.exports = makeApi(sinon);
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }
}(
    (typeof sinon == "object" && sinon || null),
    (typeof formatio == "object" && formatio)
));

},{"./util/core":55}],55:[function(require,module,exports){
/**
 * @depend ../../sinon.js
 */
/**
 * Sinon core utilities. For internal use only.
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */
"use strict";

(function (sinon) {
    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 isReallyNaN(val) {
        return typeof val === "number" && isNaN(val);
    }

    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;
    }

    // Cheap way to detect if we have ES5 support.
    var hasES5Support = "keys" in Object;

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

            if (typeof method != "function" && typeof method != "object") {
                throw new TypeError("Method wrapper should be a function or a property descriptor");
            }

            function checkWrappedMethod(wrappedMethod) {
                if (!isFunction(wrappedMethod)) {
                    error = new TypeError("Attempted to wrap " + (typeof wrappedMethod) + " property " +
                                        property + " as function");
                } else if (wrappedMethod.restore && wrappedMethod.restore.sinon) {
                    error = new TypeError("Attempted to wrap " + property + " which is already wrapped");
                } else 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 && wrappedMethod.stackTrace) {
                        error.stack += "\n--------------\n" + wrappedMethod.stackTrace;
                    }
                    throw error;
                }
            }

            var error, wrappedMethod;

            // 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);

            if (hasES5Support) {
                var methodDesc = (typeof method == "function") ? {value: method} : method,
                    wrappedMethodDesc = sinon.getPropertyDescriptor(object, property),
                    i;

                if (!wrappedMethodDesc) {
                    error = new TypeError("Attempted to wrap " + (typeof wrappedMethod) + " property " +
                                        property + " as function");
                } else if (wrappedMethodDesc.restore && wrappedMethodDesc.restore.sinon) {
                    error = new TypeError("Attempted to wrap " + property + " which is already wrapped");
                }
                if (error) {
                    if (wrappedMethodDesc && wrappedMethodDesc.stackTrace) {
                        error.stack += "\n--------------\n" + wrappedMethodDesc.stackTrace;
                    }
                    throw error;
                }

                var types = sinon.objectKeys(methodDesc);
                for (i = 0; i < types.length; i++) {
                    wrappedMethod = wrappedMethodDesc[types[i]];
                    checkWrappedMethod(wrappedMethod);
                }

                mirrorProperties(methodDesc, wrappedMethodDesc);
                for (i = 0; i < types.length; i++) {
                    mirrorProperties(methodDesc[types[i]], wrappedMethodDesc[types[i]]);
                }
                Object.defineProperty(object, property, methodDesc);
            } else {
                wrappedMethod = object[property];
                checkWrappedMethod(wrappedMethod);
                object[property] = method;
                method.displayName = property;
            }

            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.stackTrace = (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) {
                    try {
                        delete object[property];
                    } catch (e) {}
                    // For native code functions `delete` fails without throwing an error
                    // on Chrome < 43, PhantomJS, etc.
                    // Use strict equality comparison to check failures then force a reset
                    // via direct assignment.
                    if (object[property] === method) {
                        object[property] = wrappedMethod;
                    }
                } else if (hasES5Support) {
                    Object.defineProperty(object, property, wrappedMethodDesc);
                }

                if (!hasES5Support && object[property] === method) {
                    object[property] = wrappedMethod;
                }
            };

            method.restore.sinon = true;

            if (!hasES5Support) {
                mirrorProperties(method, wrappedMethod);
            }

            return method;
        };

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

        sinon.deepEqual = function deepEqual(a, b) {
            if (sinon.match && sinon.match.isMatcher(a)) {
                return a.test(b);
            }

            if (typeof a != "object" || typeof b != "object") {
                if (isReallyNaN(a) && isReallyNaN(b)) {
                    return true;
                } else {
                    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 (!(prop in b)) {
                    return false;
                }

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

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

            return aLength == bLength;
        };

        sinon.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;
        };

        sinon.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";
        };

        sinon.objectKeys = function objectKeys(obj) {
            if (obj !== Object(obj)) {
                throw new TypeError("sinon.objectKeys called on a non-object");
            }

            var keys = [];
            var key;
            for (key in obj) {
                if (hasOwn.call(obj, key)) {
                    keys.push(key);
                }
            }

            return keys;
        };

        sinon.getPropertyDescriptor = function getPropertyDescriptor(object, property) {
            var proto = object, descriptor;
            while (proto && !(descriptor = Object.getOwnPropertyDescriptor(proto, property))) {
                proto = Object.getPrototypeOf(proto);
            }
            return descriptor;
        }

        sinon.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;
        };

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

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

        sinon.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;
        };

        sinon.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;
            });
        };

        sinon.createStubInstance = function (constructor) {
            if (typeof constructor !== "function") {
                throw new TypeError("The constructor should be a function.");
            }
            return sinon.stub(sinon.create(constructor.prototype));
        };

        sinon.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();
            }
        };

        return sinon;
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports) {
        makeApi(exports);
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports);
    } else if (!sinon) {
        return;
    } else {
        makeApi(sinon);
    }
}(typeof sinon == "object" && sinon || null));

},{}],56:[function(require,module,exports){
/**
 * 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
 */
"use strict";

if (typeof sinon == "undefined") {
    this.sinon = {};
}

(function () {
    var push = [].push;

    function makeApi(sinon) {
        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;
            this.lengthComputable = !!progressEventRaw.total;
        };

        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;
            }
        };
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require) {
        var sinon = require("./core");
        makeApi(sinon);
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require);
    } else {
        makeApi(sinon);
    }
}());

},{"./core":55}],57:[function(require,module,exports){
/**
 * @depend fake_xdomain_request.js
 * @depend fake_xml_http_request.js
 * @depend ../format.js
 * @depend ../log_error.js
 */
/**
 * 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
 */
"use strict";

if (typeof sinon == "undefined") {
    var sinon = {};
}

(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 makeApi(sinon) {
        sinon.fakeServer = {
            create: function () {
                var server = create(this);
                if (!sinon.xhr.supportsCORS) {
                    this.xhr = sinon.useFakeXDomainRequest();
                } else {
                    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.respondImmediately) {
                        server.respond();
                    } else 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);
                }
            },

            log: 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);
            },

            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, queue.length);
                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) {
                        this.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);
            }
        };
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports, module) {
        var sinon = require("./core");
        require("./fake_xdomain_request");
        require("./fake_xml_http_request");
        require("../format");
        makeApi(sinon);
        module.exports = sinon;
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else {
        makeApi(sinon);
    }
}());

},{"../format":44,"./core":55,"./fake_xdomain_request":60,"./fake_xml_http_request":61}],58:[function(require,module,exports){
/**
 * @depend fake_server.js
 * @depend fake_timers.js
 */
/**
 * 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
 */
"use strict";

(function () {
    function makeApi(sinon) {
        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);
        };
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require) {
        var sinon = require("./core");
        require("./fake_server");
        require("./fake_timers");
        makeApi(sinon);
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require);
    } else {
        makeApi(sinon);
    }
}());

},{"./core":55,"./fake_server":57,"./fake_timers":59}],59:[function(require,module,exports){
(function (global){
/*global lolex */

/**
 * 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
 */
"use strict";

if (typeof sinon == "undefined") {
    var sinon = {};
}

(function (global) {
    function makeApi(sinon, lol) {
        var llx = typeof lolex !== "undefined" ? lolex : lol;

        sinon.useFakeTimers = function () {
            var now, methods = Array.prototype.slice.call(arguments);

            if (typeof methods[0] === "string") {
                now = 0;
            } else {
                now = methods.shift();
            }

            var clock = llx.install(now || 0, methods);
            clock.restore = clock.uninstall;
            return clock;
        };

        sinon.clock = {
            create: function (now) {
                return llx.createClock(now);
            }
        };

        sinon.timers = {
            setTimeout: setTimeout,
            clearTimeout: clearTimeout,
            setImmediate: (typeof setImmediate !== "undefined" ? setImmediate : undefined),
            clearImmediate: (typeof clearImmediate !== "undefined" ? clearImmediate : undefined),
            setInterval: setInterval,
            clearInterval: clearInterval,
            Date: Date
        };
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, epxorts, module, lolex) {
        var sinon = require("./core");
        makeApi(sinon, lolex);
        module.exports = sinon;
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module, require("lolex"));
    } else {
        makeApi(sinon);
    }
}(typeof global != "undefined" && typeof global !== "function" ? global : this));

}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"./core":55,"lolex":64}],60:[function(require,module,exports){
/**
 * @depend core.js
 * @depend ../extend.js
 * @depend event.js
 * @depend ../log_error.js
 */
/**
 * Fake XDomainRequest object
 */
"use strict";

if (typeof sinon == "undefined") {
    this.sinon = {};
}

// wrapper for global
(function (global) {
    var xdr = { XDomainRequest: global.XDomainRequest };
    xdr.GlobalXDomainRequest = global.XDomainRequest;
    xdr.supportsXDR = typeof xdr.GlobalXDomainRequest != "undefined";
    xdr.workingXDR = xdr.supportsXDR ? xdr.GlobalXDomainRequest :  false;

    function makeApi(sinon) {
        sinon.xdr = xdr;

        function FakeXDomainRequest() {
            this.readyState = FakeXDomainRequest.UNSENT;
            this.requestBody = null;
            this.requestHeaders = {};
            this.status = 0;
            this.timeout = null;

            if (typeof FakeXDomainRequest.onCreate == "function") {
                FakeXDomainRequest.onCreate(this);
            }
        }

        function verifyState(xdr) {
            if (xdr.readyState !== FakeXDomainRequest.OPENED) {
                throw new Error("INVALID_STATE_ERR");
            }

            if (xdr.sendFlag) {
                throw new Error("INVALID_STATE_ERR");
            }
        }

        function verifyRequestSent(xdr) {
            if (xdr.readyState == FakeXDomainRequest.UNSENT) {
                throw new Error("Request not sent");
            }
            if (xdr.readyState == FakeXDomainRequest.DONE) {
                throw new Error("Request done");
            }
        }

        function verifyResponseBodyType(body) {
            if (typeof body != "string") {
                var error = new Error("Attempted to respond to fake XDomainRequest with " +
                                    body + ", which is not a string.");
                error.name = "InvalidBodyException";
                throw error;
            }
        }

        sinon.extend(FakeXDomainRequest.prototype, sinon.EventTarget, {
            open: function open(method, url) {
                this.method = method;
                this.url = url;

                this.responseText = null;
                this.sendFlag = false;

                this.readyStateChange(FakeXDomainRequest.OPENED);
            },

            readyStateChange: function readyStateChange(state) {
                this.readyState = state;
                var eventName = "";
                switch (this.readyState) {
                case FakeXDomainRequest.UNSENT:
                    break;
                case FakeXDomainRequest.OPENED:
                    break;
                case FakeXDomainRequest.LOADING:
                    if (this.sendFlag) {
                        //raise the progress event
                        eventName = "onprogress";
                    }
                    break;
                case FakeXDomainRequest.DONE:
                    if (this.isTimeout) {
                        eventName = "ontimeout"
                    } else if (this.errorFlag || (this.status < 200 || this.status > 299)) {
                        eventName = "onerror";
                    } else {
                        eventName = "onload"
                    }
                    break;
                }

                // raising event (if defined)
                if (eventName) {
                    if (typeof this[eventName] == "function") {
                        try {
                            this[eventName]();
                        } catch (e) {
                            sinon.logError("Fake XHR " + eventName + " handler", e);
                        }
                    }
                }
            },

            send: function send(data) {
                verifyState(this);

                if (!/^(get|head)$/i.test(this.method)) {
                    this.requestBody = data;
                }
                this.requestHeaders["Content-Type"] = "text/plain;charset=utf-8";

                this.errorFlag = false;
                this.sendFlag = true;
                this.readyStateChange(FakeXDomainRequest.OPENED);

                if (typeof this.onSend == "function") {
                    this.onSend(this);
                }
            },

            abort: function abort() {
                this.aborted = true;
                this.responseText = null;
                this.errorFlag = true;

                if (this.readyState > sinon.FakeXDomainRequest.UNSENT && this.sendFlag) {
                    this.readyStateChange(sinon.FakeXDomainRequest.DONE);
                    this.sendFlag = false;
                }
            },

            setResponseBody: function setResponseBody(body) {
                verifyRequestSent(this);
                verifyResponseBodyType(body);

                var chunkSize = this.chunkSize || 10;
                var index = 0;
                this.responseText = "";

                do {
                    this.readyStateChange(FakeXDomainRequest.LOADING);
                    this.responseText += body.substring(index, index + chunkSize);
                    index += chunkSize;
                } while (index < body.length);

                this.readyStateChange(FakeXDomainRequest.DONE);
            },

            respond: function respond(status, contentType, body) {
                // content-type ignored, since XDomainRequest does not carry this
                // we keep the same syntax for respond(...) as for FakeXMLHttpRequest to ease
                // test integration across browsers
                this.status = typeof status == "number" ? status : 200;
                this.setResponseBody(body || "");
            },

            simulatetimeout: function simulatetimeout() {
                this.status = 0;
                this.isTimeout = true;
                // Access to this should actually throw an error
                this.responseText = undefined;
                this.readyStateChange(FakeXDomainRequest.DONE);
            }
        });

        sinon.extend(FakeXDomainRequest, {
            UNSENT: 0,
            OPENED: 1,
            LOADING: 3,
            DONE: 4
        });

        sinon.useFakeXDomainRequest = function useFakeXDomainRequest() {
            sinon.FakeXDomainRequest.restore = function restore(keepOnCreate) {
                if (xdr.supportsXDR) {
                    global.XDomainRequest = xdr.GlobalXDomainRequest;
                }

                delete sinon.FakeXDomainRequest.restore;

                if (keepOnCreate !== true) {
                    delete sinon.FakeXDomainRequest.onCreate;
                }
            };
            if (xdr.supportsXDR) {
                global.XDomainRequest = sinon.FakeXDomainRequest;
            }
            return sinon.FakeXDomainRequest;
        };

        sinon.FakeXDomainRequest = FakeXDomainRequest;
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports, module) {
        var sinon = require("./core");
        require("../extend");
        require("./event");
        require("../log_error");
        makeApi(sinon);
        module.exports = sinon;
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else {
        makeApi(sinon);
    }
})(this);

},{"../extend":43,"../log_error":45,"./core":55,"./event":56}],61:[function(require,module,exports){
(function (global){
/**
 * @depend core.js
 * @depend ../extend.js
 * @depend event.js
 * @depend ../log_error.js
 */
/**
 * Fake XMLHttpRequest object
 *
 * @author Christian Johansen (christian@cjohansen.no)
 * @license BSD
 *
 * Copyright (c) 2010-2013 Christian Johansen
 */
"use strict";

(function (global) {

    var supportsProgress = typeof ProgressEvent !== "undefined";
    var supportsCustomEvent = typeof CustomEvent !== "undefined";
    var sinonXhr = { XMLHttpRequest: global.XMLHttpRequest };
    sinonXhr.GlobalXMLHttpRequest = global.XMLHttpRequest;
    sinonXhr.GlobalActiveXObject = global.ActiveXObject;
    sinonXhr.supportsActiveX = typeof sinonXhr.GlobalActiveXObject != "undefined";
    sinonXhr.supportsXHR = typeof sinonXhr.GlobalXMLHttpRequest != "undefined";
    sinonXhr.workingXHR = sinonXhr.supportsXHR ? sinonXhr.GlobalXMLHttpRequest : sinonXhr.supportsActiveX
                                     ? function () { return new sinonXhr.GlobalActiveXObject("MSXML2.XMLHTTP.3.0") } : false;
    sinonXhr.supportsCORS = sinonXhr.supportsXHR && "withCredentials" in (new sinonXhr.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 (sinonXhr.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 addEventListener(event, listener) {
        this.eventListeners[event].push(listener);
    };

    UploadProgress.prototype.removeEventListener = function removeEventListener(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 dispatchEvent(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");
        }
    }

    function getHeader(headers, header) {
        header = header.toLowerCase();

        for (var h in headers) {
            if (h.toLowerCase() == header) {
                return h;
            }
        }

        return null;
    }

    // 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 addFilter(fn) {
        this.filters.push(fn)
    };
    var IE6Re = /MSIE 6/;
    FakeXMLHttpRequest.defake = function defake(fakeXhr, xhrArgs) {
        var xhr = new sinonXhr.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 stateChange() {
            fakeXhr.readyState = xhr.readyState;
            if (xhr.readyState >= FakeXMLHttpRequest.HEADERS_RECEIVED) {
                copyAttrs(["status", "statusText"]);
            }
            if (xhr.readyState >= FakeXMLHttpRequest.LOADING) {
                copyAttrs(["responseText", "response"]);
            }
            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;
        }
    }

    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",
        207: "Multi-Status",
        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"
    };

    function makeApi(sinon) {
        sinon.xhr = sinonXhr;

        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 (FakeXMLHttpRequest.useFilters === true) {
                    var xhrArgs = arguments;
                    var defake = some(FakeXMLHttpRequest.filters, function (filter) {
                        return filter.apply(this, xhrArgs)
                    });
                    if (defake) {
                        return 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}));
                            this.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)) {
                    var contentType = getHeader(this.requestHeaders, "Content-Type");
                    if (this.requestHeaders[contentType]) {
                        var value = this.requestHeaders[contentType].split(";");
                        this.requestHeaders[contentType] = value[0] + ";charset=utf-8";
                    } else if (!(data instanceof FormData)) {
                        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 > FakeXMLHttpRequest.UNSENT && this.sendFlag) {
                    this.readyStateChange(FakeXMLHttpRequest.DONE);
                    this.sendFlag = false;
                }

                this.readyState = 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 = getHeader(this.responseHeaders, header);

                return this.responseHeaders[header] || 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
                    }
                }

                this.readyStateChange(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));
                }
            },

            downloadProgress: function downloadProgress(progressEventRaw) {
                if (supportsProgress) {
                    this.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
        });

        sinon.useFakeXMLHttpRequest = function () {
            FakeXMLHttpRequest.restore = function restore(keepOnCreate) {
                if (sinonXhr.supportsXHR) {
                    global.XMLHttpRequest = sinonXhr.GlobalXMLHttpRequest;
                }

                if (sinonXhr.supportsActiveX) {
                    global.ActiveXObject = sinonXhr.GlobalActiveXObject;
                }

                delete FakeXMLHttpRequest.restore;

                if (keepOnCreate !== true) {
                    delete FakeXMLHttpRequest.onCreate;
                }
            };
            if (sinonXhr.supportsXHR) {
                global.XMLHttpRequest = FakeXMLHttpRequest;
            }

            if (sinonXhr.supportsActiveX) {
                global.ActiveXObject = function ActiveXObject(objId) {
                    if (objId == "Microsoft.XMLHTTP" || /^Msxml2\.XMLHTTP/i.test(objId)) {

                        return new FakeXMLHttpRequest();
                    }

                    return new sinonXhr.GlobalActiveXObject(objId);
                };
            }

            return FakeXMLHttpRequest;
        };

        sinon.FakeXMLHttpRequest = FakeXMLHttpRequest;
    }

    var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
    var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;

    function loadDependencies(require, exports, module) {
        var sinon = require("./core");
        require("../extend");
        require("./event");
        require("../log_error");
        makeApi(sinon);
        module.exports = sinon;
    }

    if (isAMD) {
        define(loadDependencies);
    } else if (isNode) {
        loadDependencies(require, module.exports, module);
    } else if (typeof sinon === "undefined") {
        return;
    } else {
        makeApi(sinon);
    }

})(typeof global !== "undefined" ? global : this);

}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"../extend":43,"../log_error":45,"./core":55,"./event":56}],62:[function(require,module,exports){
(function (global){
((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) {
    "use strict";

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

    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 pieces = [];
        var i, l;
        l = (this.limitChildrenCount > 0) ? 
            Math.min(this.limitChildrenCount, array.length) : array.length;

        for (i = 0; i < l; ++i) {
            pieces.push(ascii(this, array[i], processed));
        }

        if(l < array.length)
            pieces.push("[... " + (array.length - l) + " more elements]");

        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, k, l;
        l = (this.limitChildrenCount > 0) ? 
            Math.min(this.limitChildrenCount, properties.length) : properties.length;

        for (i = 0; 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, k = indent; i < k; ++i) { is += " "; }

        if(l < properties.length)
            pieces.push("[... " + (properties.length - l) + " more elements]");

        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;
});

}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"samsam":63}],63:[function(require,module,exports){
((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 (getClass(object) === 'Arguments') { return true; }
        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 (typeof(matcher) === "undefined") {
            return typeof(object) === "undefined";
        }

        if (matcher === null) {
            return object === null;
        }

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

        if (matcher && typeof matcher === "object") {
            if (matcher === object) {
                return true;
            }
            var prop;
            for (prop in matcher) {
                var value = object[prop];
                if (typeof value === "undefined" &&
                        typeof object.getAttribute === "function") {
                    value = object.getAttribute(prop);
                }
                if (matcher[prop] === null || typeof matcher[prop] === 'undefined') {
                    if (value !== matcher[prop]) {
                        return false;
                    }
                } else if (typeof  value === "undefined" || !match(value, 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
    };
});

},{}],64:[function(require,module,exports){
(function (global){
/*jslint eqeqeq: false, plusplus: false, evil: true, onevar: false, browser: true, forin: false*/
/*global global*/
/**
 * @author Christian Johansen (christian@cjohansen.no) and contributors
 * @license BSD
 *
 * Copyright (c) 2010-2014 Christian Johansen
 */
"use strict";

// node expects setTimeout/setInterval to return a fn object w/ .ref()/.unref()
// browsers, a number.
// see https://github.com/cjohansen/Sinon.JS/pull/436
var timeoutResult = setTimeout(function() {}, 0);
var addTimerReturnsObject = typeof timeoutResult === "object";
clearTimeout(timeoutResult);

var NativeDate = Date;
var id = 1;

/**
 * Parse strings like "01:10:00" (meaning 1 hour, 10 minutes, 0 seconds) into
 * number of milliseconds. This is used to support human-readable strings passed
 * to clock.tick()
 */
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;
}

/**
 * Used to grok the `now` parameter to createClock.
 */
function getEpoch(epoch) {
    if (!epoch) { return 0; }
    if (typeof epoch.getTime === "function") { return epoch.getTime(); }
    if (typeof epoch === "number") { return epoch; }
    throw new TypeError("now should be milliseconds since UNIX epoch");
}

function inRange(from, to, timer) {
    return timer && timer.callAt >= from && timer.callAt <= to;
}

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;
}

function createDate() {
    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 addTimer(clock, timer) {
    if (typeof timer.func === "undefined") {
        throw new Error("Callback must be provided to timer calls");
    }

    if (!clock.timers) {
        clock.timers = {};
    }

    timer.id = id++;
    timer.createdAt = clock.now;
    timer.callAt = clock.now + (timer.delay || 0);

    clock.timers[timer.id] = timer;

    if (addTimerReturnsObject) {
        return {
            id: timer.id,
            ref: function() {},
            unref: function() {}
        };
    }
    else {
        return timer.id;
    }
}

function firstTimerInRange(clock, from, to) {
    var timers = clock.timers, timer = null;

    for (var id in timers) {
        if (!inRange(from, to, timers[id])) {
            continue;
        }

        if (!timer || ~compareTimers(timer, timers[id])) {
            timer = timers[id];
        }
    }

    return timer;
}

function compareTimers(a, b) {
    // Sort first by absolute timing
    if (a.callAt < b.callAt) {
        return -1;
    }
    if (a.callAt > b.callAt) {
        return 1;
    }

    // Sort next by immediate, immediate timers take precedence
    if (a.immediate && !b.immediate) {
        return -1;
    }
    if (!a.immediate && b.immediate) {
        return 1;
    }

    // Sort next by creation time, earlier-created timers take precedence
    if (a.createdAt < b.createdAt) {
        return -1;
    }
    if (a.createdAt > b.createdAt) {
        return 1;
    }

    // Sort next by id, lower-id timers take precedence
    if (a.id < b.id) {
        return -1;
    }
    if (a.id > b.id) {
        return 1;
    }

    // As timer ids are unique, no fallback `0` is necessary
}

function callTimer(clock, timer) {
    if (typeof timer.interval == "number") {
        clock.timers[timer.id].callAt += timer.interval;
    } else {
        delete clock.timers[timer.id];
    }

    try {
        if (typeof timer.func == "function") {
            timer.func.apply(null, timer.args);
        } else {
            eval(timer.func);
        }
    } catch (e) {
        var exception = e;
    }

    if (!clock.timers[timer.id]) {
        if (exception) {
            throw exception;
        }
        return;
    }

    if (exception) {
        throw exception;
    }
}

function uninstall(clock, target) {
    var method;

    for (var i = 0, l = clock.methods.length; i < l; i++) {
        method = clock.methods[i];

        if (target[method].hadOwnProperty) {
            target[method] = clock["_" + method];
        } else {
            try {
                delete target[method];
            } catch (e) {}
        }
    }

    // Prevent multiple executions which will completely remove these props
    clock.methods = [];
}

function hijackMethod(target, method, clock) {
    clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(target, method);
    clock["_" + method] = target[method];

    if (method == "Date") {
        var date = mirrorDateProperties(clock[method], target[method]);
        target[method] = date;
    } else {
        target[method] = function () {
            return clock[method].apply(clock, arguments);
        };

        for (var prop in clock[method]) {
            if (clock[method].hasOwnProperty(prop)) {
                target[method][prop] = clock[method][prop];
            }
        }
    }

    target[method].clock = clock;
}

var timers = {
    setTimeout: setTimeout,
    clearTimeout: clearTimeout,
    setImmediate: (typeof setImmediate !== "undefined" ? setImmediate : undefined),
    clearImmediate: (typeof clearImmediate !== "undefined" ? clearImmediate: undefined),
    setInterval: setInterval,
    clearInterval: clearInterval,
    Date: Date
};

var keys = Object.keys || function (obj) {
    var ks = [];
    for (var key in obj) {
        ks.push(key);
    }
    return ks;
};

exports.timers = timers;

var createClock = exports.createClock = function (now) {
    var clock = {
        now: getEpoch(now),
        timeouts: {},
        Date: createDate()
    };

    clock.Date.clock = clock;

    clock.setTimeout = function setTimeout(func, timeout) {
        return addTimer(clock, {
            func: func,
            args: Array.prototype.slice.call(arguments, 2),
            delay: timeout
        });
    };

    clock.clearTimeout = function clearTimeout(timerId) {
        if (!timerId) {
            // null appears to be allowed in most browsers, and appears to be
            // relied upon by some libraries, like Bootstrap carousel
            return;
        }
        if (!clock.timers) {
            clock.timers = [];
        }
        // in Node, timerId is an object with .ref()/.unref(), and
        // its .id field is the actual timer id.
        if (typeof timerId === "object") {
            timerId = timerId.id
        }
        if (timerId in clock.timers) {
            delete clock.timers[timerId];
        }
    };

    clock.setInterval = function setInterval(func, timeout) {
        return addTimer(clock, {
            func: func,
            args: Array.prototype.slice.call(arguments, 2),
            delay: timeout,
            interval: timeout
        });
    };

    clock.clearInterval = function clearInterval(timerId) {
        clock.clearTimeout(timerId);
    };

    clock.setImmediate = function setImmediate(func) {
        return addTimer(clock, {
            func: func,
            args: Array.prototype.slice.call(arguments, 1),
            immediate: true
        });
    };

    clock.clearImmediate = function clearImmediate(timerId) {
        clock.clearTimeout(timerId);
    };

    clock.tick = function tick(ms) {
        ms = typeof ms == "number" ? ms : parseTime(ms);
        var tickFrom = clock.now, tickTo = clock.now + ms, previous = clock.now;
        var timer = firstTimerInRange(clock, tickFrom, tickTo);

        var firstException;
        while (timer && tickFrom <= tickTo) {
            if (clock.timers[timer.id]) {
                tickFrom = clock.now = timer.callAt;
                try {
                    callTimer(clock, timer);
                } catch (e) {
                    firstException = firstException || e;
                }
            }

            timer = firstTimerInRange(clock, previous, tickTo);
            previous = tickFrom;
        }

        clock.now = tickTo;

        if (firstException) {
            throw firstException;
        }

        return clock.now;
    };

    clock.reset = function reset() {
        clock.timers = {};
    };

    return clock;
};

exports.install = function install(target, now, toFake) {
    if (typeof target === "number") {
        toFake = now;
        now = target;
        target = null;
    }

    if (!target) {
        target = global;
    }

    var clock = createClock(now);

    clock.uninstall = function () {
        uninstall(clock, target);
    };

    clock.methods = toFake || [];

    if (clock.methods.length === 0) {
        clock.methods = keys(timers);
    }

    for (var i = 0, l = clock.methods.length; i < l; i++) {
        hijackMethod(target, clock.methods[i], clock);
    }

    return clock;
};

}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{}],65:[function(require,module,exports){
//     Underscore.js 1.8.3
//     http://underscorejs.org
//     (c) 2009-2015 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._;

  // 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,
    toString         = ObjProto.toString,
    hasOwnProperty   = ObjProto.hasOwnProperty;

  // All **ECMAScript 5** native function implementations that we hope to use
  // are declared here.
  var
    nativeIsArray      = Array.isArray,
    nativeKeys         = Object.keys,
    nativeBind         = FuncProto.bind,
    nativeCreate       = Object.create;

  // Naked function reference for surrogate-prototype-swapping.
  var Ctor = function(){};

  // 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.
  if (typeof exports !== 'undefined') {
    if (typeof module !== 'undefined' && module.exports) {
      exports = module.exports = _;
    }
    exports._ = _;
  } else {
    root._ = _;
  }

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

  // Internal function that returns an efficient (for current engines) version
  // of the passed-in callback, to be repeatedly applied in other Underscore
  // functions.
  var optimizeCb = function(func, context, argCount) {
    if (context === void 0) return func;
    switch (argCount == null ? 3 : argCount) {
      case 1: return function(value) {
        return func.call(context, value);
      };
      case 2: return function(value, other) {
        return func.call(context, value, other);
      };
      case 3: return function(value, index, collection) {
        return func.call(context, value, index, collection);
      };
      case 4: return function(accumulator, value, index, collection) {
        return func.call(context, accumulator, value, index, collection);
      };
    }
    return function() {
      return func.apply(context, arguments);
    };
  };

  // A mostly-internal function to generate callbacks that can be applied
  // to each element in a collection, returning the desired result — either
  // identity, an arbitrary callback, a property matcher, or a property accessor.
  var cb = function(value, context, argCount) {
    if (value == null) return _.identity;
    if (_.isFunction(value)) return optimizeCb(value, context, argCount);
    if (_.isObject(value)) return _.matcher(value);
    return _.property(value);
  };
  _.iteratee = function(value, context) {
    return cb(value, context, Infinity);
  };

  // An internal function for creating assigner functions.
  var createAssigner = function(keysFunc, undefinedOnly) {
    return function(obj) {
      var length = arguments.length;
      if (length < 2 || obj == null) return obj;
      for (var index = 1; index < length; index++) {
        var source = arguments[index],
            keys = keysFunc(source),
            l = keys.length;
        for (var i = 0; i < l; i++) {
          var key = keys[i];
          if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];
        }
      }
      return obj;
    };
  };

  // An internal function for creating a new object that inherits from another.
  var baseCreate = function(prototype) {
    if (!_.isObject(prototype)) return {};
    if (nativeCreate) return nativeCreate(prototype);
    Ctor.prototype = prototype;
    var result = new Ctor;
    Ctor.prototype = null;
    return result;
  };

  var property = function(key) {
    return function(obj) {
      return obj == null ? void 0 : obj[key];
    };
  };

  // Helper for collection methods to determine whether a collection
  // should be iterated as an array or as an object
  // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength
  // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094
  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;
  var getLength = property('length');
  var isArrayLike = function(collection) {
    var length = getLength(collection);
    return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;
  };

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

  // The cornerstone, an `each` implementation, aka `forEach`.
  // Handles raw objects in addition to array-likes. Treats all
  // sparse array-likes as if they were dense.
  _.each = _.forEach = function(obj, iteratee, context) {
    iteratee = optimizeCb(iteratee, context);
    var i, length;
    if (isArrayLike(obj)) {
      for (i = 0, length = obj.length; i < length; i++) {
        iteratee(obj[i], i, obj);
      }
    } else {
      var keys = _.keys(obj);
      for (i = 0, length = keys.length; i < length; i++) {
        iteratee(obj[keys[i]], keys[i], obj);
      }
    }
    return obj;
  };

  // Return the results of applying the iteratee to each element.
  _.map = _.collect = function(obj, iteratee, context) {
    iteratee = cb(iteratee, context);
    var keys = !isArrayLike(obj) && _.keys(obj),
        length = (keys || obj).length,
        results = Array(length);
    for (var index = 0; index < length; index++) {
      var currentKey = keys ? keys[index] : index;
      results[index] = iteratee(obj[currentKey], currentKey, obj);
    }
    return results;
  };

  // Create a reducing function iterating left or right.
  function createReduce(dir) {
    // Optimized iterator function as using arguments.length
    // in the main function will deoptimize the, see #1991.
    function iterator(obj, iteratee, memo, keys, index, length) {
      for (; index >= 0 && index < length; index += dir) {
        var currentKey = keys ? keys[index] : index;
        memo = iteratee(memo, obj[currentKey], currentKey, obj);
      }
      return memo;
    }

    return function(obj, iteratee, memo, context) {
      iteratee = optimizeCb(iteratee, context, 4);
      var keys = !isArrayLike(obj) && _.keys(obj),
          length = (keys || obj).length,
          index = dir > 0 ? 0 : length - 1;
      // Determine the initial value if none is provided.
      if (arguments.length < 3) {
        memo = obj[keys ? keys[index] : index];
        index += dir;
      }
      return iterator(obj, iteratee, memo, keys, index, length);
    };
  }

  // **Reduce** builds up a single result from a list of values, aka `inject`,
  // or `foldl`.
  _.reduce = _.foldl = _.inject = createReduce(1);

  // The right-associative version of reduce, also known as `foldr`.
  _.reduceRight = _.foldr = createReduce(-1);

  // Return the first value which passes a truth test. Aliased as `detect`.
  _.find = _.detect = function(obj, predicate, context) {
    var key;
    if (isArrayLike(obj)) {
      key = _.findIndex(obj, predicate, context);
    } else {
      key = _.findKey(obj, predicate, context);
    }
    if (key !== void 0 && key !== -1) return obj[key];
  };

  // Return all the elements that pass a truth test.
  // Aliased as `select`.
  _.filter = _.select = function(obj, predicate, context) {
    var results = [];
    predicate = cb(predicate, context);
    _.each(obj, function(value, index, list) {
      if (predicate(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, _.negate(cb(predicate)), context);
  };

  // Determine whether all of the elements match a truth test.
  // Aliased as `all`.
  _.every = _.all = function(obj, predicate, context) {
    predicate = cb(predicate, context);
    var keys = !isArrayLike(obj) && _.keys(obj),
        length = (keys || obj).length;
    for (var index = 0; index < length; index++) {
      var currentKey = keys ? keys[index] : index;
      if (!predicate(obj[currentKey], currentKey, obj)) return false;
    }
    return true;
  };

  // Determine if at least one element in the object matches a truth test.
  // Aliased as `any`.
  _.some = _.any = function(obj, predicate, context) {
    predicate = cb(predicate, context);
    var keys = !isArrayLike(obj) && _.keys(obj),
        length = (keys || obj).length;
    for (var index = 0; index < length; index++) {
      var currentKey = keys ? keys[index] : index;
      if (predicate(obj[currentKey], currentKey, obj)) return true;
    }
    return false;
  };

  // Determine if the array or object contains a given item (using `===`).
  // Aliased as `includes` and `include`.
  _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {
    if (!isArrayLike(obj)) obj = _.values(obj);
    if (typeof fromIndex != 'number' || guard) fromIndex = 0;
    return _.indexOf(obj, item, fromIndex) >= 0;
  };

  // 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) {
      var func = isFunc ? method : value[method];
      return func == null ? func : func.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, _.matcher(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, _.matcher(attrs));
  };

  // Return the maximum element (or element-based computation).
  _.max = function(obj, iteratee, context) {
    var result = -Infinity, lastComputed = -Infinity,
        value, computed;
    if (iteratee == null && obj != null) {
      obj = isArrayLike(obj) ? obj : _.values(obj);
      for (var i = 0, length = obj.length; i < length; i++) {
        value = obj[i];
        if (value > result) {
          result = value;
        }
      }
    } else {
      iteratee = cb(iteratee, context);
      _.each(obj, function(value, index, list) {
        computed = iteratee(value, index, list);
        if (computed > lastComputed || computed === -Infinity && result === -Infinity) {
          result = value;
          lastComputed = computed;
        }
      });
    }
    return result;
  };

  // Return the minimum element (or element-based computation).
  _.min = function(obj, iteratee, context) {
    var result = Infinity, lastComputed = Infinity,
        value, computed;
    if (iteratee == null && obj != null) {
      obj = isArrayLike(obj) ? obj : _.values(obj);
      for (var i = 0, length = obj.length; i < length; i++) {
        value = obj[i];
        if (value < result) {
          result = value;
        }
      }
    } else {
      iteratee = cb(iteratee, context);
      _.each(obj, function(value, index, list) {
        computed = iteratee(value, index, list);
        if (computed < lastComputed || computed === Infinity && result === Infinity) {
          result = value;
          lastComputed = computed;
        }
      });
    }
    return result;
  };

  // Shuffle a collection, using the modern version of the
  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).
  _.shuffle = function(obj) {
    var set = isArrayLike(obj) ? obj : _.values(obj);
    var length = set.length;
    var shuffled = Array(length);
    for (var index = 0, rand; index < length; index++) {
      rand = _.random(0, index);
      if (rand !== index) shuffled[index] = shuffled[rand];
      shuffled[rand] = set[index];
    }
    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 (!isArrayLike(obj)) obj = _.values(obj);
      return obj[_.random(obj.length - 1)];
    }
    return _.shuffle(obj).slice(0, Math.max(0, n));
  };

  // Sort the object's values by a criterion produced by an iteratee.
  _.sortBy = function(obj, iteratee, context) {
    iteratee = cb(iteratee, context);
    return _.pluck(_.map(obj, function(value, index, list) {
      return {
        value: value,
        index: index,
        criteria: iteratee(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, iteratee, context) {
      var result = {};
      iteratee = cb(iteratee, context);
      _.each(obj, function(value, index) {
        var key = iteratee(value, index, obj);
        behavior(result, value, key);
      });
      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, value, key) {
    if (_.has(result, key)) result[key].push(value); else 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, value, key) {
    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, value, key) {
    if (_.has(result, key)) result[key]++; else result[key] = 1;
  });

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

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

  // Split a collection into two arrays: one whose elements all satisfy the given
  // predicate, and one whose elements all do not satisfy the predicate.
  _.partition = function(obj, predicate, context) {
    predicate = cb(predicate, context);
    var pass = [], fail = [];
    _.each(obj, function(value, key, obj) {
      (predicate(value, key, obj) ? pass : fail).push(value);
    });
    return [pass, fail];
  };

  // 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];
    return _.initial(array, array.length - 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.
  _.initial = function(array, n, guard) {
    return slice.call(array, 0, Math.max(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.
  _.last = function(array, n, guard) {
    if (array == null) return void 0;
    if (n == null || guard) return array[array.length - 1];
    return _.rest(array, Math.max(0, array.length - n));
  };

  // 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.
  _.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, strict, startIndex) {
    var output = [], idx = 0;
    for (var i = startIndex || 0, length = getLength(input); i < length; i++) {
      var value = input[i];
      if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {
        //flatten current level of array or arguments object
        if (!shallow) value = flatten(value, shallow, strict);
        var j = 0, len = value.length;
        output.length += len;
        while (j < len) {
          output[idx++] = value[j++];
        }
      } else if (!strict) {
        output[idx++] = value;
      }
    }
    return output;
  };

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

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

  // 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, iteratee, context) {
    if (!_.isBoolean(isSorted)) {
      context = iteratee;
      iteratee = isSorted;
      isSorted = false;
    }
    if (iteratee != null) iteratee = cb(iteratee, context);
    var result = [];
    var seen = [];
    for (var i = 0, length = getLength(array); i < length; i++) {
      var value = array[i],
          computed = iteratee ? iteratee(value, i, array) : value;
      if (isSorted) {
        if (!i || seen !== computed) result.push(value);
        seen = computed;
      } else if (iteratee) {
        if (!_.contains(seen, computed)) {
          seen.push(computed);
          result.push(value);
        }
      } else if (!_.contains(result, value)) {
        result.push(value);
      }
    }
    return result;
  };

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

  // Produce an array that contains every item shared between all the
  // passed-in arrays.
  _.intersection = function(array) {
    var result = [];
    var argsLength = arguments.length;
    for (var i = 0, length = getLength(array); i < length; i++) {
      var item = array[i];
      if (_.contains(result, item)) continue;
      for (var j = 1; j < argsLength; j++) {
        if (!_.contains(arguments[j], item)) break;
      }
      if (j === argsLength) result.push(item);
    }
    return result;
  };

  // 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 = flatten(arguments, true, true, 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() {
    return _.unzip(arguments);
  };

  // Complement of _.zip. Unzip accepts an array of arrays and groups
  // each array's elements on shared indices
  _.unzip = function(array) {
    var length = array && _.max(array, getLength).length || 0;
    var result = Array(length);

    for (var index = 0; index < length; index++) {
      result[index] = _.pluck(array, index);
    }
    return result;
  };

  // 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) {
    var result = {};
    for (var i = 0, length = getLength(list); i < length; i++) {
      if (values) {
        result[list[i]] = values[i];
      } else {
        result[list[i][0]] = list[i][1];
      }
    }
    return result;
  };

  // Generator function to create the findIndex and findLastIndex functions
  function createPredicateIndexFinder(dir) {
    return function(array, predicate, context) {
      predicate = cb(predicate, context);
      var length = getLength(array);
      var index = dir > 0 ? 0 : length - 1;
      for (; index >= 0 && index < length; index += dir) {
        if (predicate(array[index], index, array)) return index;
      }
      return -1;
    };
  }

  // Returns the first index on an array-like that passes a predicate test
  _.findIndex = createPredicateIndexFinder(1);
  _.findLastIndex = createPredicateIndexFinder(-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, iteratee, context) {
    iteratee = cb(iteratee, context, 1);
    var value = iteratee(obj);
    var low = 0, high = getLength(array);
    while (low < high) {
      var mid = Math.floor((low + high) / 2);
      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;
    }
    return low;
  };

  // Generator function to create the indexOf and lastIndexOf functions
  function createIndexFinder(dir, predicateFind, sortedIndex) {
    return function(array, item, idx) {
      var i = 0, length = getLength(array);
      if (typeof idx == 'number') {
        if (dir > 0) {
            i = idx >= 0 ? idx : Math.max(idx + length, i);
        } else {
            length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;
        }
      } else if (sortedIndex && idx && length) {
        idx = sortedIndex(array, item);
        return array[idx] === item ? idx : -1;
      }
      if (item !== item) {
        idx = predicateFind(slice.call(array, i, length), _.isNaN);
        return idx >= 0 ? idx + i : -1;
      }
      for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {
        if (array[idx] === item) return idx;
      }
      return -1;
    };
  }

  // Return the position of the first occurrence of an item in an array,
  // or -1 if the item is not included in the array.
  // If the array is large and already in sort order, pass `true`
  // for **isSorted** to use binary search.
  _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);
  _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);

  // 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 (stop == null) {
      stop = start || 0;
      start = 0;
    }
    step = step || 1;

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

    for (var idx = 0; idx < length; idx++, start += step) {
      range[idx] = start;
    }

    return range;
  };

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

  // Determines whether to execute a function as a constructor
  // or a normal function with the provided arguments
  var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {
    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);
    var self = baseCreate(sourceFunc.prototype);
    var result = sourceFunc.apply(self, args);
    if (_.isObject(result)) return result;
    return self;
  };

  // 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) {
    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');
    var args = slice.call(arguments, 2);
    var bound = function() {
      return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));
    };
    return bound;
  };

  // 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);
    var bound = function() {
      var position = 0, length = boundArgs.length;
      var args = Array(length);
      for (var i = 0; i < length; i++) {
        args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];
      }
      while (position < arguments.length) args.push(arguments[position++]);
      return executeBound(func, bound, this, this, args);
    };
    return bound;
  };

  // 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 i, length = arguments.length, key;
    if (length <= 1) throw new Error('bindAll must be passed function names');
    for (i = 1; i < length; i++) {
      key = arguments[i];
      obj[key] = _.bind(obj[key], obj);
    }
    return obj;
  };

  // Memoize an expensive function by storing its results.
  _.memoize = function(func, hasher) {
    var memoize = function(key) {
      var cache = memoize.cache;
      var address = '' + (hasher ? hasher.apply(this, arguments) : key);
      if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);
      return cache[address];
    };
    memoize.cache = {};
    return memoize;
  };

  // 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 = _.partial(_.delay, _, 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;
    if (!options) options = {};
    var later = function() {
      previous = options.leading === false ? 0 : _.now();
      timeout = null;
      result = func.apply(context, args);
      if (!timeout) 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 || remaining > wait) {
        if (timeout) {
          clearTimeout(timeout);
          timeout = null;
        }
        previous = now;
        result = func.apply(context, args);
        if (!timeout) 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 && last >= 0) {
        timeout = setTimeout(later, wait - last);
      } else {
        timeout = null;
        if (!immediate) {
          result = func.apply(context, args);
          if (!timeout) 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 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 negated version of the passed-in predicate.
  _.negate = function(predicate) {
    return function() {
      return !predicate.apply(this, arguments);
    };
  };

  // 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 args = arguments;
    var start = args.length - 1;
    return function() {
      var i = start;
      var result = args[start].apply(this, arguments);
      while (i--) result = args[i].call(this, result);
      return result;
    };
  };

  // Returns a function that will only be executed on and after the Nth call.
  _.after = function(times, func) {
    return function() {
      if (--times < 1) {
        return func.apply(this, arguments);
      }
    };
  };

  // Returns a function that will only be executed up to (but not including) the Nth call.
  _.before = function(times, func) {
    var memo;
    return function() {
      if (--times > 0) {
        memo = func.apply(this, arguments);
      }
      if (times <= 1) func = null;
      return memo;
    };
  };

  // Returns a function that will be executed at most one time, no matter how
  // often you call it. Useful for lazy initialization.
  _.once = _.partial(_.before, 2);

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

  // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.
  var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');
  var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',
                      'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];

  function collectNonEnumProps(obj, keys) {
    var nonEnumIdx = nonEnumerableProps.length;
    var constructor = obj.constructor;
    var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;

    // Constructor is a special case.
    var prop = 'constructor';
    if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);

    while (nonEnumIdx--) {
      prop = nonEnumerableProps[nonEnumIdx];
      if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {
        keys.push(prop);
      }
    }
  }

  // Retrieve the names of an object's own 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);
    // Ahem, IE < 9.
    if (hasEnumBug) collectNonEnumProps(obj, keys);
    return keys;
  };

  // Retrieve all the property names of an object.
  _.allKeys = function(obj) {
    if (!_.isObject(obj)) return [];
    var keys = [];
    for (var key in obj) keys.push(key);
    // Ahem, IE < 9.
    if (hasEnumBug) collectNonEnumProps(obj, keys);
    return keys;
  };

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

  // Returns the results of applying the iteratee to each element of the object
  // In contrast to _.map it returns an object
  _.mapObject = function(obj, iteratee, context) {
    iteratee = cb(iteratee, context);
    var keys =  _.keys(obj),
          length = keys.length,
          results = {},
          currentKey;
      for (var index = 0; index < length; index++) {
        currentKey = keys[index];
        results[currentKey] = iteratee(obj[currentKey], currentKey, obj);
      }
      return results;
  };

  // Convert an object into a list of `[key, value]` pairs.
  _.pairs = function(obj) {
    var keys = _.keys(obj);
    var length = keys.length;
    var pairs = 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 = createAssigner(_.allKeys);

  // Assigns a given object with all the own properties in the passed-in object(s)
  // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)
  _.extendOwn = _.assign = createAssigner(_.keys);

  // Returns the first key on an object that passes a predicate test
  _.findKey = function(obj, predicate, context) {
    predicate = cb(predicate, context);
    var keys = _.keys(obj), key;
    for (var i = 0, length = keys.length; i < length; i++) {
      key = keys[i];
      if (predicate(obj[key], key, obj)) return key;
    }
  };

  // Return a copy of the object only containing the whitelisted properties.
  _.pick = function(object, oiteratee, context) {
    var result = {}, obj = object, iteratee, keys;
    if (obj == null) return result;
    if (_.isFunction(oiteratee)) {
      keys = _.allKeys(obj);
      iteratee = optimizeCb(oiteratee, context);
    } else {
      keys = flatten(arguments, false, false, 1);
      iteratee = function(value, key, obj) { return key in obj; };
      obj = Object(obj);
    }
    for (var i = 0, length = keys.length; i < length; i++) {
      var key = keys[i];
      var value = obj[key];
      if (iteratee(value, key, obj)) result[key] = value;
    }
    return result;
  };

   // Return a copy of the object without the blacklisted properties.
  _.omit = function(obj, iteratee, context) {
    if (_.isFunction(iteratee)) {
      iteratee = _.negate(iteratee);
    } else {
      var keys = _.map(flatten(arguments, false, false, 1), String);
      iteratee = function(value, key) {
        return !_.contains(keys, key);
      };
    }
    return _.pick(obj, iteratee, context);
  };

  // Fill in a given object with default properties.
  _.defaults = createAssigner(_.allKeys, true);

  // Creates an object that inherits from the given prototype object.
  // If additional properties are provided then they will be added to the
  // created object.
  _.create = function(prototype, props) {
    var result = baseCreate(prototype);
    if (props) _.extendOwn(result, props);
    return result;
  };

  // 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;
  };

  // Returns whether an object has a given set of `key:value` pairs.
  _.isMatch = function(object, attrs) {
    var keys = _.keys(attrs), length = keys.length;
    if (object == null) return !length;
    var obj = Object(object);
    for (var i = 0; i < length; i++) {
      var key = keys[i];
      if (attrs[key] !== obj[key] || !(key in obj)) return false;
    }
    return true;
  };


  // 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, regular expressions, dates, and booleans are compared by value.
      case '[object RegExp]':
      // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')
      case '[object String]':
        // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is
        // equivalent to `new String("5")`.
        return '' + a === '' + b;
      case '[object Number]':
        // `NaN`s are equivalent, but non-reflexive.
        // Object(NaN) is equivalent to NaN
        if (+a !== +a) return +b !== +b;
        // An `egal` comparison is performed for other numeric values.
        return +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;
    }

    var areArrays = className === '[object Array]';
    if (!areArrays) {
      if (typeof a != 'object' || typeof b != 'object') return false;

      // Objects with different constructors are not equivalent, but `Object`s or `Array`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;
      }
    }
    // Assume equality for cyclic structures. The algorithm for detecting cyclic
    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.

    // Initializing stack of traversed objects.
    // It's done here since we only need them for objects and arrays comparison.
    aStack = aStack || [];
    bStack = bStack || [];
    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;
    }

    // Add the first object to the stack of traversed objects.
    aStack.push(a);
    bStack.push(b);

    // Recursively compare objects and arrays.
    if (areArrays) {
      // Compare array lengths to determine if a deep comparison is necessary.
      length = a.length;
      if (length !== b.length) return false;
      // Deep compare the contents, ignoring non-numeric properties.
      while (length--) {
        if (!eq(a[length], b[length], aStack, bStack)) return false;
      }
    } else {
      // Deep compare objects.
      var keys = _.keys(a), key;
      length = keys.length;
      // Ensure that both objects contain the same number of properties before comparing deep equality.
      if (_.keys(b).length !== length) return false;
      while (length--) {
        // Deep compare each member
        key = keys[length];
        if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;
      }
    }
    // Remove the first object from the stack of traversed objects.
    aStack.pop();
    bStack.pop();
    return true;
  };

  // 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 (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;
    return _.keys(obj).length === 0;
  };

  // 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) {
    var type = typeof obj;
    return type === 'function' || type === 'object' && !!obj;
  };

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

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

  // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,
  // IE 11 (#1621), and in Safari 8 (#1929).
  if (typeof /./ != 'function' && typeof Int8Array != 'object') {
    _.isFunction = function(obj) {
      return typeof obj == 'function' || false;
    };
  }

  // 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 obj != null && 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 iteratees.
  _.identity = function(value) {
    return value;
  };

  // Predicate-generating functions. Often useful outside of Underscore.
  _.constant = function(value) {
    return function() {
      return value;
    };
  };

  _.noop = function(){};

  _.property = property;

  // Generates a function for a given object that returns a given property.
  _.propertyOf = function(obj) {
    return obj == null ? function(){} : function(key) {
      return obj[key];
    };
  };

  // Returns a predicate for checking whether an object has a given set of
  // `key:value` pairs.
  _.matcher = _.matches = function(attrs) {
    attrs = _.extendOwn({}, attrs);
    return function(obj) {
      return _.isMatch(obj, attrs);
    };
  };

  // Run a function **n** times.
  _.times = function(n, iteratee, context) {
    var accum = Array(Math.max(0, n));
    iteratee = optimizeCb(iteratee, context, 1);
    for (var i = 0; i < n; i++) accum[i] = iteratee(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 escapeMap = {
    '&': '&amp;',
    '<': '&lt;',
    '>': '&gt;',
    '"': '&quot;',
    "'": '&#x27;',
    '`': '&#x60;'
  };
  var unescapeMap = _.invert(escapeMap);

  // Functions for escaping and unescaping strings to/from HTML interpolation.
  var createEscaper = function(map) {
    var escaper = function(match) {
      return map[match];
    };
    // Regexes for identifying a key that needs to be escaped
    var source = '(?:' + _.keys(map).join('|') + ')';
    var testRegexp = RegExp(source);
    var replaceRegexp = RegExp(source, 'g');
    return function(string) {
      string = string == null ? '' : '' + string;
      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;
    };
  };
  _.escape = createEscaper(escapeMap);
  _.unescape = createEscaper(unescapeMap);

  // 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, fallback) {
    var value = object == null ? void 0 : object[property];
    if (value === void 0) {
      value = fallback;
    }
    return _.isFunction(value) ? value.call(object) : value;
  };

  // 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',
    '\u2028': 'u2028',
    '\u2029': 'u2029'
  };

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

  var escapeChar = function(match) {
    return '\\' + escapes[match];
  };

  // JavaScript micro-templating, similar to John Resig's implementation.
  // Underscore templating handles arbitrary delimiters, preserves whitespace,
  // and correctly escapes quotes within interpolated code.
  // NB: `oldSettings` only exists for backwards compatibility.
  _.template = function(text, settings, oldSettings) {
    if (!settings && oldSettings) settings = oldSettings;
    settings = _.defaults({}, settings, _.templateSettings);

    // Combine delimiters into one regular expression via alternation.
    var matcher = 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, escapeChar);
      index = offset + match.length;

      if (escape) {
        source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'";
      } else if (interpolate) {
        source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'";
      } else if (evaluate) {
        source += "';\n" + evaluate + "\n__p+='";
      }

      // Adobe VMs need the match returned to produce the correct offest.
      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 {
      var render = new Function(settings.variable || 'obj', '_', source);
    } catch (e) {
      e.source = source;
      throw e;
    }

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

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

    return template;
  };

  // Add a "chain" function. Start chaining a wrapped Underscore object.
  _.chain = function(obj) {
    var instance = _(obj);
    instance._chain = true;
    return instance;
  };

  // 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(instance, obj) {
    return instance._chain ? _(obj).chain() : obj;
  };

  // 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(this, func.apply(_, args));
      };
    });
  };

  // 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(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(this, method.apply(this._wrapped, arguments));
    };
  });

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

  // Provide unwrapping proxy for some methods used in engine operations
  // such as arithmetic and JSON stringification.
  _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;

  _.prototype.toString = 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));

},{}],66:[function(require,module,exports){
var Connector, SelectionsTest, TestSuite, Y, chai, expect, should, sinon, sinonChai, _,
  __hasProp = {}.hasOwnProperty,
  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

chai = require('chai');

expect = chai.expect;

should = chai.should();

sinon = require('sinon');

sinonChai = require('sinon-chai');

_ = require("underscore");

chai.use(sinonChai);

Y = require("../../yjs/lib/y");

Y.List = require("../../y-list/lib/y-list.coffee");

Y.Selections = require("../lib/y-selections");

Connector = require("../../y-test/lib/y-test.coffee");

TestSuite = require("../../yjs/test/TestSuite");

SelectionsTest = (function(_super) {
  __extends(SelectionsTest, _super);

  function SelectionsTest(suffix) {
    SelectionsTest.__super__.constructor.call(this, suffix, Y);
  }

  SelectionsTest.prototype.type = "SelectionsTest";

  SelectionsTest.prototype.makeNewUser = function(userId) {
    var conn;
    conn = new Connector(userId);
    return new Y(conn);
  };

  SelectionsTest.prototype.initUsers = function(u) {
    u.val("selections", new Y.Selections());
    return u.val("list", new Y.List([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]));
  };

  SelectionsTest.prototype.getRandomRoot = function(user_num) {
    return this.users[user_num].val("TextTest");
  };

  SelectionsTest.prototype.getContent = function(user_num) {
    return this.users[user_num].val("TextTest").val();
  };

  return SelectionsTest;

})(TestSuite);

describe("Selections Test", function() {
  this.timeout(500000);
  beforeEach(function(done) {
    this.yTest = new SelectionsTest();
    return done();
  });
  it("selected two elements, checked for pointers", function() {
    var l, l_left, l_right, sel;
    l = this.yTest.users[0].val("list");
    l_left = l.ref(1);
    l_right = l.ref(2);
    sel = this.yTest.users[0].val("selections");
    sel.select(l_left, l_right, {
      "my_attr": "black"
    });
    expect(l.ref(1).selection.from).to.equal(l.ref(1));
    expect(l.ref(1).selection.to).to.equal(l.ref(2));
    expect(l.ref(2).selection.from).to.equal(l.ref(1));
    return expect(l.ref(2).selection.to).to.equal(l.ref(2));
  });
  it("selected two elements, checked for pointers (foreign user)", function() {
    var l, l_left, l_right, sel;
    l = this.yTest.users[0].val("list");
    l_left = l.ref(1);
    l_right = l.ref(2);
    sel = this.yTest.users[0].val("selections");
    sel.select(l_left, l_right, {
      "c": "blue"
    });
    this.yTest.flushAll();
    l = this.yTest.users[1].val("list");
    expect(l.ref(1).selection.from).to.equal(l.ref(1));
    expect(l.ref(1).selection.to).to.equal(l.ref(2));
    expect(l.ref(2).selection.from).to.equal(l.ref(1));
    return expect(l.ref(2).selection.to).to.equal(l.ref(2));
  });
  it("selected two elements, checked for pointers (foreign user, new Selections instance)", function() {
    var l, l_left, l_right, sel;
    l = this.yTest.users[0].val("list");
    l_left = l.ref(1);
    l_right = l.ref(2);
    this.yTest.users[0].val("selections", new Y.Selections());
    sel = this.yTest.users[0].val("selections");
    sel.select(l_left, l_right, {
      "c": "blue"
    });
    this.yTest.flushAll();
    l = this.yTest.users[1].val("list");
    expect(l.ref(1).selection.from).to.equal(l.ref(1));
    expect(l.ref(1).selection.to).to.equal(l.ref(2));
    expect(l.ref(2).selection.from).to.equal(l.ref(1));
    return expect(l.ref(2).selection.to).to.equal(l.ref(2));
  });
  it("selected two times two elements, checked for pointers (foreign user, new Selections instance)", function() {
    var l, l_left, l_right, sel;
    l = this.yTest.users[0].val("list");
    l_left = l.ref(1);
    l_right = l.ref(2);
    this.yTest.users[0].val("selections", new Y.Selections());
    sel = this.yTest.users[0].val("selections");
    sel.select(l_left, l_right, {
      "c": "blue"
    });
    l_left = l.ref(3);
    l_right = l.ref(4);
    sel.select(l_left, l_right, {
      "c": "blue"
    });
    this.yTest.flushAll();
    l = this.yTest.users[1].val("list");
    expect(l.ref(1).selection.from).to.equal(l.ref(1));
    expect(l.ref(1).selection.to).to.equal(l.ref(4));
    expect(l.ref(2).selection != null).to.be["false"];
    return expect(l.ref(3).selection != null).to.be["false"];
  });
  describe("Intersection of selections:", function() {
    it("intersected two elements, checked for pointers and attrs (strict inner overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(4);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(3);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.equal(l.ref(3).selection);
      expect(l.ref(2).selection.from).to.equal(l.ref(2));
      expect(l.ref(2).selection.to).to.equal(l.ref(3));
      expect(l.ref(2).selection.attrs.c).to.equal("blue");
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(1));
      expect(l.ref(4).selection.from).to.equal(l.ref(4));
      expect(l.ref(4).selection.to).to.equal(l.ref(4));
      expect(l.ref(2).selection.attrs.c).to.equal("blue");
      expect(l.ref(3).selection.attrs.c).to.equal("blue");
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      expect(l.ref(4).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 1,
          attrs: {
            "c": "black"
          }
        }, {
          from: 2,
          to: 3,
          attrs: {
            "c": "blue"
          }
        }, {
          from: 4,
          to: 4,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements (minimal), checked for pointers and attrs (strict inner overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      this.yTest.flushAll();
      expect(l.ref(2).selection.from).to.equal(l.ref(2));
      expect(l.ref(2).selection.to).to.equal(l.ref(2));
      expect(l.ref(2).selection.attrs.c).to.equal("blue");
      expect(l.ref(2).selection.from).to.equal(l.ref(2));
      expect(l.ref(2).selection.to).to.equal(l.ref(2));
      expect(l.ref(2).selection.attrs.c).to.equal("blue");
      expect(l.ref(3).selection.attrs.c).to.equal("black");
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 1,
          attrs: {
            "c": "black"
          }
        }, {
          from: 2,
          to: 2,
          attrs: {
            "c": "blue"
          }
        }, {
          from: 3,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements, checked for pointers and attrs (inner overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(2));
      expect(l.ref(1).selection.attrs.c).to.equal("blue");
      expect(l.ref(2).selection.from).to.equal(l.ref(1));
      expect(l.ref(2).selection.to).to.equal(l.ref(2));
      expect(l.ref(2).selection.attrs.c).to.equal("blue");
      expect(l.ref(3).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 2,
          attrs: {
            "c": "blue"
          }
        }, {
          from: 3,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements (minimal), checked for pointers and attrs (inner overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(1);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(1));
      expect(l.ref(1).selection.attrs.c).to.equal("blue");
      expect(l.ref(2).selection.from).to.equal(l.ref(2));
      expect(l.ref(2).selection.to).to.equal(l.ref(3));
      expect(l.ref(1).selection.attrs.c).to.equal("blue");
      expect(l.ref(2).selection.attrs.c).to.equal("black");
      expect(l.ref(3).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 1,
          attrs: {
            "c": "blue"
          }
        }, {
          from: 2,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements, checked for pointers and attrs (inner overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(2));
      expect(l.ref(1).selection.attrs.c).to.equal("blue");
      expect(l.ref(2).selection.from).to.equal(l.ref(1));
      expect(l.ref(2).selection.to).to.equal(l.ref(2));
      expect(l.ref(2).selection.attrs.c).to.equal("blue");
      expect(l.ref(0).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 0,
          to: 0,
          attrs: {
            "c": "black"
          }
        }, {
          from: 1,
          to: 2,
          attrs: {
            "c": "blue"
          }
        }
      ]);
    });
    it("intersected two elements (minimal), checked for pointers and attrs (inner overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection).to.equal(l.ref(0).selection);
      expect(l.ref(2).selection.to).to.equal(l.ref(2));
      expect(l.ref(2).selection.from).to.equal(l.ref(2));
      expect(l.ref(0).selection.to).to.equal(l.ref(1));
      expect(l.ref(1).selection.from).to.equal(l.ref(0));
      expect(l.ref(2).selection.attrs.c).to.equal("blue");
      expect(l.ref(0).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 0,
          to: 1,
          attrs: {
            "c": "black"
          }
        }, {
          from: 2,
          to: 2,
          attrs: {
            "c": "blue"
          }
        }
      ]);
    });
    it("intersected two elements, checked for pointers and attrs (strict outer overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(3);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(4);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection).to.equal(l.ref(4).selection);
      expect(l.ref(1).selection.to).to.equal(l.ref(4));
      expect(l.ref(4).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 4,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements (minimal), checked for pointers and attrs (strict outer overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(3));
      expect(l.ref(3).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements, checked for pointers and attrs (outer overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection).to.equal(l.ref(3).selection);
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(3));
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements (minimal), checked for pointers and attrs (outer overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(1);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection).to.equal(l.ref(3).selection);
      expect(l.ref(1).selection.to).to.equal(l.ref(3));
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements, checked for pointers and attrs (outer overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      this.yTest.flushAll();
      expect(l.ref(0).selection).to.equal(l.ref(2).selection);
      expect(l.ref(0).selection.from).to.equal(l.ref(0));
      expect(l.ref(0).selection.to).to.equal(l.ref(2));
      expect(l.ref(0).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 0,
          to: 2,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    return it("intersected two elements (minimal), checked for pointers and attrs (outer overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      this.yTest.flushAll();
      expect(l.ref(0).selection).to.equal(l.ref(2).selection);
      expect(l.ref(0).selection.to).to.equal(l.ref(2));
      expect(l.ref(2).selection.from).to.equal(l.ref(0));
      expect(l.ref(0).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 0,
          to: 2,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
  });
  describe("Unselections", function() {
    it("intersected a selection, checked for pointers and attrs (strict inner overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(4);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(3);
      this.yTest.users[0].val("selections").unselect(l_left, l_right, ["c"]);
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(3).selection).to.be.undefined;
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(1));
      expect(l.ref(4).selection.from).to.equal(l.ref(4));
      expect(l.ref(4).selection.to).to.equal(l.ref(4));
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      expect(l.ref(4).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 1,
          attrs: {
            "c": "black"
          }
        }, {
          from: 4,
          to: 4,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected a selection (minimal), checked for pointers and attrs (strict inner overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(1));
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(3).selection.attrs.c).to.equal("black");
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 1,
          attrs: {
            "c": "black"
          }
        }, {
          from: 3,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected a selection, checked for pointers and attrs (inner overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(1).selection).to.be.undefined;
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(3).selection.attrs.c).to.equal("black");
      expect(l.ref(3).selection.from).to.equal(l.ref(3));
      expect(l.ref(3).selection.to).to.equal(l.ref(3));
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 3,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected a selection (minimal), checked for pointers and attrs (inner overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(1);
      this.yTest.users[0].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(1).selection).to.be.undefined;
      expect(l.ref(2).selection).to.equal(l.ref(3).selection);
      expect(l.ref(2).selection.from).to.equal(l.ref(2));
      expect(l.ref(2).selection.to).to.equal(l.ref(3));
      expect(l.ref(1).selection).to.be.undefined;
      expect(l.ref(2).selection.attrs.c).to.equal("black");
      expect(l.ref(3).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 2,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected a selection, checked for pointers and attrs (inner overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(0).selection).to.equal(l.ref(0).selection);
      expect(l.ref(0).selection.from).to.equal(l.ref(0));
      expect(l.ref(0).selection.to).to.equal(l.ref(0));
      expect(l.ref(1).selection).to.be.undefined;
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(0).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 0,
          to: 0,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected a selection (minimal), checked for pointers and attrs (inner overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(1).selection).to.equal(l.ref(0).selection);
      expect(l.ref(0).selection.to).to.equal(l.ref(1));
      expect(l.ref(1).selection.from).to.equal(l.ref(0));
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(0).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 0,
          to: 1,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected a selection, checked for pointers and attrs (strict outer overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(3);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(4);
      sel = this.yTest.users[0].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(3).selection).to.be.undefined;
      expect(l.ref(1).selection).to.be.undefined;
      expect(l.ref(4).selection).to.be.undefined;
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([]);
    });
    it("intersected a selection (minimal), checked for pointers and attrs (strict outer overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(1).selection).to.be.undefined;
      expect(l.ref(3).selection).to.be.undefined;
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([]);
    });
    it("intersected a selection, checked for pointers and attrs (outer overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(3).selection).to.be.undefined;
      expect(l.ref(1).selection).to.be.undefined;
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([]);
    });
    it("intersected a selection (minimal), checked for pointers and attrs (outer overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(1);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(3).selection).to.be.undefined;
      expect(l.ref(1).selection).to.be.undefined;
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([]);
    });
    it("intersected a selection, checked for pointers and attrs (outer overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[0].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(1).selection).to.be.undefined;
      expect(l.ref(0).selection).to.be.undefined;
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([]);
    });
    return it("intersected a selection (minimal), checked for pointers and attrs (outer overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[0].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[0].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(1).selection).to.be.undefined;
      expect(l.ref(0).selection).to.be.undefined;
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      return expect(s).to.deep.equal([]);
    });
  });
  describe("Concurrent intersection of selections:", function() {
    it("intersected two elements, checked for pointers and attrs (strict inner overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(4);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(2);
      l_right = l.ref(3);
      this.yTest.users[1].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.equal(l.ref(3).selection);
      expect(l.ref(2).selection.from).to.equal(l.ref(2));
      expect(l.ref(2).selection.to).to.equal(l.ref(3));
      expect(l.ref(2).selection.attrs.c).to.equal("blue");
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(1));
      expect(l.ref(4).selection.from).to.equal(l.ref(4));
      expect(l.ref(4).selection.to).to.equal(l.ref(4));
      expect(l.ref(2).selection.attrs.c).to.equal("blue");
      expect(l.ref(3).selection.attrs.c).to.equal("blue");
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      expect(l.ref(4).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 1,
          to: 1,
          attrs: {
            "c": "black"
          }
        }, {
          from: 2,
          to: 3,
          attrs: {
            "c": "blue"
          }
        }, {
          from: 4,
          to: 4,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 1,
          attrs: {
            "c": "black"
          }
        }, {
          from: 2,
          to: 3,
          attrs: {
            "c": "blue"
          }
        }, {
          from: 4,
          to: 4,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements (minimal), checked for pointers and attrs (strict inner overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[1].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      this.yTest.flushAll();
      expect(l.ref(2).selection.from).to.equal(l.ref(2));
      expect(l.ref(2).selection.to).to.equal(l.ref(2));
      expect(l.ref(2).selection.attrs.c).to.equal("blue");
      expect(l.ref(2).selection.from).to.equal(l.ref(2));
      expect(l.ref(2).selection.to).to.equal(l.ref(2));
      expect(l.ref(2).selection.attrs.c).to.equal("blue");
      expect(l.ref(3).selection.attrs.c).to.equal("black");
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 1,
          to: 1,
          attrs: {
            "c": "black"
          }
        }, {
          from: 2,
          to: 2,
          attrs: {
            "c": "blue"
          }
        }, {
          from: 3,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 1,
          attrs: {
            "c": "black"
          }
        }, {
          from: 2,
          to: 2,
          attrs: {
            "c": "blue"
          }
        }, {
          from: 3,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements, checked for pointers and attrs (inner overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[1].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(2));
      expect(l.ref(1).selection.attrs.c).to.equal("blue");
      expect(l.ref(2).selection.from).to.equal(l.ref(1));
      expect(l.ref(2).selection.to).to.equal(l.ref(2));
      expect(l.ref(2).selection.attrs.c).to.equal("blue");
      expect(l.ref(3).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 1,
          to: 2,
          attrs: {
            "c": "blue"
          }
        }, {
          from: 3,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 2,
          attrs: {
            "c": "blue"
          }
        }, {
          from: 3,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements (minimal), checked for pointers and attrs (inner overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(1);
      l_right = l.ref(1);
      this.yTest.users[1].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(1));
      expect(l.ref(1).selection.attrs.c).to.equal("blue");
      expect(l.ref(2).selection.from).to.equal(l.ref(2));
      expect(l.ref(2).selection.to).to.equal(l.ref(3));
      expect(l.ref(1).selection.attrs.c).to.equal("blue");
      expect(l.ref(2).selection.attrs.c).to.equal("black");
      expect(l.ref(3).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 1,
          to: 1,
          attrs: {
            "c": "blue"
          }
        }, {
          from: 2,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 1,
          attrs: {
            "c": "blue"
          }
        }, {
          from: 2,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements, checked for pointers and attrs (inner overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[1].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(2));
      expect(l.ref(1).selection.attrs.c).to.equal("blue");
      expect(l.ref(2).selection.from).to.equal(l.ref(1));
      expect(l.ref(2).selection.to).to.equal(l.ref(2));
      expect(l.ref(2).selection.attrs.c).to.equal("blue");
      expect(l.ref(0).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 0,
          to: 0,
          attrs: {
            "c": "black"
          }
        }, {
          from: 1,
          to: 2,
          attrs: {
            "c": "blue"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 0,
          to: 0,
          attrs: {
            "c": "black"
          }
        }, {
          from: 1,
          to: 2,
          attrs: {
            "c": "blue"
          }
        }
      ]);
    });
    it("intersected two elements (minimal), checked for pointers and attrs (inner overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[1].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection).to.equal(l.ref(0).selection);
      expect(l.ref(2).selection.to).to.equal(l.ref(2));
      expect(l.ref(2).selection.from).to.equal(l.ref(2));
      expect(l.ref(0).selection.to).to.equal(l.ref(1));
      expect(l.ref(1).selection.from).to.equal(l.ref(0));
      expect(l.ref(2).selection.attrs.c).to.equal("blue");
      expect(l.ref(0).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 0,
          to: 1,
          attrs: {
            "c": "black"
          }
        }, {
          from: 2,
          to: 2,
          attrs: {
            "c": "blue"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 0,
          to: 1,
          attrs: {
            "c": "black"
          }
        }, {
          from: 2,
          to: 2,
          attrs: {
            "c": "blue"
          }
        }
      ]);
    });
    it("intersected two elements, checked for pointers and attrs (strict outer overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(3);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(1);
      l_right = l.ref(4);
      sel = this.yTest.users[1].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection).to.equal(l.ref(4).selection);
      expect(l.ref(1).selection.to).to.equal(l.ref(4));
      expect(l.ref(4).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 1,
          to: 4,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 4,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements (minimal), checked for pointers and attrs (strict outer overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[1].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection).to.equal(l.ref(3).selection);
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(3));
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 1,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements, checked for pointers and attrs (outer overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[1].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection).to.equal(l.ref(3).selection);
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(3));
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 1,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements (minimal), checked for pointers and attrs (outer overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(1);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[1].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      this.yTest.flushAll();
      expect(l.ref(1).selection).to.equal(l.ref(3).selection);
      expect(l.ref(1).selection.to).to.equal(l.ref(3));
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 1,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected two elements, checked for pointers and attrs (outer overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[1].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      this.yTest.flushAll();
      expect(l.ref(0).selection).to.equal(l.ref(2).selection);
      expect(l.ref(0).selection.from).to.equal(l.ref(0));
      expect(l.ref(0).selection.to).to.equal(l.ref(2));
      expect(l.ref(0).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 0,
          to: 2,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 0,
          to: 2,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    return it("intersected two elements (minimal), checked for pointers and attrs (outer overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[1].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      this.yTest.flushAll();
      expect(l.ref(0).selection).to.equal(l.ref(2).selection);
      expect(l.ref(0).selection.to).to.equal(l.ref(2));
      expect(l.ref(2).selection.from).to.equal(l.ref(0));
      expect(l.ref(0).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 0,
          to: 2,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 0,
          to: 2,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
  });
  return describe("Concurrent Unselections", function() {
    it("intersected a selection, checked for pointers and attrs (strict inner overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(4);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(2);
      l_right = l.ref(3);
      this.yTest.users[1].val("selections").unselect(l_left, l_right, ["c"]);
      this.yTest.flushAll();
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(1));
      expect(l.ref(4).selection.from).to.equal(l.ref(4));
      expect(l.ref(4).selection.to).to.equal(l.ref(4));
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(3).selection).to.be.undefined;
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      expect(l.ref(4).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 1,
          to: 1,
          attrs: {
            "c": "black"
          }
        }, {
          from: 4,
          to: 4,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 1,
          attrs: {
            "c": "black"
          }
        }, {
          from: 4,
          to: 4,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected a selection (minimal), checked for pointers and attrs (strict inner overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[1].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(1).selection.from).to.equal(l.ref(1));
      expect(l.ref(1).selection.to).to.equal(l.ref(1));
      expect(l.ref(3).selection.from).to.equal(l.ref(3));
      expect(l.ref(3).selection.to).to.equal(l.ref(3));
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(3).selection.attrs.c).to.equal("black");
      expect(l.ref(1).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 1,
          to: 1,
          attrs: {
            "c": "black"
          }
        }, {
          from: 3,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 1,
          to: 1,
          attrs: {
            "c": "black"
          }
        }, {
          from: 3,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected a selection, checked for pointers and attrs (inner overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[1].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(3).selection.from).to.equal(l.ref(3));
      expect(l.ref(3).selection.to).to.equal(l.ref(3));
      expect(l.ref(1).selection).to.be.undefined;
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(3).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 3,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 3,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected a selection (minimal), checked for pointers and attrs (inner overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(1);
      l_right = l.ref(1);
      this.yTest.users[1].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(2).selection.from).to.equal(l.ref(2));
      expect(l.ref(2).selection.to).to.equal(l.ref(3));
      expect(l.ref(1).selection).to.be.undefined;
      expect(l.ref(2).selection.attrs.c).to.equal("black");
      expect(l.ref(3).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 2,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 2,
          to: 3,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected a selection, checked for pointers and attrs (inner overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[1].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(0).selection.from).to.equal(l.ref(0));
      expect(l.ref(0).selection.to).to.equal(l.ref(0));
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(1).selection).to.be.undefined;
      expect(l.ref(0).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 0,
          to: 0,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 0,
          to: 0,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected a selection (minimal), checked for pointers and attrs (inner overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "black"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[1].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(1).selection).to.equal(l.ref(0).selection);
      expect(l.ref(0).selection.to).to.equal(l.ref(1));
      expect(l.ref(1).selection.from).to.equal(l.ref(0));
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(0).selection.attrs.c).to.equal("black");
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([
        {
          from: 0,
          to: 1,
          attrs: {
            "c": "black"
          }
        }
      ]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([
        {
          from: 0,
          to: 1,
          attrs: {
            "c": "black"
          }
        }
      ]);
    });
    it("intersected a selection, checked for pointers and attrs (strict outer overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(3);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(1);
      l_right = l.ref(4);
      sel = this.yTest.users[1].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(3).selection).to.be.undefined;
      expect(l.ref(1).selection).to.be.undefined;
      expect(l.ref(4).selection).to.be.undefined;
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([]);
    });
    it("intersected a selection (minimal), checked for pointers and attrs (strict outer overwrite)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[1].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(1).selection).to.be.undefined;
      expect(l.ref(3).selection).to.be.undefined;
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([]);
    });
    it("intersected a selection, checked for pointers and attrs (outer overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[1].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(3).selection).to.be.undefined;
      expect(l.ref(1).selection).to.be.undefined;
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([]);
    });
    it("intersected a selection (minimal), checked for pointers and attrs (outer overwrite, left non-strict, right strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(1);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(1);
      l_right = l.ref(3);
      sel = this.yTest.users[1].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(3).selection).to.be.undefined;
      expect(l.ref(1).selection).to.be.undefined;
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([]);
    });
    it("intersected a selection, checked for pointers and attrs (outer overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(1);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[1].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(1).selection).to.be.undefined;
      expect(l.ref(0).selection).to.be.undefined;
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([]);
    });
    return it("intersected a selection (minimal), checked for pointers and attrs (outer overwrite, right non-strict, left strict)", function() {
      var l, l_left, l_right, s, sel;
      l = this.yTest.users[0].val("list");
      l_left = l.ref(2);
      l_right = l.ref(2);
      this.yTest.users[0].val("selections").select(l_left, l_right, {
        "c": "blue"
      });
      l = this.yTest.users[1].val("list");
      l_left = l.ref(0);
      l_right = l.ref(2);
      sel = this.yTest.users[1].val("selections").unselect(l_left, l_right, "c");
      this.yTest.flushAll();
      expect(l.ref(2).selection).to.be.undefined;
      expect(l.ref(1).selection).to.be.undefined;
      expect(l.ref(0).selection).to.be.undefined;
      s = this.yTest.users[0].val("selections").getSelections(this.yTest.users[0].val("list"));
      expect(s).to.deep.equal([]);
      s = this.yTest.users[1].val("selections").getSelections(this.yTest.users[1].val("list"));
      return expect(s).to.deep.equal([]);
    });
  });
});

module.exports = SelectionsTest;

module.exports = SelectionsTest;


},{"../../y-list/lib/y-list.coffee":1,"../../y-test/lib/y-test.coffee":67,"../../yjs/lib/y":75,"../../yjs/test/TestSuite":146,"../lib/y-selections":2,"chai":3,"sinon":38,"sinon-chai":37,"underscore":65}],67:[function(require,module,exports){
var TestConnector;

TestConnector = (function() {
  function TestConnector(id) {
    var options;
    this.id = id;
    options = {
      syncMethod: "syncAll",
      role: "slave",
      user_id: this.id,
      perform_send_again: false
    };
    this.on_bound_to_y = (function(_this) {
      return function() {
        _this.init(options);
        _this.execution_order = [];
        _this.receive_buffer = {};
        return _this.receive_handlers.push(function(user, message) {
          return _this.execution_order.push(message);
        });
      };
    })(this);
  }

  TestConnector.prototype.join = function(conn) {
    var c, cid, _ref, _results;
    if (this.connections[conn.id] == null) {
      this.connections[conn.id] = {
        conn: conn
      };
      this.userJoined(conn.id, "slave");
      conn.join(this);
      this.flushAll();
      conn.flushAll();
      this.flushAll();
      conn.flushAll();
      _ref = conn.connections;
      _results = [];
      for (cid in _ref) {
        c = _ref[cid];
        if (this.connections[cid] == null) {
          _results.push(this.join(c.conn));
        } else {
          _results.push(void 0);
        }
      }
      return _results;
    }
  };

  TestConnector.prototype.getOpsInExecutionOrder = function() {
    return this.execution_order;
  };

  TestConnector.prototype.send = function(uid, message) {
    var rb, _name;
    if ((message.sync_step != null) && false) {
      return this.receiveMessage(uid, message);
    } else {
      rb = this.connections[uid].conn.receive_buffer;
      if (rb[_name = this.id] == null) {
        rb[_name] = [];
      }
      return rb[this.id].push(message);
    }
  };

  TestConnector.prototype.broadcast = function(message) {
    var c, name, _ref, _results;
    _ref = this.connections;
    _results = [];
    for (name in _ref) {
      c = _ref[name];
      _results.push(this.send(name, message));
    }
    return _results;
  };

  TestConnector.prototype.flushOne = function(uid) {
    var message, _ref;
    if (((_ref = this.receive_buffer[uid]) != null ? _ref.length : void 0) > 0) {
      message = this.receive_buffer[uid].shift();
      return this.receiveMessage(uid, message);
    }
  };

  TestConnector.prototype.flushOneRandom = function() {
    var c, cid, connlist, i;
    connlist = (function() {
      var _ref, _results;
      _ref = this.receive_buffer;
      _results = [];
      for (cid in _ref) {
        c = _ref[cid];
        _results.push(cid);
      }
      return _results;
    }).call(this);
    i = Math.ceil(Math.random() * connlist.length - 0.5);
    return this.flushOne(connlist[i]);
  };

  TestConnector.prototype.flushAll = function() {
    var message, messages, n, _i, _len, _ref;
    _ref = this.receive_buffer;
    for (n in _ref) {
      messages = _ref[n];
      for (_i = 0, _len = messages.length; _i < _len; _i++) {
        message = messages[_i];
        this.receiveMessage(n, message);
      }
    }
    return this.receive_buffer = {};
  };

  return TestConnector;

})();

if (typeof window !== "undefined" && window !== null) {
  if (typeof Y === "undefined" || Y === null) {
    throw new Error("You must import Y first!");
  } else {
    window.Y.TestConnector = TestConnector;
  }
}

if (typeof module !== "undefined" && module !== null) {
  module.exports = TestConnector;
}


},{}],68:[function(require,module,exports){
var ConnectorClass, adaptConnector;

ConnectorClass = require("./ConnectorClass");

adaptConnector = function(connector, engine, HB, execution_listener) {
  var applyHB, encode_state_vector, f, getHB, getStateVector, name, parse_state_vector, send_;
  for (name in ConnectorClass) {
    f = ConnectorClass[name];
    connector[name] = f;
  }
  connector.setIsBoundToY();
  send_ = function(o) {
    if ((o.uid.creator === HB.getUserId()) && (typeof o.uid.op_number !== "string") && (HB.getUserId() !== "_temp")) {
      return connector.broadcast(o);
    }
  };
  if (connector.invokeSync != null) {
    HB.setInvokeSyncHandler(connector.invokeSync);
  }
  execution_listener.push(send_);
  encode_state_vector = function(v) {
    var value, _results;
    _results = [];
    for (name in v) {
      value = v[name];
      _results.push({
        user: name,
        state: value
      });
    }
    return _results;
  };
  parse_state_vector = function(v) {
    var s, state_vector, _i, _len;
    state_vector = {};
    for (_i = 0, _len = v.length; _i < _len; _i++) {
      s = v[_i];
      state_vector[s.user] = s.state;
    }
    return state_vector;
  };
  getStateVector = function() {
    return encode_state_vector(HB.getOperationCounter());
  };
  getHB = function(v) {
    var hb, json, state_vector;
    state_vector = parse_state_vector(v);
    hb = HB._encode(state_vector);
    json = {
      hb: hb,
      state_vector: encode_state_vector(HB.getOperationCounter())
    };
    return json;
  };
  applyHB = function(hb, fromHB) {
    return engine.applyOp(hb, fromHB);
  };
  connector.getStateVector = getStateVector;
  connector.getHB = getHB;
  connector.applyHB = applyHB;
  if (connector.receive_handlers == null) {
    connector.receive_handlers = [];
  }
  return connector.receive_handlers.push(function(sender, op) {
    if (op.uid.creator !== HB.getUserId()) {
      return engine.applyOp(op);
    }
  });
};

module.exports = adaptConnector;


},{"./ConnectorClass":69}],69:[function(require,module,exports){
module.exports = {
  init: function(options) {
    var req;
    req = (function(_this) {
      return function(name, choices) {
        if (options[name] != null) {
          if ((choices == null) || choices.some(function(c) {
            return c === options[name];
          })) {
            return _this[name] = options[name];
          } else {
            throw new Error("You can set the '" + name + "' option to one of the following choices: " + JSON.encode(choices));
          }
        } else {
          throw new Error("You must specify " + name + ", when initializing the Connector!");
        }
      };
    })(this);
    req("syncMethod", ["syncAll", "master-slave"]);
    req("role", ["master", "slave"]);
    req("user_id");
    if (typeof this.on_user_id_set === "function") {
      this.on_user_id_set(this.user_id);
    }
    if (options.perform_send_again != null) {
      this.perform_send_again = options.perform_send_again;
    } else {
      this.perform_send_again = true;
    }
    if (this.role === "master") {
      this.syncMethod = "syncAll";
    }
    this.is_synced = false;
    this.connections = {};
    if (this.receive_handlers == null) {
      this.receive_handlers = [];
    }
    this.connections = {};
    this.current_sync_target = null;
    this.sent_hb_to_all_users = false;
    return this.is_initialized = true;
  },
  onUserEvent: function(f) {
    if (this.connections_listeners == null) {
      this.connections_listeners = [];
    }
    return this.connections_listeners.push(f);
  },
  isRoleMaster: function() {
    return this.role === "master";
  },
  isRoleSlave: function() {
    return this.role === "slave";
  },
  findNewSyncTarget: function() {
    var c, user, _ref;
    this.current_sync_target = null;
    if (this.syncMethod === "syncAll") {
      _ref = this.connections;
      for (user in _ref) {
        c = _ref[user];
        if (!c.is_synced) {
          this.performSync(user);
          break;
        }
      }
    }
    if (this.current_sync_target == null) {
      this.setStateSynced();
    }
    return null;
  },
  userLeft: function(user) {
    var f, _i, _len, _ref, _results;
    delete this.connections[user];
    this.findNewSyncTarget();
    if (this.connections_listeners != null) {
      _ref = this.connections_listeners;
      _results = [];
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        f = _ref[_i];
        _results.push(f({
          action: "userLeft",
          user: user
        }));
      }
      return _results;
    }
  },
  userJoined: function(user, role) {
    var f, _base, _i, _len, _ref, _results;
    if (role == null) {
      throw new Error("Internal: You must specify the role of the joined user! E.g. userJoined('uid:3939','slave')");
    }
    if ((_base = this.connections)[user] == null) {
      _base[user] = {};
    }
    this.connections[user].is_synced = false;
    if ((!this.is_synced) || this.syncMethod === "syncAll") {
      if (this.syncMethod === "syncAll") {
        this.performSync(user);
      } else if (role === "master") {
        this.performSyncWithMaster(user);
      }
    }
    if (this.connections_listeners != null) {
      _ref = this.connections_listeners;
      _results = [];
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        f = _ref[_i];
        _results.push(f({
          action: "userJoined",
          user: user,
          role: role
        }));
      }
      return _results;
    }
  },
  whenSynced: function(args) {
    if (args.constructor === Function) {
      args = [args];
    }
    if (this.is_synced) {
      return args[0].apply(this, args.slice(1));
    } else {
      if (this.compute_when_synced == null) {
        this.compute_when_synced = [];
      }
      return this.compute_when_synced.push(args);
    }
  },
  onReceive: function(f) {
    return this.receive_handlers.push(f);
  },

  /*
   * Broadcast a message to all connected peers.
   * @param message {Object} The message to broadcast.
   *
  broadcast: (message)->
    throw new Error "You must implement broadcast!"
  
   *
   * Send a message to a peer, or set of peers
   *
  send: (peer_s, message)->
    throw new Error "You must implement send!"
   */
  performSync: function(user) {
    var hb, o, _hb, _i, _len;
    if (this.current_sync_target == null) {
      this.current_sync_target = user;
      this.send(user, {
        sync_step: "getHB",
        send_again: "true",
        data: this.getStateVector()
      });
      if (!this.sent_hb_to_all_users) {
        this.sent_hb_to_all_users = true;
        hb = this.getHB([]).hb;
        _hb = [];
        for (_i = 0, _len = hb.length; _i < _len; _i++) {
          o = hb[_i];
          _hb.push(o);
          if (_hb.length > 10) {
            this.broadcast({
              sync_step: "applyHB_",
              data: _hb
            });
            _hb = [];
          }
        }
        return this.broadcast({
          sync_step: "applyHB",
          data: _hb
        });
      }
    }
  },
  performSyncWithMaster: function(user) {
    var hb, o, _hb, _i, _len;
    this.current_sync_target = user;
    this.send(user, {
      sync_step: "getHB",
      send_again: "true",
      data: this.getStateVector()
    });
    hb = this.getHB([]).hb;
    _hb = [];
    for (_i = 0, _len = hb.length; _i < _len; _i++) {
      o = hb[_i];
      _hb.push(o);
      if (_hb.length > 10) {
        this.broadcast({
          sync_step: "applyHB_",
          data: _hb
        });
        _hb = [];
      }
    }
    return this.broadcast({
      sync_step: "applyHB",
      data: _hb
    });
  },
  setStateSynced: function() {
    var args, el, f, _i, _len, _ref;
    if (!this.is_synced) {
      this.is_synced = true;
      if (this.compute_when_synced != null) {
        _ref = this.compute_when_synced;
        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
          el = _ref[_i];
          f = el[0];
          args = el.slice(1);
          f.apply(args);
        }
        delete this.compute_when_synced;
      }
      return null;
    }
  },
  whenReceivedStateVector: function(f) {
    if (this.when_received_state_vector_listeners == null) {
      this.when_received_state_vector_listeners = [];
    }
    return this.when_received_state_vector_listeners.push(f);
  },
  receiveMessage: function(sender, res) {
    var data, f, hb, o, sendApplyHB, send_again, _hb, _i, _j, _k, _len, _len1, _len2, _ref, _ref1, _results;
    if (res.sync_step == null) {
      _ref = this.receive_handlers;
      _results = [];
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        f = _ref[_i];
        _results.push(f(sender, res));
      }
      return _results;
    } else {
      if (sender === this.user_id) {
        return;
      }
      if (res.sync_step === "getHB") {
        if (this.when_received_state_vector_listeners != null) {
          _ref1 = this.when_received_state_vector_listeners;
          for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
            f = _ref1[_j];
            f.call(this, res.data);
          }
        }
        delete this.when_received_state_vector_listeners;
        data = this.getHB(res.data);
        hb = data.hb;
        _hb = [];
        if (this.is_synced) {
          sendApplyHB = (function(_this) {
            return function(m) {
              return _this.send(sender, m);
            };
          })(this);
        } else {
          sendApplyHB = (function(_this) {
            return function(m) {
              return _this.broadcast(m);
            };
          })(this);
        }
        for (_k = 0, _len2 = hb.length; _k < _len2; _k++) {
          o = hb[_k];
          _hb.push(o);
          if (_hb.length > 10) {
            sendApplyHB({
              sync_step: "applyHB_",
              data: _hb
            });
            _hb = [];
          }
        }
        sendApplyHB({
          sync_step: "applyHB",
          data: _hb
        });
        if ((res.send_again != null) && this.perform_send_again) {
          send_again = (function(_this) {
            return function(sv) {
              return function() {
                var _l, _len3;
                hb = _this.getHB(sv).hb;
                for (_l = 0, _len3 = hb.length; _l < _len3; _l++) {
                  o = hb[_l];
                  _hb.push(o);
                  if (_hb.length > 10) {
                    _this.send(sender, {
                      sync_step: "applyHB_",
                      data: _hb
                    });
                    _hb = [];
                  }
                }
                return _this.send(sender, {
                  sync_step: "applyHB",
                  data: _hb,
                  sent_again: "true"
                });
              };
            };
          })(this)(data.state_vector);
          return setTimeout(send_again, 3000);
        }
      } else if (res.sync_step === "applyHB") {
        this.applyHB(res.data, sender === this.current_sync_target);
        if ((this.syncMethod === "syncAll" || (res.sent_again != null)) && (!this.is_synced) && ((this.current_sync_target === sender) || (this.current_sync_target == null))) {
          this.connections[sender].is_synced = true;
          return this.findNewSyncTarget();
        }
      } else if (res.sync_step === "applyHB_") {
        return this.applyHB(res.data, sender === this.current_sync_target);
      }
    }
  },
  parseMessageFromXml: function(m) {
    var parse_array, parse_object;
    parse_array = function(node) {
      var n, _i, _len, _ref, _results;
      _ref = node.children;
      _results = [];
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        n = _ref[_i];
        if (n.getAttribute("isArray") === "true") {
          _results.push(parse_array(n));
        } else {
          _results.push(parse_object(n));
        }
      }
      return _results;
    };
    parse_object = function(node) {
      var int, json, n, name, value, _i, _len, _ref, _ref1;
      json = {};
      _ref = node.attrs;
      for (name in _ref) {
        value = _ref[name];
        int = parseInt(value);
        if (isNaN(int) || ("" + int) !== value) {
          json[name] = value;
        } else {
          json[name] = int;
        }
      }
      _ref1 = node.children;
      for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
        n = _ref1[_i];
        name = n.name;
        if (n.getAttribute("isArray") === "true") {
          json[name] = parse_array(n);
        } else {
          json[name] = parse_object(n);
        }
      }
      return json;
    };
    return parse_object(m);
  },
  encodeMessageToXml: function(m, json) {
    var encode_array, encode_object;
    encode_object = function(m, json) {
      var name, value;
      for (name in json) {
        value = json[name];
        if (value == null) {

        } else if (value.constructor === Object) {
          encode_object(m.c(name), value);
        } else if (value.constructor === Array) {
          encode_array(m.c(name), value);
        } else {
          m.setAttribute(name, value);
        }
      }
      return m;
    };
    encode_array = function(m, array) {
      var e, _i, _len;
      m.setAttribute("isArray", "true");
      for (_i = 0, _len = array.length; _i < _len; _i++) {
        e = array[_i];
        if (e.constructor === Object) {
          encode_object(m.c("array-element"), e);
        } else {
          encode_array(m.c("array-element"), e);
        }
      }
      return m;
    };
    if (json.constructor === Object) {
      return encode_object(m.c("y", {
        xmlns: "http://y.ninja/connector-stanza"
      }), json);
    } else if (json.constructor === Array) {
      return encode_array(m.c("y", {
        xmlns: "http://y.ninja/connector-stanza"
      }), json);
    } else {
      throw new Error("I can't encode this json!");
    }
  },
  setIsBoundToY: function() {
    if (typeof this.on_bound_to_y === "function") {
      this.on_bound_to_y();
    }
    delete this.when_bound_to_y;
    return this.is_bound_to_y = true;
  }
};


},{}],70:[function(require,module,exports){
var Engine;

if (typeof window !== "undefined" && window !== null) {
  window.unprocessed_counter = 0;
}

if (typeof window !== "undefined" && window !== null) {
  window.unprocessed_exec_counter = 0;
}

if (typeof window !== "undefined" && window !== null) {
  window.unprocessed_types = [];
}

Engine = (function() {
  function Engine(HB, types) {
    this.HB = HB;
    this.types = types;
    this.unprocessed_ops = [];
  }

  Engine.prototype.parseOperation = function(json) {
    var type;
    type = this.types[json.type];
    if ((type != null ? type.parse : void 0) != null) {
      return type.parse(json);
    } else {
      throw new Error("You forgot to specify a parser for type " + json.type + ". The message is " + (JSON.stringify(json)) + ".");
    }
  };


  /*
  applyOpsBundle: (ops_json)->
    ops = []
    for o in ops_json
      ops.push @parseOperation o
    for o in ops
      if not o.execute()
        @unprocessed_ops.push o
    @tryUnprocessed()
   */

  Engine.prototype.applyOpsCheckDouble = function(ops_json) {
    var o, _i, _len, _results;
    _results = [];
    for (_i = 0, _len = ops_json.length; _i < _len; _i++) {
      o = ops_json[_i];
      if (this.HB.getOperation(o.uid) == null) {
        _results.push(this.applyOp(o));
      } else {
        _results.push(void 0);
      }
    }
    return _results;
  };

  Engine.prototype.applyOps = function(ops_json) {
    return this.applyOp(ops_json);
  };

  Engine.prototype.applyOp = function(op_json_array, fromHB) {
    var o, op_json, _i, _len;
    if (fromHB == null) {
      fromHB = false;
    }
    if (op_json_array.constructor !== Array) {
      op_json_array = [op_json_array];
    }
    for (_i = 0, _len = op_json_array.length; _i < _len; _i++) {
      op_json = op_json_array[_i];
      if (fromHB) {
        op_json.fromHB = "true";
      }
      o = this.parseOperation(op_json);
      o.parsed_from_json = op_json;
      if (op_json.fromHB != null) {
        o.fromHB = op_json.fromHB;
      }
      if (this.HB.getOperation(o) != null) {

      } else if (((!this.HB.isExpectedOperation(o)) && (o.fromHB == null)) || (!o.execute())) {
        this.unprocessed_ops.push(o);
        if (typeof window !== "undefined" && window !== null) {
          window.unprocessed_types.push(o.type);
        }
      }
    }
    return this.tryUnprocessed();
  };

  Engine.prototype.tryUnprocessed = function() {
    var old_length, op, unprocessed, _i, _len, _ref;
    while (true) {
      old_length = this.unprocessed_ops.length;
      unprocessed = [];
      _ref = this.unprocessed_ops;
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        op = _ref[_i];
        if (this.HB.getOperation(op) != null) {

        } else if ((!this.HB.isExpectedOperation(op) && (op.fromHB == null)) || (!op.execute())) {
          unprocessed.push(op);
        }
      }
      this.unprocessed_ops = unprocessed;
      if (this.unprocessed_ops.length === old_length) {
        break;
      }
    }
    if (this.unprocessed_ops.length !== 0) {
      return this.HB.invokeSync();
    }
  };

  return Engine;

})();

module.exports = Engine;


},{}],71:[function(require,module,exports){
var HistoryBuffer,
  __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };

HistoryBuffer = (function() {
  function HistoryBuffer(user_id) {
    this.user_id = user_id;
    this.emptyGarbage = __bind(this.emptyGarbage, this);
    this.operation_counter = {};
    this.buffer = {};
    this.change_listeners = [];
    this.garbage = [];
    this.trash = [];
    this.performGarbageCollection = true;
    this.garbageCollectTimeout = 30000;
    this.reserved_identifier_counter = 0;
    setTimeout(this.emptyGarbage, this.garbageCollectTimeout);
  }

  HistoryBuffer.prototype.setUserId = function(user_id, state_vector) {
    var buff, counter_diff, o, o_name, _base, _name, _ref;
    this.user_id = user_id;
    if ((_base = this.buffer)[_name = this.user_id] == null) {
      _base[_name] = [];
    }
    buff = this.buffer[this.user_id];
    counter_diff = state_vector[this.user_id] || 0;
    if (this.buffer._temp != null) {
      _ref = this.buffer._temp;
      for (o_name in _ref) {
        o = _ref[o_name];
        o.uid.creator = this.user_id;
        o.uid.op_number += counter_diff;
        buff[o.uid.op_number] = o;
      }
    }
    this.operation_counter[this.user_id] = (this.operation_counter._temp || 0) + counter_diff;
    delete this.operation_counter._temp;
    return delete this.buffer._temp;
  };

  HistoryBuffer.prototype.emptyGarbage = function() {
    var o, _i, _len, _ref;
    _ref = this.garbage;
    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
      o = _ref[_i];
      if (typeof o.cleanup === "function") {
        o.cleanup();
      }
    }
    this.garbage = this.trash;
    this.trash = [];
    if (this.garbageCollectTimeout !== -1) {
      this.garbageCollectTimeoutId = setTimeout(this.emptyGarbage, this.garbageCollectTimeout);
    }
    return void 0;
  };

  HistoryBuffer.prototype.getUserId = function() {
    return this.user_id;
  };

  HistoryBuffer.prototype.addToGarbageCollector = function() {
    var o, _i, _len, _results;
    if (this.performGarbageCollection) {
      _results = [];
      for (_i = 0, _len = arguments.length; _i < _len; _i++) {
        o = arguments[_i];
        if (o != null) {
          _results.push(this.garbage.push(o));
        } else {
          _results.push(void 0);
        }
      }
      return _results;
    }
  };

  HistoryBuffer.prototype.stopGarbageCollection = function() {
    this.performGarbageCollection = false;
    this.setManualGarbageCollect();
    this.garbage = [];
    return this.trash = [];
  };

  HistoryBuffer.prototype.setManualGarbageCollect = function() {
    this.garbageCollectTimeout = -1;
    clearTimeout(this.garbageCollectTimeoutId);
    return this.garbageCollectTimeoutId = void 0;
  };

  HistoryBuffer.prototype.setGarbageCollectTimeout = function(garbageCollectTimeout) {
    this.garbageCollectTimeout = garbageCollectTimeout;
  };

  HistoryBuffer.prototype.getReservedUniqueIdentifier = function() {
    return {
      creator: '_',
      op_number: "_" + (this.reserved_identifier_counter++)
    };
  };

  HistoryBuffer.prototype.getOperationCounter = function(user_id) {
    var ctn, res, user, _ref;
    if (user_id == null) {
      res = {};
      _ref = this.operation_counter;
      for (user in _ref) {
        ctn = _ref[user];
        res[user] = ctn;
      }
      return res;
    } else {
      return this.operation_counter[user_id];
    }
  };

  HistoryBuffer.prototype.isExpectedOperation = function(o) {
    var _base, _name;
    if ((_base = this.operation_counter)[_name = o.uid.creator] == null) {
      _base[_name] = 0;
    }
    o.uid.op_number <= this.operation_counter[o.uid.creator];
    return true;
  };

  HistoryBuffer.prototype._encode = function(state_vector) {
    var json, o, o_json, o_next, o_number, o_prev, u_name, unknown, user, _ref;
    if (state_vector == null) {
      state_vector = {};
    }
    json = [];
    unknown = function(user, o_number) {
      if ((user == null) || (o_number == null)) {
        throw new Error("dah!");
      }
      return (state_vector[user] == null) || state_vector[user] <= o_number;
    };
    _ref = this.buffer;
    for (u_name in _ref) {
      user = _ref[u_name];
      if (u_name === "_") {
        continue;
      }
      for (o_number in user) {
        o = user[o_number];
        if ((o.uid.noOperation == null) && unknown(u_name, o_number)) {
          o_json = o._encode();
          if (o.next_cl != null) {
            o_next = o.next_cl;
            while ((o_next.next_cl != null) && unknown(o_next.uid.creator, o_next.uid.op_number)) {
              o_next = o_next.next_cl;
            }
            o_json.next = o_next.getUid();
          } else if (o.prev_cl != null) {
            o_prev = o.prev_cl;
            while ((o_prev.prev_cl != null) && unknown(o_prev.uid.creator, o_prev.uid.op_number)) {
              o_prev = o_prev.prev_cl;
            }
            o_json.prev = o_prev.getUid();
          }
          json.push(o_json);
        }
      }
    }
    return json;
  };

  HistoryBuffer.prototype.getNextOperationIdentifier = function(user_id) {
    var uid;
    if (user_id == null) {
      user_id = this.user_id;
    }
    if (this.operation_counter[user_id] == null) {
      this.operation_counter[user_id] = 0;
    }
    uid = {
      'creator': user_id,
      'op_number': this.operation_counter[user_id]
    };
    this.operation_counter[user_id]++;
    return uid;
  };

  HistoryBuffer.prototype.getOperation = function(uid) {
    var o, _ref;
    if (uid.uid != null) {
      uid = uid.uid;
    }
    o = (_ref = this.buffer[uid.creator]) != null ? _ref[uid.op_number] : void 0;
    if ((uid.sub != null) && (o != null)) {
      return o.retrieveSub(uid.sub);
    } else {
      return o;
    }
  };

  HistoryBuffer.prototype.addOperation = function(o) {
    if (this.buffer[o.uid.creator] == null) {
      this.buffer[o.uid.creator] = {};
    }
    if (this.buffer[o.uid.creator][o.uid.op_number] != null) {
      throw new Error("You must not overwrite operations!");
    }
    if ((o.uid.op_number.constructor !== String) && (!this.isExpectedOperation(o)) && (o.fromHB == null)) {
      throw new Error("this operation was not expected!");
    }
    this.addToCounter(o);
    this.buffer[o.uid.creator][o.uid.op_number] = o;
    return o;
  };

  HistoryBuffer.prototype.removeOperation = function(o) {
    var _ref;
    return (_ref = this.buffer[o.uid.creator]) != null ? delete _ref[o.uid.op_number] : void 0;
  };

  HistoryBuffer.prototype.setInvokeSyncHandler = function(f) {
    return this.invokeSync = f;
  };

  HistoryBuffer.prototype.invokeSync = function() {};

  HistoryBuffer.prototype.renewStateVector = function(state_vector) {
    var state, user, _results;
    _results = [];
    for (user in state_vector) {
      state = state_vector[user];
      if (((this.operation_counter[user] == null) || (this.operation_counter[user] < state_vector[user])) && (state_vector[user] != null)) {
        _results.push(this.operation_counter[user] = state_vector[user]);
      } else {
        _results.push(void 0);
      }
    }
    return _results;
  };

  HistoryBuffer.prototype.addToCounter = function(o) {
    var _base, _name;
    if ((_base = this.operation_counter)[_name = o.uid.creator] == null) {
      _base[_name] = 0;
    }
    if (o.uid.op_number === this.operation_counter[o.uid.creator]) {
      this.operation_counter[o.uid.creator]++;
    }
    while (this.buffer[o.uid.creator][this.operation_counter[o.uid.creator]] != null) {
      this.operation_counter[o.uid.creator]++;
    }
    return void 0;
  };

  return HistoryBuffer;

})();

module.exports = HistoryBuffer;


},{}],72:[function(require,module,exports){
var YObject;

YObject = (function() {
  function YObject(_object) {
    var name, val, _ref;
    this._object = _object != null ? _object : {};
    if (this._object.constructor === Object) {
      _ref = this._object;
      for (name in _ref) {
        val = _ref[name];
        if (val.constructor === Object) {
          this._object[name] = new YObject(val);
        }
      }
    } else {
      throw new Error("Y.Object accepts Json Objects only");
    }
  }

  YObject.prototype._name = "Object";

  YObject.prototype._getModel = function(types, ops) {
    var n, o, _ref;
    if (this._model == null) {
      this._model = new ops.MapManager(this).execute();
      _ref = this._object;
      for (n in _ref) {
        o = _ref[n];
        this._model.val(n, o);
      }
    }
    delete this._object;
    return this._model;
  };

  YObject.prototype._setModel = function(_model) {
    this._model = _model;
    return delete this._object;
  };

  YObject.prototype.observe = function(f) {
    this._model.observe(f);
    return this;
  };

  YObject.prototype.unobserve = function(f) {
    this._model.unobserve(f);
    return this;
  };

  YObject.prototype.val = function(name, content) {
    var n, res, v, _ref;
    if (this._model != null) {
      return this._model.val.apply(this._model, arguments);
    } else {
      if (content != null) {
        return this._object[name] = content;
      } else if (name != null) {
        return this._object[name];
      } else {
        res = {};
        _ref = this._object;
        for (n in _ref) {
          v = _ref[n];
          res[n] = v;
        }
        return res;
      }
    }
  };

  YObject.prototype["delete"] = function(name) {
    this._model["delete"](name);
    return this;
  };

  return YObject;

})();

if (typeof window !== "undefined" && window !== null) {
  if (window.Y != null) {
    window.Y.Object = YObject;
  } else {
    throw new Error("You must first import Y!");
  }
}

if (typeof module !== "undefined" && module !== null) {
  module.exports = YObject;
}


},{}],73:[function(require,module,exports){
var __slice = [].slice,
  __hasProp = {}.hasOwnProperty,
  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

module.exports = function() {
  var execution_listener, ops;
  ops = {};
  execution_listener = [];
  ops.Operation = (function() {
    function Operation(custom_type, uid, content, content_operations) {
      var name, op;
      if (custom_type != null) {
        this.custom_type = custom_type;
      }
      this.is_deleted = false;
      this.garbage_collected = false;
      this.event_listeners = [];
      if (uid != null) {
        this.uid = uid;
      }
      if (content === void 0) {

      } else if ((content != null) && (content.creator != null)) {
        this.saveOperation('content', content);
      } else {
        this.content = content;
      }
      if (content_operations != null) {
        this.content_operations = {};
        for (name in content_operations) {
          op = content_operations[name];
          this.saveOperation(name, op, 'content_operations');
        }
      }
    }

    Operation.prototype.type = "Operation";

    Operation.prototype.getContent = function(name) {
      var content, n, v, _ref, _ref1;
      if (this.content != null) {
        if (this.content.getCustomType != null) {
          return this.content.getCustomType();
        } else if (this.content.constructor === Object) {
          if (name != null) {
            if (this.content[name] != null) {
              return this.content[name];
            } else {
              return this.content_operations[name].getCustomType();
            }
          } else {
            content = {};
            _ref = this.content;
            for (n in _ref) {
              v = _ref[n];
              content[n] = v;
            }
            if (this.content_operations != null) {
              _ref1 = this.content_operations;
              for (n in _ref1) {
                v = _ref1[n];
                v = v.getCustomType();
                content[n] = v;
              }
            }
            return content;
          }
        } else {
          return this.content;
        }
      } else {
        return this.content;
      }
    };

    Operation.prototype.retrieveSub = function() {
      throw new Error("sub properties are not enable on this operation type!");
    };

    Operation.prototype.observe = function(f) {
      return this.event_listeners.push(f);
    };

    Operation.prototype.unobserve = function(f) {
      return this.event_listeners = this.event_listeners.filter(function(g) {
        return f !== g;
      });
    };

    Operation.prototype.deleteAllObservers = function() {
      return this.event_listeners = [];
    };

    Operation.prototype["delete"] = function() {
      (new ops.Delete(void 0, this)).execute();
      return null;
    };

    Operation.prototype.callEvent = function() {
      var callon;
      if (this.custom_type != null) {
        callon = this.getCustomType();
      } else {
        callon = this;
      }
      return this.forwardEvent.apply(this, [callon].concat(__slice.call(arguments)));
    };

    Operation.prototype.forwardEvent = function() {
      var args, f, op, _i, _len, _ref, _results;
      op = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
      _ref = this.event_listeners;
      _results = [];
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        f = _ref[_i];
        _results.push(f.call.apply(f, [op].concat(__slice.call(args))));
      }
      return _results;
    };

    Operation.prototype.isDeleted = function() {
      return this.is_deleted;
    };

    Operation.prototype.applyDelete = function(garbagecollect) {
      if (garbagecollect == null) {
        garbagecollect = true;
      }
      if (!this.garbage_collected) {
        this.is_deleted = true;
        if (garbagecollect) {
          this.garbage_collected = true;
          return this.HB.addToGarbageCollector(this);
        }
      }
    };

    Operation.prototype.cleanup = function() {
      this.HB.removeOperation(this);
      return this.deleteAllObservers();
    };

    Operation.prototype.setParent = function(parent) {
      this.parent = parent;
    };

    Operation.prototype.getParent = function() {
      return this.parent;
    };

    Operation.prototype.getUid = function() {
      var map_uid;
      if (this.uid.noOperation == null) {
        return this.uid;
      } else {
        if (this.uid.alt != null) {
          map_uid = this.uid.alt.cloneUid();
          map_uid.sub = this.uid.sub;
          return map_uid;
        } else {
          return void 0;
        }
      }
    };

    Operation.prototype.cloneUid = function() {
      var n, uid, v, _ref;
      uid = {};
      _ref = this.getUid();
      for (n in _ref) {
        v = _ref[n];
        uid[n] = v;
      }
      return uid;
    };

    Operation.prototype.execute = function() {
      var l, _i, _len;
      if (this.validateSavedOperations()) {
        this.is_executed = true;
        if (this.uid == null) {
          this.uid = this.HB.getNextOperationIdentifier();
        }
        if (this.uid.noOperation == null) {
          this.HB.addOperation(this);
          for (_i = 0, _len = execution_listener.length; _i < _len; _i++) {
            l = execution_listener[_i];
            l(this._encode());
          }
        }
        return this;
      } else {
        return false;
      }
    };

    Operation.prototype.saveOperation = function(name, op, base) {
      var dest, last_path, path, paths, _base, _i, _len;
      if (base == null) {
        base = "this";
      }
      if ((op != null) && (op._getModel != null)) {
        op = op._getModel(this.custom_types, this.operations);
      }
      if (op == null) {

      } else if ((op.execute != null) || !((op.op_number != null) && (op.creator != null))) {
        if (base === "this") {
          return this[name] = op;
        } else {
          dest = this[base];
          paths = name.split("/");
          last_path = paths.pop();
          for (_i = 0, _len = paths.length; _i < _len; _i++) {
            path = paths[_i];
            dest = dest[path];
          }
          return dest[last_path] = op;
        }
      } else {
        if (this.unchecked == null) {
          this.unchecked = {};
        }
        if ((_base = this.unchecked)[base] == null) {
          _base[base] = {};
        }
        return this.unchecked[base][name] = op;
      }
    };

    Operation.prototype.validateSavedOperations = function() {
      var base, base_name, dest, last_path, name, op, op_uid, path, paths, success, uninstantiated, _i, _len, _ref;
      uninstantiated = {};
      success = true;
      _ref = this.unchecked;
      for (base_name in _ref) {
        base = _ref[base_name];
        for (name in base) {
          op_uid = base[name];
          op = this.HB.getOperation(op_uid);
          if (op) {
            if (base_name === "this") {
              this[name] = op;
            } else {
              dest = this[base_name];
              paths = name.split("/");
              last_path = paths.pop();
              for (_i = 0, _len = paths.length; _i < _len; _i++) {
                path = paths[_i];
                dest = dest[path];
              }
              dest[last_path] = op;
            }
          } else {
            if (uninstantiated[base_name] == null) {
              uninstantiated[base_name] = {};
            }
            uninstantiated[base_name][name] = op_uid;
            success = false;
          }
        }
      }
      if (!success) {
        this.unchecked = uninstantiated;
        return false;
      } else {
        delete this.unchecked;
        return this;
      }
    };

    Operation.prototype.getCustomType = function() {
      var Type, t, _i, _len, _ref;
      if (this.custom_type == null) {
        return this;
      } else {
        if (this.custom_type.constructor === String) {
          Type = this.custom_types;
          _ref = this.custom_type.split(".");
          for (_i = 0, _len = _ref.length; _i < _len; _i++) {
            t = _ref[_i];
            Type = Type[t];
          }
          this.custom_type = new Type();
          this.custom_type._setModel(this);
        }
        return this.custom_type;
      }
    };

    Operation.prototype._encode = function(json) {
      var n, o, operations, _ref, _ref1;
      if (json == null) {
        json = {};
      }
      json.type = this.type;
      json.uid = this.getUid();
      if (this.custom_type != null) {
        if (this.custom_type.constructor === String) {
          json.custom_type = this.custom_type;
        } else {
          json.custom_type = this.custom_type._name;
        }
      }
      if (((_ref = this.content) != null ? _ref.getUid : void 0) != null) {
        json.content = this.content.getUid();
      } else {
        json.content = this.content;
      }
      if (this.content_operations != null) {
        operations = {};
        _ref1 = this.content_operations;
        for (n in _ref1) {
          o = _ref1[n];
          if (o._getModel != null) {
            o = o._getModel(this.custom_types, this.operations);
          }
          operations[n] = o.getUid();
        }
        json.content_operations = operations;
      }
      return json;
    };

    return Operation;

  })();
  ops.Delete = (function(_super) {
    __extends(Delete, _super);

    function Delete(custom_type, uid, deletes) {
      this.saveOperation('deletes', deletes);
      Delete.__super__.constructor.call(this, custom_type, uid);
    }

    Delete.prototype.type = "Delete";

    Delete.prototype._encode = function() {
      return {
        'type': "Delete",
        'uid': this.getUid(),
        'deletes': this.deletes.getUid()
      };
    };

    Delete.prototype.execute = function() {
      var res;
      if (this.validateSavedOperations()) {
        res = Delete.__super__.execute.apply(this, arguments);
        if (res) {
          this.deletes.applyDelete(this);
        }
        return res;
      } else {
        return false;
      }
    };

    return Delete;

  })(ops.Operation);
  ops.Delete.parse = function(o) {
    var deletes_uid, uid;
    uid = o['uid'], deletes_uid = o['deletes'];
    return new this(null, uid, deletes_uid);
  };
  ops.Insert = (function(_super) {
    __extends(Insert, _super);

    function Insert(custom_type, content, content_operations, parent, uid, prev_cl, next_cl, origin) {
      this.saveOperation('parent', parent);
      this.saveOperation('prev_cl', prev_cl);
      this.saveOperation('next_cl', next_cl);
      if (origin != null) {
        this.saveOperation('origin', origin);
      } else {
        this.saveOperation('origin', prev_cl);
      }
      Insert.__super__.constructor.call(this, custom_type, uid, content, content_operations);
    }

    Insert.prototype.type = "Insert";

    Insert.prototype.val = function() {
      return this.getContent();
    };

    Insert.prototype.getNext = function(i) {
      var n;
      if (i == null) {
        i = 1;
      }
      n = this;
      while (i > 0 && (n.next_cl != null)) {
        n = n.next_cl;
        if (!n.is_deleted) {
          i--;
        }
      }
      if (n.is_deleted) {
        null;
      }
      return n;
    };

    Insert.prototype.getPrev = function(i) {
      var n;
      if (i == null) {
        i = 1;
      }
      n = this;
      while (i > 0 && (n.prev_cl != null)) {
        n = n.prev_cl;
        if (!n.is_deleted) {
          i--;
        }
      }
      if (n.is_deleted) {
        return null;
      } else {
        return n;
      }
    };

    Insert.prototype.applyDelete = function(o) {
      var callLater, garbagecollect;
      if (this.deleted_by == null) {
        this.deleted_by = [];
      }
      callLater = false;
      if ((this.parent != null) && !this.is_deleted && (o != null)) {
        callLater = true;
      }
      if (o != null) {
        this.deleted_by.push(o);
      }
      garbagecollect = false;
      if (this.next_cl.isDeleted()) {
        garbagecollect = true;
      }
      Insert.__super__.applyDelete.call(this, garbagecollect);
      if (callLater) {
        this.parent.callOperationSpecificDeleteEvents(this, o);
      }
      if ((this.prev_cl != null) && this.prev_cl.isDeleted()) {
        return this.prev_cl.applyDelete();
      }
    };

    Insert.prototype.cleanup = function() {
      var d, o, _i, _len, _ref;
      if (this.next_cl.isDeleted()) {
        _ref = this.deleted_by;
        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
          d = _ref[_i];
          d.cleanup();
        }
        o = this.next_cl;
        while (o.type !== "Delimiter") {
          if (o.origin === this) {
            o.origin = this.prev_cl;
          }
          o = o.next_cl;
        }
        this.prev_cl.next_cl = this.next_cl;
        this.next_cl.prev_cl = this.prev_cl;
        if (this.content instanceof ops.Operation && !(this.content instanceof ops.Insert)) {
          this.content.referenced_by--;
          if (this.content.referenced_by <= 0 && !this.content.is_deleted) {
            this.content.applyDelete();
          }
        }
        delete this.content;
        return Insert.__super__.cleanup.apply(this, arguments);
      }
    };

    Insert.prototype.getDistanceToOrigin = function() {
      var d, o;
      d = 0;
      o = this.prev_cl;
      while (true) {
        if (this.origin === o) {
          break;
        }
        d++;
        o = o.prev_cl;
      }
      return d;
    };

    Insert.prototype.execute = function() {
      var distance_to_origin, i, o, _base;
      if (!this.validateSavedOperations()) {
        return false;
      } else {
        if (this.content instanceof ops.Operation) {
          this.content.insert_parent = this;
          if ((_base = this.content).referenced_by == null) {
            _base.referenced_by = 0;
          }
          this.content.referenced_by++;
        }
        if (this.parent != null) {
          if (this.prev_cl == null) {
            this.prev_cl = this.parent.beginning;
          }
          if (this.origin == null) {
            this.origin = this.prev_cl;
          } else if (this.origin === "Delimiter") {
            this.origin = this.parent.beginning;
          }
          if (this.next_cl == null) {
            this.next_cl = this.parent.end;
          }
        }
        if (this.prev_cl != null) {
          distance_to_origin = this.getDistanceToOrigin();
          o = this.prev_cl.next_cl;
          i = distance_to_origin;
          while (true) {
            if (o !== this.next_cl) {
              if (o.getDistanceToOrigin() === i) {
                if (o.uid.creator < this.uid.creator) {
                  this.prev_cl = o;
                  distance_to_origin = i + 1;
                } else {

                }
              } else if (o.getDistanceToOrigin() < i) {
                if (i - distance_to_origin <= o.getDistanceToOrigin()) {
                  this.prev_cl = o;
                  distance_to_origin = i + 1;
                } else {

                }
              } else {
                break;
              }
              i++;
              o = o.next_cl;
            } else {
              break;
            }
          }
          this.next_cl = this.prev_cl.next_cl;
          this.prev_cl.next_cl = this;
          this.next_cl.prev_cl = this;
        }
        this.setParent(this.prev_cl.getParent());
        Insert.__super__.execute.apply(this, arguments);
        this.parent.callOperationSpecificInsertEvents(this);
        return this;
      }
    };

    Insert.prototype.getPosition = function() {
      var position, prev;
      position = 0;
      prev = this.prev_cl;
      while (true) {
        if (prev instanceof ops.Delimiter) {
          break;
        }
        if (!prev.isDeleted()) {
          position++;
        }
        prev = prev.prev_cl;
      }
      return position;
    };

    Insert.prototype._encode = function(json) {
      if (json == null) {
        json = {};
      }
      json.prev = this.prev_cl.getUid();
      json.next = this.next_cl.getUid();
      if (this.origin.type === "Delimiter") {
        json.origin = "Delimiter";
      } else if (this.origin !== this.prev_cl) {
        json.origin = this.origin.getUid();
      }
      json.parent = this.parent.getUid();
      return Insert.__super__._encode.call(this, json);
    };

    return Insert;

  })(ops.Operation);
  ops.Insert.parse = function(json) {
    var content, content_operations, next, origin, parent, prev, uid;
    content = json['content'], content_operations = json['content_operations'], uid = json['uid'], prev = json['prev'], next = json['next'], origin = json['origin'], parent = json['parent'];
    return new this(null, content, content_operations, parent, uid, prev, next, origin);
  };
  ops.Delimiter = (function(_super) {
    __extends(Delimiter, _super);

    function Delimiter(prev_cl, next_cl, origin) {
      this.saveOperation('prev_cl', prev_cl);
      this.saveOperation('next_cl', next_cl);
      this.saveOperation('origin', prev_cl);
      Delimiter.__super__.constructor.call(this, null, {
        noOperation: true
      });
    }

    Delimiter.prototype.type = "Delimiter";

    Delimiter.prototype.applyDelete = function() {
      var o;
      Delimiter.__super__.applyDelete.call(this);
      o = this.prev_cl;
      while (o != null) {
        o.applyDelete();
        o = o.prev_cl;
      }
      return void 0;
    };

    Delimiter.prototype.cleanup = function() {
      return Delimiter.__super__.cleanup.call(this);
    };

    Delimiter.prototype.execute = function() {
      var _ref, _ref1;
      if (((_ref = this.unchecked) != null ? _ref['next_cl'] : void 0) != null) {
        return Delimiter.__super__.execute.apply(this, arguments);
      } else if ((_ref1 = this.unchecked) != null ? _ref1['prev_cl'] : void 0) {
        if (this.validateSavedOperations()) {
          if (this.prev_cl.next_cl != null) {
            throw new Error("Probably duplicated operations");
          }
          this.prev_cl.next_cl = this;
          return Delimiter.__super__.execute.apply(this, arguments);
        } else {
          return false;
        }
      } else if ((this.prev_cl != null) && (this.prev_cl.next_cl == null)) {
        delete this.prev_cl.unchecked.next_cl;
        this.prev_cl.next_cl = this;
        return Delimiter.__super__.execute.apply(this, arguments);
      } else if ((this.prev_cl != null) || (this.next_cl != null) || true) {
        return Delimiter.__super__.execute.apply(this, arguments);
      }
    };

    Delimiter.prototype._encode = function() {
      var _ref, _ref1;
      return {
        'type': this.type,
        'uid': this.getUid(),
        'prev': (_ref = this.prev_cl) != null ? _ref.getUid() : void 0,
        'next': (_ref1 = this.next_cl) != null ? _ref1.getUid() : void 0
      };
    };

    return Delimiter;

  })(ops.Operation);
  ops.Delimiter.parse = function(json) {
    var next, prev, uid;
    uid = json['uid'], prev = json['prev'], next = json['next'];
    return new this(uid, prev, next);
  };
  return {
    'operations': ops,
    'execution_listener': execution_listener
  };
};


},{}],74:[function(require,module,exports){
var basic_ops_uninitialized,
  __hasProp = {}.hasOwnProperty,
  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };

basic_ops_uninitialized = require("./Basic");

module.exports = function() {
  var basic_ops, ops;
  basic_ops = basic_ops_uninitialized();
  ops = basic_ops.operations;
  ops.MapManager = (function(_super) {
    __extends(MapManager, _super);

    function MapManager(custom_type, uid, content, content_operations) {
      this._map = {};
      MapManager.__super__.constructor.call(this, custom_type, uid, content, content_operations);
    }

    MapManager.prototype.type = "MapManager";

    MapManager.prototype.applyDelete = function() {
      var name, p, _ref;
      _ref = this._map;
      for (name in _ref) {
        p = _ref[name];
        p.applyDelete();
      }
      return MapManager.__super__.applyDelete.call(this);
    };

    MapManager.prototype.cleanup = function() {
      return MapManager.__super__.cleanup.call(this);
    };

    MapManager.prototype.map = function(f) {
      var n, v, _ref;
      _ref = this._map;
      for (n in _ref) {
        v = _ref[n];
        f(n, v);
      }
      return void 0;
    };

    MapManager.prototype.val = function(name, content) {
      var o, prop, rep, res, result, _ref;
      if (arguments.length > 1) {
        if ((content != null) && (content._getModel != null)) {
          rep = content._getModel(this.custom_types, this.operations);
        } else {
          rep = content;
        }
        this.retrieveSub(name).replace(rep);
        return this.getCustomType();
      } else if (name != null) {
        prop = this._map[name];
        if ((prop != null) && !prop.isContentDeleted()) {
          res = prop.val();
          if (res instanceof ops.Operation) {
            return res.getCustomType();
          } else {
            return res;
          }
        } else {
          return void 0;
        }
      } else {
        result = {};
        _ref = this._map;
        for (name in _ref) {
          o = _ref[name];
          if (!o.isContentDeleted()) {
            result[name] = o.val();
          }
        }
        return result;
      }
    };

    MapManager.prototype["delete"] = function(name) {
      var _ref;
      if ((_ref = this._map[name]) != null) {
        _ref.deleteContent();
      }
      return this;
    };

    MapManager.prototype.retrieveSub = function(property_name) {
      var event_properties, event_this, rm, rm_uid;
      if (this._map[property_name] == null) {
        event_properties = {
          name: property_name
        };
        event_this = this;
        rm_uid = {
          noOperation: true,
          sub: property_name,
          alt: this
        };
        rm = new ops.ReplaceManager(null, event_properties, event_this, rm_uid);
        this._map[property_name] = rm;
        rm.setParent(this, property_name);
        rm.execute();
      }
      return this._map[property_name];
    };

    return MapManager;

  })(ops.Operation);
  ops.MapManager.parse = function(json) {
    var content, content_operations, custom_type, uid;
    uid = json['uid'], custom_type = json['custom_type'], content = json['content'], content_operations = json['content_operations'];
    return new this(custom_type, uid, content, content_operations);
  };
  ops.ListManager = (function(_super) {
    __extends(ListManager, _super);

    function ListManager(custom_type, uid, content, content_operations) {
      this.beginning = new ops.Delimiter(void 0, void 0);
      this.end = new ops.Delimiter(this.beginning, void 0);
      this.beginning.next_cl = this.end;
      this.beginning.execute();
      this.end.execute();
      ListManager.__super__.constructor.call(this, custom_type, uid, content, content_operations);
    }

    ListManager.prototype.type = "ListManager";

    ListManager.prototype.applyDelete = function() {
      var o;
      o = this.beginning;
      while (o != null) {
        o.applyDelete();
        o = o.next_cl;
      }
      return ListManager.__super__.applyDelete.call(this);
    };

    ListManager.prototype.cleanup = function() {
      return ListManager.__super__.cleanup.call(this);
    };

    ListManager.prototype.toJson = function(transform_to_value) {
      var i, o, val, _i, _len, _results;
      if (transform_to_value == null) {
        transform_to_value = false;
      }
      val = this.val();
      _results = [];
      for (o = _i = 0, _len = val.length; _i < _len; o = ++_i) {
        i = val[o];
        if (o instanceof ops.Object) {
          _results.push(o.toJson(transform_to_value));
        } else if (o instanceof ops.ListManager) {
          _results.push(o.toJson(transform_to_value));
        } else if (transform_to_value && o instanceof ops.Operation) {
          _results.push(o.val());
        } else {
          _results.push(o);
        }
      }
      return _results;
    };

    ListManager.prototype.execute = function() {
      if (this.validateSavedOperations()) {
        this.beginning.setParent(this);
        this.end.setParent(this);
        return ListManager.__super__.execute.apply(this, arguments);
      } else {
        return false;
      }
    };

    ListManager.prototype.getLastOperation = function() {
      return this.end.prev_cl;
    };

    ListManager.prototype.getFirstOperation = function() {
      return this.beginning.next_cl;
    };

    ListManager.prototype.toArray = function() {
      var o, result;
      o = this.beginning.next_cl;
      result = [];
      while (o !== this.end) {
        if (!o.is_deleted) {
          result.push(o.val());
        }
        o = o.next_cl;
      }
      return result;
    };

    ListManager.prototype.map = function(f) {
      var o, result;
      o = this.beginning.next_cl;
      result = [];
      while (o !== this.end) {
        if (!o.is_deleted) {
          result.push(f(o));
        }
        o = o.next_cl;
      }
      return result;
    };

    ListManager.prototype.fold = function(init, f) {
      var o;
      o = this.beginning.next_cl;
      while (o !== this.end) {
        if (!o.is_deleted) {
          init = f(init, o);
        }
        o = o.next_cl;
      }
      return init;
    };

    ListManager.prototype.val = function(pos) {
      var o;
      if (pos != null) {
        o = this.getOperationByPosition(pos + 1);
        if (!(o instanceof ops.Delimiter)) {
          return o.val();
        } else {
          throw new Error("this position does not exist");
        }
      } else {
        return this.toArray();
      }
    };

    ListManager.prototype.ref = function(pos) {
      var o;
      if (pos != null) {
        o = this.getOperationByPosition(pos + 1);
        if (!(o instanceof ops.Delimiter)) {
          return o;
        } else {
          return null;
        }
      } else {
        throw new Error("you must specify a position parameter");
      }
    };

    ListManager.prototype.getOperationByPosition = function(position) {
      var o;
      o = this.beginning;
      while (true) {
        if (o instanceof ops.Delimiter && (o.prev_cl != null)) {
          o = o.prev_cl;
          while (o.isDeleted() && (o.prev_cl != null)) {
            o = o.prev_cl;
          }
          break;
        }
        if (position <= 0 && !o.isDeleted()) {
          break;
        }
        o = o.next_cl;
        if (!o.isDeleted()) {
          position -= 1;
        }
      }
      return o;
    };

    ListManager.prototype.push = function(content) {
      return this.insertAfter(this.end.prev_cl, [content]);
    };

    ListManager.prototype.insertAfter = function(left, contents) {
      var c, right, tmp, _i, _len;
      right = left.next_cl;
      while (right.isDeleted()) {
        right = right.next_cl;
      }
      left = right.prev_cl;
      if (contents instanceof ops.Operation) {
        (new ops.Insert(null, content, null, void 0, void 0, left, right)).execute();
      } else {
        for (_i = 0, _len = contents.length; _i < _len; _i++) {
          c = contents[_i];
          if ((c != null) && (c._name != null) && (c._getModel != null)) {
            c = c._getModel(this.custom_types, this.operations);
          }
          tmp = (new ops.Insert(null, c, null, void 0, void 0, left, right)).execute();
          left = tmp;
        }
      }
      return this;
    };

    ListManager.prototype.insert = function(position, contents) {
      var ith;
      ith = this.getOperationByPosition(position);
      return this.insertAfter(ith, contents);
    };

    ListManager.prototype["delete"] = function(position, length) {
      var d, delete_ops, i, o, _i;
      if (length == null) {
        length = 1;
      }
      o = this.getOperationByPosition(position + 1);
      delete_ops = [];
      for (i = _i = 0; 0 <= length ? _i < length : _i > length; i = 0 <= length ? ++_i : --_i) {
        if (o instanceof ops.Delimiter) {
          break;
        }
        d = (new ops.Delete(null, void 0, o)).execute();
        o = o.next_cl;
        while ((!(o instanceof ops.Delimiter)) && o.isDeleted()) {
          o = o.next_cl;
        }
        delete_ops.push(d._encode());
      }
      return this;
    };

    ListManager.prototype.callOperationSpecificInsertEvents = function(op) {
      var getContentType;
      getContentType = function(content) {
        if (content instanceof ops.Operation) {
          return content.getCustomType();
        } else {
          return content;
        }
      };
      return this.callEvent([
        {
          type: "insert",
          reference: op,
          position: op.getPosition(),
          object: this.getCustomType(),
          changedBy: op.uid.creator,
          value: getContentType(op.val())
        }
      ]);
    };

    ListManager.prototype.callOperationSpecificDeleteEvents = function(op, del_op) {
      return this.callEvent([
        {
          type: "delete",
          reference: op,
          position: op.getPosition(),
          object: this.getCustomType(),
          length: 1,
          changedBy: del_op.uid.creator,
          oldValue: op.val()
        }
      ]);
    };

    return ListManager;

  })(ops.Operation);
  ops.ListManager.parse = function(json) {
    var content, content_operations, custom_type, uid;
    uid = json['uid'], custom_type = json['custom_type'], content = json['content'], content_operations = json['content_operations'];
    return new this(custom_type, uid, content, content_operations);
  };
  ops.Composition = (function(_super) {
    __extends(Composition, _super);

    function Composition(custom_type, _composition_value, composition_value_operations, uid, tmp_composition_ref) {
      var n, o;
      this._composition_value = _composition_value;
      Composition.__super__.constructor.call(this, custom_type, uid);
      if (tmp_composition_ref != null) {
        this.tmp_composition_ref = tmp_composition_ref;
      } else {
        this.composition_ref = this.end.prev_cl;
      }
      if (composition_value_operations != null) {
        this.composition_value_operations = {};
        for (n in composition_value_operations) {
          o = composition_value_operations[n];
          this.saveOperation(n, o, '_composition_value');
        }
      }
    }

    Composition.prototype.type = "Composition";

    Composition.prototype.execute = function() {
      var composition_ref;
      if (this.validateSavedOperations()) {
        this.getCustomType()._setCompositionValue(this._composition_value);
        delete this._composition_value;
        if (this.tmp_composition_ref) {
          composition_ref = this.HB.getOperation(this.tmp_composition_ref);
          if (composition_ref != null) {
            delete this.tmp_composition_ref;
            this.composition_ref = composition_ref;
          }
        }
        return Composition.__super__.execute.apply(this, arguments);
      } else {
        return false;
      }
    };

    Composition.prototype.callOperationSpecificInsertEvents = function(op) {
      var o;
      if (this.tmp_composition_ref != null) {
        if (op.uid.creator === this.tmp_composition_ref.creator && op.uid.op_number === this.tmp_composition_ref.op_number) {
          this.composition_ref = op;
          delete this.tmp_composition_ref;
          op = op.next_cl;
          if (op === this.end) {
            return;
          }
        } else {
          return;
        }
      }
      o = this.end.prev_cl;
      while (o !== op) {
        this.getCustomType()._unapply(o.undo_delta);
        o = o.prev_cl;
      }
      while (o !== this.end) {
        o.undo_delta = this.getCustomType()._apply(o.val());
        o = o.next_cl;
      }
      this.composition_ref = this.end.prev_cl;
      return this.callEvent([
        {
          type: "update",
          changedBy: op.uid.creator,
          newValue: this.val()
        }
      ]);
    };

    Composition.prototype.callOperationSpecificDeleteEvents = function(op, del_op) {};

    Composition.prototype.applyDelta = function(delta, operations) {
      (new ops.Insert(null, delta, operations, this, null, this.end.prev_cl, this.end)).execute();
      return void 0;
    };

    Composition.prototype._encode = function(json) {
      var custom, n, o, _ref;
      if (json == null) {
        json = {};
      }
      custom = this.getCustomType()._getCompositionValue();
      json.composition_value = custom.composition_value;
      if (custom.composition_value_operations != null) {
        json.composition_value_operations = {};
        _ref = custom.composition_value_operations;
        for (n in _ref) {
          o = _ref[n];
          json.composition_value_operations[n] = o.getUid();
        }
      }
      if (this.composition_ref != null) {
        json.composition_ref = this.composition_ref.getUid();
      } else {
        json.composition_ref = this.tmp_composition_ref;
      }
      return Composition.__super__._encode.call(this, json);
    };

    return Composition;

  })(ops.ListManager);
  ops.Composition.parse = function(json) {
    var composition_ref, composition_value, composition_value_operations, custom_type, uid;
    uid = json['uid'], custom_type = json['custom_type'], composition_value = json['composition_value'], composition_value_operations = json['composition_value_operations'], composition_ref = json['composition_ref'];
    return new this(custom_type, composition_value, composition_value_operations, uid, composition_ref);
  };
  ops.ReplaceManager = (function(_super) {
    __extends(ReplaceManager, _super);

    function ReplaceManager(custom_type, event_properties, event_this, uid) {
      this.event_properties = event_properties;
      this.event_this = event_this;
      if (this.event_properties['object'] == null) {
        this.event_properties['object'] = this.event_this.getCustomType();
      }
      ReplaceManager.__super__.constructor.call(this, custom_type, uid);
    }

    ReplaceManager.prototype.type = "ReplaceManager";

    ReplaceManager.prototype.callEventDecorator = function(events) {
      var event, name, prop, _i, _len, _ref;
      if (!this.isDeleted()) {
        for (_i = 0, _len = events.length; _i < _len; _i++) {
          event = events[_i];
          _ref = this.event_properties;
          for (name in _ref) {
            prop = _ref[name];
            event[name] = prop;
          }
        }
        this.event_this.callEvent(events);
      }
      return void 0;
    };

    ReplaceManager.prototype.callOperationSpecificInsertEvents = function(op) {
      var old_value;
      if (op.next_cl.type === "Delimiter" && op.prev_cl.type !== "Delimiter") {
        if (!op.is_deleted) {
          old_value = op.prev_cl.val();
          this.callEventDecorator([
            {
              type: "update",
              changedBy: op.uid.creator,
              oldValue: old_value
            }
          ]);
        }
        op.prev_cl.applyDelete();
      } else if (op.next_cl.type !== "Delimiter") {
        op.applyDelete();
      } else {
        this.callEventDecorator([
          {
            type: "add",
            changedBy: op.uid.creator
          }
        ]);
      }
      return void 0;
    };

    ReplaceManager.prototype.callOperationSpecificDeleteEvents = function(op, del_op) {
      if (op.next_cl.type === "Delimiter") {
        return this.callEventDecorator([
          {
            type: "delete",
            changedBy: del_op.uid.creator,
            oldValue: op.val()
          }
        ]);
      }
    };

    ReplaceManager.prototype.replace = function(content, replaceable_uid) {
      var o, relp;
      o = this.getLastOperation();
      relp = (new ops.Insert(null, content, null, this, replaceable_uid, o, o.next_cl)).execute();
      return void 0;
    };

    ReplaceManager.prototype.isContentDeleted = function() {
      return this.getLastOperation().isDeleted();
    };

    ReplaceManager.prototype.deleteContent = function() {
      var last_op;
      last_op = this.getLastOperation();
      if ((!last_op.isDeleted()) && last_op.type !== "Delimiter") {
        (new ops.Delete(null, void 0, this.getLastOperation().uid)).execute();
      }
      return void 0;
    };

    ReplaceManager.prototype.val = function() {
      var o;
      o = this.getLastOperation();
      return typeof o.val === "function" ? o.val() : void 0;
    };

    return ReplaceManager;

  })(ops.ListManager);
  return basic_ops;
};


},{"./Basic":73}],75:[function(require,module,exports){
var Engine, HistoryBuffer, adaptConnector, createY, structured_ops_uninitialized;

structured_ops_uninitialized = require("./Operations/Structured");

HistoryBuffer = require("./HistoryBuffer");

Engine = require("./Engine");

adaptConnector = require("./ConnectorAdapter");

createY = function(connector) {
  var HB, ct, engine, model, ops, ops_manager, user_id;
  if (connector.user_id != null) {
    user_id = connector.user_id;
  } else {
    user_id = "_temp";
    connector.when_received_state_vector_listeners = [
      function(state_vector) {
        return HB.setUserId(this.user_id, state_vector);
      }
    ];
  }
  HB = new HistoryBuffer(user_id);
  ops_manager = structured_ops_uninitialized(HB, this.constructor);
  ops = ops_manager.operations;
  engine = new Engine(HB, ops);
  adaptConnector(connector, engine, HB, ops_manager.execution_listener);
  ops.Operation.prototype.HB = HB;
  ops.Operation.prototype.operations = ops;
  ops.Operation.prototype.engine = engine;
  ops.Operation.prototype.connector = connector;
  ops.Operation.prototype.custom_types = this.constructor;
  ct = new createY.Object();
  model = new ops.MapManager(ct, HB.getReservedUniqueIdentifier()).execute();
  ct._setModel(model);
  return ct;
};

module.exports = createY;

if (typeof window !== "undefined" && window !== null) {
  window.Y = createY;
}

createY.Object = require("./ObjectType");


},{"./ConnectorAdapter":68,"./Engine":70,"./HistoryBuffer":71,"./ObjectType":72,"./Operations/Structured":74}],76:[function(require,module,exports){
module.exports=require(3)
},{"./lib/chai":77}],77:[function(require,module,exports){
module.exports=require(4)
},{"./chai/assertion":78,"./chai/config":79,"./chai/core/assertions":80,"./chai/interface/assert":81,"./chai/interface/expect":82,"./chai/interface/should":83,"./chai/utils":96,"assertion-error":105}],78:[function(require,module,exports){
module.exports=require(5)
},{"./config":79}],79:[function(require,module,exports){
module.exports=require(6)
},{}],80:[function(require,module,exports){
module.exports=require(7)
},{}],81:[function(require,module,exports){
module.exports=require(8)
},{}],82:[function(require,module,exports){
module.exports=require(9)
},{}],83:[function(require,module,exports){
module.exports=require(10)
},{}],84:[function(require,module,exports){
module.exports=require(11)
},{"../config":79,"./flag":87,"./transferFlags":103}],85:[function(require,module,exports){
module.exports=require(12)
},{"../config":79,"./flag":87}],86:[function(require,module,exports){
module.exports=require(13)
},{}],87:[function(require,module,exports){
module.exports=require(14)
},{}],88:[function(require,module,exports){
module.exports=require(15)
},{}],89:[function(require,module,exports){
module.exports=require(16)
},{}],90:[function(require,module,exports){
module.exports=require(17)
},{"./flag":87,"./getActual":88,"./inspect":97,"./objDisplay":98}],91:[function(require,module,exports){
module.exports=require(18)
},{}],92:[function(require,module,exports){
module.exports=require(19)
},{"./hasProperty":95}],93:[function(require,module,exports){
module.exports=require(20)
},{"./getPathInfo":92}],94:[function(require,module,exports){
module.exports=require(21)
},{}],95:[function(require,module,exports){
module.exports=require(22)
},{"./type":104}],96:[function(require,module,exports){
module.exports=require(23)
},{"./addChainableMethod":84,"./addMethod":85,"./addProperty":86,"./flag":87,"./getActual":88,"./getMessage":90,"./getName":91,"./getPathInfo":92,"./getPathValue":93,"./hasProperty":95,"./inspect":97,"./objDisplay":98,"./overwriteChainableMethod":99,"./overwriteMethod":100,"./overwriteProperty":101,"./test":102,"./transferFlags":103,"./type":104,"deep-eql":106}],97:[function(require,module,exports){
module.exports=require(24)
},{"./getEnumerableProperties":89,"./getName":91,"./getProperties":94}],98:[function(require,module,exports){
module.exports=require(25)
},{"../config":79,"./inspect":97}],99:[function(require,module,exports){
module.exports=require(26)
},{}],100:[function(require,module,exports){
module.exports=require(27)
},{}],101:[function(require,module,exports){
module.exports=require(28)
},{}],102:[function(require,module,exports){
module.exports=require(29)
},{"./flag":87}],103:[function(require,module,exports){
module.exports=require(30)
},{}],104:[function(require,module,exports){
module.exports=require(31)
},{}],105:[function(require,module,exports){
module.exports=require(32)
},{}],106:[function(require,module,exports){
module.exports=require(33)
},{"./lib/eql":107}],107:[function(require,module,exports){
module.exports=require(34)
},{"buffer":110,"type-detect":108}],108:[function(require,module,exports){
module.exports=require(35)
},{"./lib/type":109}],109:[function(require,module,exports){
module.exports=require(36)
},{}],110:[function(require,module,exports){
/*!
 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
 * @license  MIT
 */

var base64 = require('base64-js')
var ieee754 = require('ieee754')

exports.Buffer = Buffer
exports.SlowBuffer = Buffer
exports.INSPECT_MAX_BYTES = 50
Buffer.poolSize = 8192

/**
 * If `Buffer._useTypedArrays`:
 *   === true    Use Uint8Array implementation (fastest)
 *   === false   Use Object implementation (compatible down to IE6)
 */
Buffer._useTypedArrays = (function () {
  // Detect if browser supports Typed Arrays. Supported browsers are IE 10+, Firefox 4+,
  // Chrome 7+, Safari 5.1+, Opera 11.6+, iOS 4.2+. If the browser does not support adding
  // properties to `Uint8Array` instances, then that's the same as no `Uint8Array` support
  // because we need to be able to add all the node Buffer API methods. This is an issue
  // in Firefox 4-29. Now fixed: https://bugzilla.mozilla.org/show_bug.cgi?id=695438
  try {
    var buf = new ArrayBuffer(0)
    var arr = new Uint8Array(buf)
    arr.foo = function () { return 42 }
    return 42 === arr.foo() &&
        typeof arr.subarray === 'function' // Chrome 9-10 lack `subarray`
  } catch (e) {
    return false
  }
})()

/**
 * Class: Buffer
 * =============
 *
 * The Buffer constructor returns instances of `Uint8Array` that are augmented
 * with function properties for all the node `Buffer` API functions. We use
 * `Uint8Array` so that square bracket notation works as expected -- it returns
 * a single octet.
 *
 * By augmenting the instances, we can avoid modifying the `Uint8Array`
 * prototype.
 */
function Buffer (subject, encoding, noZero) {
  if (!(this instanceof Buffer))
    return new Buffer(subject, encoding, noZero)

  var type = typeof subject

  // Workaround: node's base64 implementation allows for non-padded strings
  // while base64-js does not.
  if (encoding === 'base64' && type === 'string') {
    subject = stringtrim(subject)
    while (subject.length % 4 !== 0) {
      subject = subject + '='
    }
  }

  // Find the length
  var length
  if (type === 'number')
    length = coerce(subject)
  else if (type === 'string')
    length = Buffer.byteLength(subject, encoding)
  else if (type === 'object')
    length = coerce(subject.length) // assume that object is array-like
  else
    throw new Error('First argument needs to be a number, array or string.')

  var buf
  if (Buffer._useTypedArrays) {
    // Preferred: Return an augmented `Uint8Array` instance for best performance
    buf = Buffer._augment(new Uint8Array(length))
  } else {
    // Fallback: Return THIS instance of Buffer (created by `new`)
    buf = this
    buf.length = length
    buf._isBuffer = true
  }

  var i
  if (Buffer._useTypedArrays && typeof subject.byteLength === 'number') {
    // Speed optimization -- use set if we're copying from a typed array
    buf._set(subject)
  } else if (isArrayish(subject)) {
    // Treat array-ish objects as a byte array
    for (i = 0; i < length; i++) {
      if (Buffer.isBuffer(subject))
        buf[i] = subject.readUInt8(i)
      else
        buf[i] = subject[i]
    }
  } else if (type === 'string') {
    buf.write(subject, 0, encoding)
  } else if (type === 'number' && !Buffer._useTypedArrays && !noZero) {
    for (i = 0; i < length; i++) {
      buf[i] = 0
    }
  }

  return buf
}

// STATIC METHODS
// ==============

Buffer.isEncoding = function (encoding) {
  switch (String(encoding).toLowerCase()) {
    case 'hex':
    case 'utf8':
    case 'utf-8':
    case 'ascii':
    case 'binary':
    case 'base64':
    case 'raw':
    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
      return true
    default:
      return false
  }
}

Buffer.isBuffer = function (b) {
  return !!(b !== null && b !== undefined && b._isBuffer)
}

Buffer.byteLength = function (str, encoding) {
  var ret
  str = str + ''
  switch (encoding || 'utf8') {
    case 'hex':
      ret = str.length / 2
      break
    case 'utf8':
    case 'utf-8':
      ret = utf8ToBytes(str).length
      break
    case 'ascii':
    case 'binary':
    case 'raw':
      ret = str.length
      break
    case 'base64':
      ret = base64ToBytes(str).length
      break
    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
      ret = str.length * 2
      break
    default:
      throw new Error('Unknown encoding')
  }
  return ret
}

Buffer.concat = function (list, totalLength) {
  assert(isArray(list), 'Usage: Buffer.concat(list, [totalLength])\n' +
      'list should be an Array.')

  if (list.length === 0) {
    return new Buffer(0)
  } else if (list.length === 1) {
    return list[0]
  }

  var i
  if (typeof totalLength !== 'number') {
    totalLength = 0
    for (i = 0; i < list.length; i++) {
      totalLength += list[i].length
    }
  }

  var buf = new Buffer(totalLength)
  var pos = 0
  for (i = 0; i < list.length; i++) {
    var item = list[i]
    item.copy(buf, pos)
    pos += item.length
  }
  return buf
}

// BUFFER INSTANCE METHODS
// =======================

function _hexWrite (buf, string, offset, length) {
  offset = Number(offset) || 0
  var remaining = buf.length - offset
  if (!length) {
    length = remaining
  } else {
    length = Number(length)
    if (length > remaining) {
      length = remaining
    }
  }

  // must be an even number of digits
  var strLen = string.length
  assert(strLen % 2 === 0, 'Invalid hex string')

  if (length > strLen / 2) {
    length = strLen / 2
  }
  for (var i = 0; i < length; i++) {
    var byte = parseInt(string.substr(i * 2, 2), 16)
    assert(!isNaN(byte), 'Invalid hex string')
    buf[offset + i] = byte
  }
  Buffer._charsWritten = i * 2
  return i
}

function _utf8Write (buf, string, offset, length) {
  var charsWritten = Buffer._charsWritten =
    blitBuffer(utf8ToBytes(string), buf, offset, length)
  return charsWritten
}

function _asciiWrite (buf, string, offset, length) {
  var charsWritten = Buffer._charsWritten =
    blitBuffer(asciiToBytes(string), buf, offset, length)
  return charsWritten
}

function _binaryWrite (buf, string, offset, length) {
  return _asciiWrite(buf, string, offset, length)
}

function _base64Write (buf, string, offset, length) {
  var charsWritten = Buffer._charsWritten =
    blitBuffer(base64ToBytes(string), buf, offset, length)
  return charsWritten
}

function _utf16leWrite (buf, string, offset, length) {
  var charsWritten = Buffer._charsWritten =
    blitBuffer(utf16leToBytes(string), buf, offset, length)
  return charsWritten
}

Buffer.prototype.write = function (string, offset, length, encoding) {
  // Support both (string, offset, length, encoding)
  // and the legacy (string, encoding, offset, length)
  if (isFinite(offset)) {
    if (!isFinite(length)) {
      encoding = length
      length = undefined
    }
  } else {  // legacy
    var swap = encoding
    encoding = offset
    offset = length
    length = swap
  }

  offset = Number(offset) || 0
  var remaining = this.length - offset
  if (!length) {
    length = remaining
  } else {
    length = Number(length)
    if (length > remaining) {
      length = remaining
    }
  }
  encoding = String(encoding || 'utf8').toLowerCase()

  var ret
  switch (encoding) {
    case 'hex':
      ret = _hexWrite(this, string, offset, length)
      break
    case 'utf8':
    case 'utf-8':
      ret = _utf8Write(this, string, offset, length)
      break
    case 'ascii':
      ret = _asciiWrite(this, string, offset, length)
      break
    case 'binary':
      ret = _binaryWrite(this, string, offset, length)
      break
    case 'base64':
      ret = _base64Write(this, string, offset, length)
      break
    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
      ret = _utf16leWrite(this, string, offset, length)
      break
    default:
      throw new Error('Unknown encoding')
  }
  return ret
}

Buffer.prototype.toString = function (encoding, start, end) {
  var self = this

  encoding = String(encoding || 'utf8').toLowerCase()
  start = Number(start) || 0
  end = (end !== undefined)
    ? Number(end)
    : end = self.length

  // Fastpath empty strings
  if (end === start)
    return ''

  var ret
  switch (encoding) {
    case 'hex':
      ret = _hexSlice(self, start, end)
      break
    case 'utf8':
    case 'utf-8':
      ret = _utf8Slice(self, start, end)
      break
    case 'ascii':
      ret = _asciiSlice(self, start, end)
      break
    case 'binary':
      ret = _binarySlice(self, start, end)
      break
    case 'base64':
      ret = _base64Slice(self, start, end)
      break
    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
      ret = _utf16leSlice(self, start, end)
      break
    default:
      throw new Error('Unknown encoding')
  }
  return ret
}

Buffer.prototype.toJSON = function () {
  return {
    type: 'Buffer',
    data: Array.prototype.slice.call(this._arr || this, 0)
  }
}

// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
Buffer.prototype.copy = function (target, target_start, start, end) {
  var source = this

  if (!start) start = 0
  if (!end && end !== 0) end = this.length
  if (!target_start) target_start = 0

  // Copy 0 bytes; we're done
  if (end === start) return
  if (target.length === 0 || source.length === 0) return

  // Fatal error conditions
  assert(end >= start, 'sourceEnd < sourceStart')
  assert(target_start >= 0 && target_start < target.length,
      'targetStart out of bounds')
  assert(start >= 0 && start < source.length, 'sourceStart out of bounds')
  assert(end >= 0 && end <= source.length, 'sourceEnd out of bounds')

  // Are we oob?
  if (end > this.length)
    end = this.length
  if (target.length - target_start < end - start)
    end = target.length - target_start + start

  var len = end - start

  if (len < 100 || !Buffer._useTypedArrays) {
    for (var i = 0; i < len; i++)
      target[i + target_start] = this[i + start]
  } else {
    target._set(this.subarray(start, start + len), target_start)
  }
}

function _base64Slice (buf, start, end) {
  if (start === 0 && end === buf.length) {
    return base64.fromByteArray(buf)
  } else {
    return base64.fromByteArray(buf.slice(start, end))
  }
}

function _utf8Slice (buf, start, end) {
  var res = ''
  var tmp = ''
  end = Math.min(buf.length, end)

  for (var i = start; i < end; i++) {
    if (buf[i] <= 0x7F) {
      res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])
      tmp = ''
    } else {
      tmp += '%' + buf[i].toString(16)
    }
  }

  return res + decodeUtf8Char(tmp)
}

function _asciiSlice (buf, start, end) {
  var ret = ''
  end = Math.min(buf.length, end)

  for (var i = start; i < end; i++)
    ret += String.fromCharCode(buf[i])
  return ret
}

function _binarySlice (buf, start, end) {
  return _asciiSlice(buf, start, end)
}

function _hexSlice (buf, start, end) {
  var len = buf.length

  if (!start || start < 0) start = 0
  if (!end || end < 0 || end > len) end = len

  var out = ''
  for (var i = start; i < end; i++) {
    out += toHex(buf[i])
  }
  return out
}

function _utf16leSlice (buf, start, end) {
  var bytes = buf.slice(start, end)
  var res = ''
  for (var i = 0; i < bytes.length; i += 2) {
    res += String.fromCharCode(bytes[i] + bytes[i+1] * 256)
  }
  return res
}

Buffer.prototype.slice = function (start, end) {
  var len = this.length
  start = clamp(start, len, 0)
  end = clamp(end, len, len)

  if (Buffer._useTypedArrays) {
    return Buffer._augment(this.subarray(start, end))
  } else {
    var sliceLen = end - start
    var newBuf = new Buffer(sliceLen, undefined, true)
    for (var i = 0; i < sliceLen; i++) {
      newBuf[i] = this[i + start]
    }
    return newBuf
  }
}

// `get` will be removed in Node 0.13+
Buffer.prototype.get = function (offset) {
  console.log('.get() is deprecated. Access using array indexes instead.')
  return this.readUInt8(offset)
}

// `set` will be removed in Node 0.13+
Buffer.prototype.set = function (v, offset) {
  console.log('.set() is deprecated. Access using array indexes instead.')
  return this.writeUInt8(v, offset)
}

Buffer.prototype.readUInt8 = function (offset, noAssert) {
  if (!noAssert) {
    assert(offset !== undefined && offset !== null, 'missing offset')
    assert(offset < this.length, 'Trying to read beyond buffer length')
  }

  if (offset >= this.length)
    return

  return this[offset]
}

function _readUInt16 (buf, offset, littleEndian, noAssert) {
  if (!noAssert) {
    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
    assert(offset !== undefined && offset !== null, 'missing offset')
    assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
  }

  var len = buf.length
  if (offset >= len)
    return

  var val
  if (littleEndian) {
    val = buf[offset]
    if (offset + 1 < len)
      val |= buf[offset + 1] << 8
  } else {
    val = buf[offset] << 8
    if (offset + 1 < len)
      val |= buf[offset + 1]
  }
  return val
}

Buffer.prototype.readUInt16LE = function (offset, noAssert) {
  return _readUInt16(this, offset, true, noAssert)
}

Buffer.prototype.readUInt16BE = function (offset, noAssert) {
  return _readUInt16(this, offset, false, noAssert)
}

function _readUInt32 (buf, offset, littleEndian, noAssert) {
  if (!noAssert) {
    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
    assert(offset !== undefined && offset !== null, 'missing offset')
    assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
  }

  var len = buf.length
  if (offset >= len)
    return

  var val
  if (littleEndian) {
    if (offset + 2 < len)
      val = buf[offset + 2] << 16
    if (offset + 1 < len)
      val |= buf[offset + 1] << 8
    val |= buf[offset]
    if (offset + 3 < len)
      val = val + (buf[offset + 3] << 24 >>> 0)
  } else {
    if (offset + 1 < len)
      val = buf[offset + 1] << 16
    if (offset + 2 < len)
      val |= buf[offset + 2] << 8
    if (offset + 3 < len)
      val |= buf[offset + 3]
    val = val + (buf[offset] << 24 >>> 0)
  }
  return val
}

Buffer.prototype.readUInt32LE = function (offset, noAssert) {
  return _readUInt32(this, offset, true, noAssert)
}

Buffer.prototype.readUInt32BE = function (offset, noAssert) {
  return _readUInt32(this, offset, false, noAssert)
}

Buffer.prototype.readInt8 = function (offset, noAssert) {
  if (!noAssert) {
    assert(offset !== undefined && offset !== null,
        'missing offset')
    assert(offset < this.length, 'Trying to read beyond buffer length')
  }

  if (offset >= this.length)
    return

  var neg = this[offset] & 0x80
  if (neg)
    return (0xff - this[offset] + 1) * -1
  else
    return this[offset]
}

function _readInt16 (buf, offset, littleEndian, noAssert) {
  if (!noAssert) {
    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
    assert(offset !== undefined && offset !== null, 'missing offset')
    assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')
  }

  var len = buf.length
  if (offset >= len)
    return

  var val = _readUInt16(buf, offset, littleEndian, true)
  var neg = val & 0x8000
  if (neg)
    return (0xffff - val + 1) * -1
  else
    return val
}

Buffer.prototype.readInt16LE = function (offset, noAssert) {
  return _readInt16(this, offset, true, noAssert)
}

Buffer.prototype.readInt16BE = function (offset, noAssert) {
  return _readInt16(this, offset, false, noAssert)
}

function _readInt32 (buf, offset, littleEndian, noAssert) {
  if (!noAssert) {
    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
    assert(offset !== undefined && offset !== null, 'missing offset')
    assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
  }

  var len = buf.length
  if (offset >= len)
    return

  var val = _readUInt32(buf, offset, littleEndian, true)
  var neg = val & 0x80000000
  if (neg)
    return (0xffffffff - val + 1) * -1
  else
    return val
}

Buffer.prototype.readInt32LE = function (offset, noAssert) {
  return _readInt32(this, offset, true, noAssert)
}

Buffer.prototype.readInt32BE = function (offset, noAssert) {
  return _readInt32(this, offset, false, noAssert)
}

function _readFloat (buf, offset, littleEndian, noAssert) {
  if (!noAssert) {
    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
    assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')
  }

  return ieee754.read(buf, offset, littleEndian, 23, 4)
}

Buffer.prototype.readFloatLE = function (offset, noAssert) {
  return _readFloat(this, offset, true, noAssert)
}

Buffer.prototype.readFloatBE = function (offset, noAssert) {
  return _readFloat(this, offset, false, noAssert)
}

function _readDouble (buf, offset, littleEndian, noAssert) {
  if (!noAssert) {
    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
    assert(offset + 7 < buf.length, 'Trying to read beyond buffer length')
  }

  return ieee754.read(buf, offset, littleEndian, 52, 8)
}

Buffer.prototype.readDoubleLE = function (offset, noAssert) {
  return _readDouble(this, offset, true, noAssert)
}

Buffer.prototype.readDoubleBE = function (offset, noAssert) {
  return _readDouble(this, offset, false, noAssert)
}

Buffer.prototype.writeUInt8 = function (value, offset, noAssert) {
  if (!noAssert) {
    assert(value !== undefined && value !== null, 'missing value')
    assert(offset !== undefined && offset !== null, 'missing offset')
    assert(offset < this.length, 'trying to write beyond buffer length')
    verifuint(value, 0xff)
  }

  if (offset >= this.length) return

  this[offset] = value
}

function _writeUInt16 (buf, value, offset, littleEndian, noAssert) {
  if (!noAssert) {
    assert(value !== undefined && value !== null, 'missing value')
    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
    assert(offset !== undefined && offset !== null, 'missing offset')
    assert(offset + 1 < buf.length, 'trying to write beyond buffer length')
    verifuint(value, 0xffff)
  }

  var len = buf.length
  if (offset >= len)
    return

  for (var i = 0, j = Math.min(len - offset, 2); i < j; i++) {
    buf[offset + i] =
        (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
            (littleEndian ? i : 1 - i) * 8
  }
}

Buffer.prototype.writeUInt16LE = function (value, offset, noAssert) {
  _writeUInt16(this, value, offset, true, noAssert)
}

Buffer.prototype.writeUInt16BE = function (value, offset, noAssert) {
  _writeUInt16(this, value, offset, false, noAssert)
}

function _writeUInt32 (buf, value, offset, littleEndian, noAssert) {
  if (!noAssert) {
    assert(value !== undefined && value !== null, 'missing value')
    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
    assert(offset !== undefined && offset !== null, 'missing offset')
    assert(offset + 3 < buf.length, 'trying to write beyond buffer length')
    verifuint(value, 0xffffffff)
  }

  var len = buf.length
  if (offset >= len)
    return

  for (var i = 0, j = Math.min(len - offset, 4); i < j; i++) {
    buf[offset + i] =
        (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
  }
}

Buffer.prototype.writeUInt32LE = function (value, offset, noAssert) {
  _writeUInt32(this, value, offset, true, noAssert)
}

Buffer.prototype.writeUInt32BE = function (value, offset, noAssert) {
  _writeUInt32(this, value, offset, false, noAssert)
}

Buffer.prototype.writeInt8 = function (value, offset, noAssert) {
  if (!noAssert) {
    assert(value !== undefined && value !== null, 'missing value')
    assert(offset !== undefined && offset !== null, 'missing offset')
    assert(offset < this.length, 'Trying to write beyond buffer length')
    verifsint(value, 0x7f, -0x80)
  }

  if (offset >= this.length)
    return

  if (value >= 0)
    this.writeUInt8(value, offset, noAssert)
  else
    this.writeUInt8(0xff + value + 1, offset, noAssert)
}

function _writeInt16 (buf, value, offset, littleEndian, noAssert) {
  if (!noAssert) {
    assert(value !== undefined && value !== null, 'missing value')
    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
    assert(offset !== undefined && offset !== null, 'missing offset')
    assert(offset + 1 < buf.length, 'Trying to write beyond buffer length')
    verifsint(value, 0x7fff, -0x8000)
  }

  var len = buf.length
  if (offset >= len)
    return

  if (value >= 0)
    _writeUInt16(buf, value, offset, littleEndian, noAssert)
  else
    _writeUInt16(buf, 0xffff + value + 1, offset, littleEndian, noAssert)
}

Buffer.prototype.writeInt16LE = function (value, offset, noAssert) {
  _writeInt16(this, value, offset, true, noAssert)
}

Buffer.prototype.writeInt16BE = function (value, offset, noAssert) {
  _writeInt16(this, value, offset, false, noAssert)
}

function _writeInt32 (buf, value, offset, littleEndian, noAssert) {
  if (!noAssert) {
    assert(value !== undefined && value !== null, 'missing value')
    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
    assert(offset !== undefined && offset !== null, 'missing offset')
    assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
    verifsint(value, 0x7fffffff, -0x80000000)
  }

  var len = buf.length
  if (offset >= len)
    return

  if (value >= 0)
    _writeUInt32(buf, value, offset, littleEndian, noAssert)
  else
    _writeUInt32(buf, 0xffffffff + value + 1, offset, littleEndian, noAssert)
}

Buffer.prototype.writeInt32LE = function (value, offset, noAssert) {
  _writeInt32(this, value, offset, true, noAssert)
}

Buffer.prototype.writeInt32BE = function (value, offset, noAssert) {
  _writeInt32(this, value, offset, false, noAssert)
}

function _writeFloat (buf, value, offset, littleEndian, noAssert) {
  if (!noAssert) {
    assert(value !== undefined && value !== null, 'missing value')
    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
    assert(offset !== undefined && offset !== null, 'missing offset')
    assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')
    verifIEEE754(value, 3.4028234663852886e+38, -3.4028234663852886e+38)
  }

  var len = buf.length
  if (offset >= len)
    return

  ieee754.write(buf, value, offset, littleEndian, 23, 4)
}

Buffer.prototype.writeFloatLE = function (value, offset, noAssert) {
  _writeFloat(this, value, offset, true, noAssert)
}

Buffer.prototype.writeFloatBE = function (value, offset, noAssert) {
  _writeFloat(this, value, offset, false, noAssert)
}

function _writeDouble (buf, value, offset, littleEndian, noAssert) {
  if (!noAssert) {
    assert(value !== undefined && value !== null, 'missing value')
    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')
    assert(offset !== undefined && offset !== null, 'missing offset')
    assert(offset + 7 < buf.length,
        'Trying to write beyond buffer length')
    verifIEEE754(value, 1.7976931348623157E+308, -1.7976931348623157E+308)
  }

  var len = buf.length
  if (offset >= len)
    return

  ieee754.write(buf, value, offset, littleEndian, 52, 8)
}

Buffer.prototype.writeDoubleLE = function (value, offset, noAssert) {
  _writeDouble(this, value, offset, true, noAssert)
}

Buffer.prototype.writeDoubleBE = function (value, offset, noAssert) {
  _writeDouble(this, value, offset, false, noAssert)
}

// fill(value, start=0, end=buffer.length)
Buffer.prototype.fill = function (value, start, end) {
  if (!value) value = 0
  if (!start) start = 0
  if (!end) end = this.length

  if (typeof value === 'string') {
    value = value.charCodeAt(0)
  }

  assert(typeof value === 'number' && !isNaN(value), 'value is not a number')
  assert(end >= start, 'end < start')

  // Fill 0 bytes; we're done
  if (end === start) return
  if (this.length === 0) return

  assert(start >= 0 && start < this.length, 'start out of bounds')
  assert(end >= 0 && end <= this.length, 'end out of bounds')

  for (var i = start; i < end; i++) {
    this[i] = value
  }
}

Buffer.prototype.inspect = function () {
  var out = []
  var len = this.length
  for (var i = 0; i < len; i++) {
    out[i] = toHex(this[i])
    if (i === exports.INSPECT_MAX_BYTES) {
      out[i + 1] = '...'
      break
    }
  }
  return '<Buffer ' + out.join(' ') + '>'
}

/**
 * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
 * Added in Node 0.12. Only available in browsers that support ArrayBuffer.
 */
Buffer.prototype.toArrayBuffer = function () {
  if (typeof Uint8Array !== 'undefined') {
    if (Buffer._useTypedArrays) {
      return (new Buffer(this)).buffer
    } else {
      var buf = new Uint8Array(this.length)
      for (var i = 0, len = buf.length; i < len; i += 1)
        buf[i] = this[i]
      return buf.buffer
    }
  } else {
    throw new Error('Buffer.toArrayBuffer not supported in this browser')
  }
}

// HELPER FUNCTIONS
// ================

function stringtrim (str) {
  if (str.trim) return str.trim()
  return str.replace(/^\s+|\s+$/g, '')
}

var BP = Buffer.prototype

/**
 * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
 */
Buffer._augment = function (arr) {
  arr._isBuffer = true

  // save reference to original Uint8Array get/set methods before overwriting
  arr._get = arr.get
  arr._set = arr.set

  // deprecated, will be removed in node 0.13+
  arr.get = BP.get
  arr.set = BP.set

  arr.write = BP.write
  arr.toString = BP.toString
  arr.toLocaleString = BP.toString
  arr.toJSON = BP.toJSON
  arr.copy = BP.copy
  arr.slice = BP.slice
  arr.readUInt8 = BP.readUInt8
  arr.readUInt16LE = BP.readUInt16LE
  arr.readUInt16BE = BP.readUInt16BE
  arr.readUInt32LE = BP.readUInt32LE
  arr.readUInt32BE = BP.readUInt32BE
  arr.readInt8 = BP.readInt8
  arr.readInt16LE = BP.readInt16LE
  arr.readInt16BE = BP.readInt16BE
  arr.readInt32LE = BP.readInt32LE
  arr.readInt32BE = BP.readInt32BE
  arr.readFloatLE = BP.readFloatLE
  arr.readFloatBE = BP.readFloatBE
  arr.readDoubleLE = BP.readDoubleLE
  arr.readDoubleBE = BP.readDoubleBE
  arr.writeUInt8 = BP.writeUInt8
  arr.writeUInt16LE = BP.writeUInt16LE
  arr.writeUInt16BE = BP.writeUInt16BE
  arr.writeUInt32LE = BP.writeUInt32LE
  arr.writeUInt32BE = BP.writeUInt32BE
  arr.writeInt8 = BP.writeInt8
  arr.writeInt16LE = BP.writeInt16LE
  arr.writeInt16BE = BP.writeInt16BE
  arr.writeInt32LE = BP.writeInt32LE
  arr.writeInt32BE = BP.writeInt32BE
  arr.writeFloatLE = BP.writeFloatLE
  arr.writeFloatBE = BP.writeFloatBE
  arr.writeDoubleLE = BP.writeDoubleLE
  arr.writeDoubleBE = BP.writeDoubleBE
  arr.fill = BP.fill
  arr.inspect = BP.inspect
  arr.toArrayBuffer = BP.toArrayBuffer

  return arr
}

// slice(start, end)
function clamp (index, len, defaultValue) {
  if (typeof index !== 'number') return defaultValue
  index = ~~index;  // Coerce to integer.
  if (index >= len) return len
  if (index >= 0) return index
  index += len
  if (index >= 0) return index
  return 0
}

function coerce (length) {
  // Coerce length to a number (possibly NaN), round up
  // in case it's fractional (e.g. 123.456) then do a
  // double negate to coerce a NaN to 0. Easy, right?
  length = ~~Math.ceil(+length)
  return length < 0 ? 0 : length
}

function isArray (subject) {
  return (Array.isArray || function (subject) {
    return Object.prototype.toString.call(subject) === '[object Array]'
  })(subject)
}

function isArrayish (subject) {
  return isArray(subject) || Buffer.isBuffer(subject) ||
      subject && typeof subject === 'object' &&
      typeof subject.length === 'number'
}

function toHex (n) {
  if (n < 16) return '0' + n.toString(16)
  return n.toString(16)
}

function utf8ToBytes (str) {
  var byteArray = []
  for (var i = 0; i < str.length; i++) {
    var b = str.charCodeAt(i)
    if (b <= 0x7F)
      byteArray.push(str.charCodeAt(i))
    else {
      var start = i
      if (b >= 0xD800 && b <= 0xDFFF) i++
      var h = encodeURIComponent(str.slice(start, i+1)).substr(1).split('%')
      for (var j = 0; j < h.length; j++)
        byteArray.push(parseInt(h[j], 16))
    }
  }
  return byteArray
}

function asciiToBytes (str) {
  var byteArray = []
  for (var i = 0; i < str.length; i++) {
    // Node's code seems to be doing this and not & 0x7F..
    byteArray.push(str.charCodeAt(i) & 0xFF)
  }
  return byteArray
}

function utf16leToBytes (str) {
  var c, hi, lo
  var byteArray = []
  for (var i = 0; i < str.length; i++) {
    c = str.charCodeAt(i)
    hi = c >> 8
    lo = c % 256
    byteArray.push(lo)
    byteArray.push(hi)
  }

  return byteArray
}

function base64ToBytes (str) {
  return base64.toByteArray(str)
}

function blitBuffer (src, dst, offset, length) {
  var pos
  for (var i = 0; i < length; i++) {
    if ((i + offset >= dst.length) || (i >= src.length))
      break
    dst[i + offset] = src[i]
  }
  return i
}

function decodeUtf8Char (str) {
  try {
    return decodeURIComponent(str)
  } catch (err) {
    return String.fromCharCode(0xFFFD) // UTF 8 invalid char
  }
}

/*
 * We have to make sure that the value is a valid integer. This means that it
 * is non-negative. It has no fractional component and that it does not
 * exceed the maximum allowed value.
 */
function verifuint (value, max) {
  assert(typeof value === 'number', 'cannot write a non-number as a number')
  assert(value >= 0, 'specified a negative value for writing an unsigned value')
  assert(value <= max, 'value is larger than maximum value for type')
  assert(Math.floor(value) === value, 'value has a fractional component')
}

function verifsint (value, max, min) {
  assert(typeof value === 'number', 'cannot write a non-number as a number')
  assert(value <= max, 'value larger than maximum allowed value')
  assert(value >= min, 'value smaller than minimum allowed value')
  assert(Math.floor(value) === value, 'value has a fractional component')
}

function verifIEEE754 (value, max, min) {
  assert(typeof value === 'number', 'cannot write a non-number as a number')
  assert(value <= max, 'value larger than maximum allowed value')
  assert(value >= min, 'value smaller than minimum allowed value')
}

function assert (test, message) {
  if (!test) throw new Error(message || 'Failed assertion')
}

},{"base64-js":111,"ieee754":112}],111:[function(require,module,exports){
var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

;(function (exports) {
	'use strict';

  var Arr = (typeof Uint8Array !== 'undefined')
    ? Uint8Array
    : Array

	var PLUS   = '+'.charCodeAt(0)
	var SLASH  = '/'.charCodeAt(0)
	var NUMBER = '0'.charCodeAt(0)
	var LOWER  = 'a'.charCodeAt(0)
	var UPPER  = 'A'.charCodeAt(0)
	var PLUS_URL_SAFE = '-'.charCodeAt(0)
	var SLASH_URL_SAFE = '_'.charCodeAt(0)

	function decode (elt) {
		var code = elt.charCodeAt(0)
		if (code === PLUS ||
		    code === PLUS_URL_SAFE)
			return 62 // '+'
		if (code === SLASH ||
		    code === SLASH_URL_SAFE)
			return 63 // '/'
		if (code < NUMBER)
			return -1 //no match
		if (code < NUMBER + 10)
			return code - NUMBER + 26 + 26
		if (code < UPPER + 26)
			return code - UPPER
		if (code < LOWER + 26)
			return code - LOWER + 26
	}

	function b64ToByteArray (b64) {
		var i, j, l, tmp, placeHolders, arr

		if (b64.length % 4 > 0) {
			throw new Error('Invalid string. Length must be a multiple of 4')
		}

		// the number of equal signs (place holders)
		// if there are two placeholders, than the two characters before it
		// represent one byte
		// if there is only one, then the three characters before it represent 2 bytes
		// this is just a cheap hack to not do indexOf twice
		var len = b64.length
		placeHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0

		// base64 is 4/3 + up to two characters of the original data
		arr = new Arr(b64.length * 3 / 4 - placeHolders)

		// if there are placeholders, only get up to the last complete 4 chars
		l = placeHolders > 0 ? b64.length - 4 : b64.length

		var L = 0

		function push (v) {
			arr[L++] = v
		}

		for (i = 0, j = 0; i < l; i += 4, j += 3) {
			tmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))
			push((tmp & 0xFF0000) >> 16)
			push((tmp & 0xFF00) >> 8)
			push(tmp & 0xFF)
		}

		if (placeHolders === 2) {
			tmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)
			push(tmp & 0xFF)
		} else if (placeHolders === 1) {
			tmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)
			push((tmp >> 8) & 0xFF)
			push(tmp & 0xFF)
		}

		return arr
	}

	function uint8ToBase64 (uint8) {
		var i,
			extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
			output = "",
			temp, length

		function encode (num) {
			return lookup.charAt(num)
		}

		function tripletToBase64 (num) {
			return encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)
		}

		// go through the array every three bytes, we'll deal with trailing stuff later
		for (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {
			temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])
			output += tripletToBase64(temp)
		}

		// pad the end with zeros, but make sure to not forget the extra bytes
		switch (extraBytes) {
			case 1:
				temp = uint8[uint8.length - 1]
				output += encode(temp >> 2)
				output += encode((temp << 4) & 0x3F)
				output += '=='
				break
			case 2:
				temp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])
				output += encode(temp >> 10)
				output += encode((temp >> 4) & 0x3F)
				output += encode((temp << 2) & 0x3F)
				output += '='
				break
		}

		return output
	}

	exports.toByteArray = b64ToByteArray
	exports.fromByteArray = uint8ToBase64
}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))

},{}],112:[function(require,module,exports){
exports.read = function(buffer, offset, isLE, mLen, nBytes) {
  var e, m,
      eLen = nBytes * 8 - mLen - 1,
      eMax = (1 << eLen) - 1,
      eBias = eMax >> 1,
      nBits = -7,
      i = isLE ? (nBytes - 1) : 0,
      d = isLE ? -1 : 1,
      s = buffer[offset + i];

  i += d;

  e = s & ((1 << (-nBits)) - 1);
  s >>= (-nBits);
  nBits += eLen;
  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);

  m = e & ((1 << (-nBits)) - 1);
  e >>= (-nBits);
  nBits += mLen;
  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);

  if (e === 0) {
    e = 1 - eBias;
  } else if (e === eMax) {
    return m ? NaN : ((s ? -1 : 1) * Infinity);
  } else {
    m = m + Math.pow(2, mLen);
    e = e - eBias;
  }
  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
};

exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
  var e, m, c,
      eLen = nBytes * 8 - mLen - 1,
      eMax = (1 << eLen) - 1,
      eBias = eMax >> 1,
      rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),
      i = isLE ? 0 : (nBytes - 1),
      d = isLE ? 1 : -1,
      s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;

  value = Math.abs(value);

  if (isNaN(value) || value === Infinity) {
    m = isNaN(value) ? 1 : 0;
    e = eMax;
  } else {
    e = Math.floor(Math.log(value) / Math.LN2);
    if (value * (c = Math.pow(2, -e)) < 1) {
      e--;
      c *= 2;
    }
    if (e + eBias >= 1) {
      value += rt / c;
    } else {
      value += rt * Math.pow(2, 1 - eBias);
    }
    if (value * c >= 2) {
      e++;
      c /= 2;
    }

    if (e + eBias >= eMax) {
      m = 0;
      e = eMax;
    } else if (e + eBias >= 1) {
      m = (value * c - 1) * Math.pow(2, mLen);
      e = e + eBias;
    } else {
      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
      e = 0;
    }
  }

  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);

  e = (e << mLen) | m;
  eLen += mLen;
  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);

  buffer[offset + i - d] |= s * 128;
};

},{}],113:[function(require,module,exports){
if (typeof Object.create === 'function') {
  // implementation from standard node.js 'util' module
  module.exports = function inherits(ctor, superCtor) {
    ctor.super_ = superCtor
    ctor.prototype = Object.create(superCtor.prototype, {
      constructor: {
        value: ctor,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
  };
} else {
  // old school shim for old browsers
  module.exports = function inherits(ctor, superCtor) {
    ctor.super_ = superCtor
    var TempCtor = function () {}
    TempCtor.prototype = superCtor.prototype
    ctor.prototype = new TempCtor()
    ctor.prototype.constructor = ctor
  }
}

},{}],114:[function(require,module,exports){
// shim for using process in browser

var process = module.exports = {};

process.nextTick = (function () {
    var canSetImmediate = typeof window !== 'undefined'
    && window.setImmediate;
    var canPost = typeof window !== 'undefined'
    && window.postMessage && window.addEventListener
    ;

    if (canSetImmediate) {
        return function (f) { return window.setImmediate(f) };
    }

    if (canPost) {
        var queue = [];
        window.addEventListener('message', function (ev) {
            var source = ev.source;
            if ((source === window || source === null) && ev.data === 'process-tick') {
                ev.stopPropagation();
                if (queue.length > 0) {
                    var fn = queue.shift();
                    fn();
                }
            }
        }, true);

        return function nextTick(fn) {
            queue.push(fn);
            window.postMessage('process-tick', '*');
        };
    }

    return function nextTick(fn) {
        setTimeout(fn, 0);
    };
})();

process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];

function noop() {}

process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;

process.binding = function (name) {
    throw new Error('process.binding is not supported');
}

// TODO(shtylman)
process.cwd = function () { return '/' };
process.chdir = function (dir) {
    throw new Error('process.chdir is not supported');
};

},{}],115:[function(require,module,exports){
module.exports = function isBuffer(arg) {
  return arg && typeof arg === 'object'
    && typeof arg.copy === 'function'
    && typeof arg.fill === 'function'
    && typeof arg.readUInt8 === 'function';
}
},{}],116:[function(require,module,exports){
(function (process,global){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

var formatRegExp = /%[sdj%]/g;
exports.format = function(f) {
  if (!isString(f)) {
    var objects = [];
    for (var i = 0; i < arguments.length; i++) {
      objects.push(inspect(arguments[i]));
    }
    return objects.join(' ');
  }

  var i = 1;
  var args = arguments;
  var len = args.length;
  var str = String(f).replace(formatRegExp, function(x) {
    if (x === '%%') return '%';
    if (i >= len) return x;
    switch (x) {
      case '%s': return String(args[i++]);
      case '%d': return Number(args[i++]);
      case '%j':
        try {
          return JSON.stringify(args[i++]);
        } catch (_) {
          return '[Circular]';
        }
      default:
        return x;
    }
  });
  for (var x = args[i]; i < len; x = args[++i]) {
    if (isNull(x) || !isObject(x)) {
      str += ' ' + x;
    } else {
      str += ' ' + inspect(x);
    }
  }
  return str;
};


// Mark that a method should not be used.
// Returns a modified function which warns once by default.
// If --no-deprecation is set, then it is a no-op.
exports.deprecate = function(fn, msg) {
  // Allow for deprecating things in the process of starting up.
  if (isUndefined(global.process)) {
    return function() {
      return exports.deprecate(fn, msg).apply(this, arguments);
    };
  }

  if (process.noDeprecation === true) {
    return fn;
  }

  var warned = false;
  function deprecated() {
    if (!warned) {
      if (process.throwDeprecation) {
        throw new Error(msg);
      } else if (process.traceDeprecation) {
        console.trace(msg);
      } else {
        console.error(msg);
      }
      warned = true;
    }
    return fn.apply(this, arguments);
  }

  return deprecated;
};


var debugs = {};
var debugEnviron;
exports.debuglog = function(set) {
  if (isUndefined(debugEnviron))
    debugEnviron = process.env.NODE_DEBUG || '';
  set = set.toUpperCase();
  if (!debugs[set]) {
    if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
      var pid = process.pid;
      debugs[set] = function() {
        var msg = exports.format.apply(exports, arguments);
        console.error('%s %d: %s', set, pid, msg);
      };
    } else {
      debugs[set] = function() {};
    }
  }
  return debugs[set];
};


/**
 * 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 {Object} opts Optional options object that alters the output.
 */
/* legacy: obj, showHidden, depth, colors*/
function inspect(obj, opts) {
  // default options
  var ctx = {
    seen: [],
    stylize: stylizeNoColor
  };
  // legacy...
  if (arguments.length >= 3) ctx.depth = arguments[2];
  if (arguments.length >= 4) ctx.colors = arguments[3];
  if (isBoolean(opts)) {
    // legacy...
    ctx.showHidden = opts;
  } else if (opts) {
    // got an "options" object
    exports._extend(ctx, opts);
  }
  // set default options
  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
  if (isUndefined(ctx.depth)) ctx.depth = 2;
  if (isUndefined(ctx.colors)) ctx.colors = false;
  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
  if (ctx.colors) ctx.stylize = stylizeWithColor;
  return formatValue(ctx, obj, ctx.depth);
}
exports.inspect = inspect;


// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
inspect.colors = {
  'bold' : [1, 22],
  'italic' : [3, 23],
  'underline' : [4, 24],
  'inverse' : [7, 27],
  'white' : [37, 39],
  'grey' : [90, 39],
  'black' : [30, 39],
  'blue' : [34, 39],
  'cyan' : [36, 39],
  'green' : [32, 39],
  'magenta' : [35, 39],
  'red' : [31, 39],
  'yellow' : [33, 39]
};

// Don't use 'blue' not visible on cmd.exe
inspect.styles = {
  'special': 'cyan',
  'number': 'yellow',
  'boolean': 'yellow',
  'undefined': 'grey',
  'null': 'bold',
  'string': 'green',
  'date': 'magenta',
  // "name": intentionally not styling
  'regexp': 'red'
};


function stylizeWithColor(str, styleType) {
  var style = inspect.styles[styleType];

  if (style) {
    return '\u001b[' + inspect.colors[style][0] + 'm' + str +
           '\u001b[' + inspect.colors[style][1] + 'm';
  } else {
    return str;
  }
}


function stylizeNoColor(str, styleType) {
  return str;
}


function arrayToHash(array) {
  var hash = {};

  array.forEach(function(val, idx) {
    hash[val] = true;
  });

  return hash;
}


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 (ctx.customInspect &&
      value &&
      isFunction(value.inspect) &&
      // 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, ctx);
    if (!isString(ret)) {
      ret = formatValue(ctx, ret, recurseTimes);
    }
    return ret;
  }

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

  // Look up the keys of the object.
  var keys = Object.keys(value);
  var visibleKeys = arrayToHash(keys);

  if (ctx.showHidden) {
    keys = Object.getOwnPropertyNames(value);
  }

  // IE doesn't make error fields non-enumerable
  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
  if (isError(value)
      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
    return formatError(value);
  }

  // Some type of object without properties can be shortcutted.
  if (keys.length === 0) {
    if (isFunction(value)) {
      var name = value.name ? ': ' + value.name : '';
      return ctx.stylize('[Function' + name + ']', 'special');
    }
    if (isRegExp(value)) {
      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
    }
    if (isDate(value)) {
      return ctx.stylize(Date.prototype.toString.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 (isFunction(value)) {
    var n = value.name ? ': ' + value.name : '';
    base = ' [Function' + n + ']';
  }

  // 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)) {
    base = ' ' + 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) {
  if (isUndefined(value))
    return ctx.stylize('undefined', 'undefined');
  if (isString(value)) {
    var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
                                             .replace(/'/g, "\\'")
                                             .replace(/\\"/g, '"') + '\'';
    return ctx.stylize(simple, 'string');
  }
  if (isNumber(value))
    return ctx.stylize('' + value, 'number');
  if (isBoolean(value))
    return ctx.stylize('' + value, 'boolean');
  // For some reason typeof null is "object", so special case here.
  if (isNull(value))
    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 (hasOwnProperty(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, desc;
  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
  if (desc.get) {
    if (desc.set) {
      str = ctx.stylize('[Getter/Setter]', 'special');
    } else {
      str = ctx.stylize('[Getter]', 'special');
    }
  } else {
    if (desc.set) {
      str = ctx.stylize('[Setter]', 'special');
    }
  }
  if (!hasOwnProperty(visibleKeys, key)) {
    name = '[' + key + ']';
  }
  if (!str) {
    if (ctx.seen.indexOf(desc.value) < 0) {
      if (isNull(recurseTimes)) {
        str = formatValue(ctx, desc.value, null);
      } else {
        str = formatValue(ctx, desc.value, 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 (isUndefined(name)) {
    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.replace(/\u001b\[\d\d?m/g, '').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];
}


// NOTE: These type checking functions intentionally don't use `instanceof`
// because it is fragile and can be easily faked with `Object.create()`.
function isArray(ar) {
  return Array.isArray(ar);
}
exports.isArray = isArray;

function isBoolean(arg) {
  return typeof arg === 'boolean';
}
exports.isBoolean = isBoolean;

function isNull(arg) {
  return arg === null;
}
exports.isNull = isNull;

function isNullOrUndefined(arg) {
  return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;

function isNumber(arg) {
  return typeof arg === 'number';
}
exports.isNumber = isNumber;

function isString(arg) {
  return typeof arg === 'string';
}
exports.isString = isString;

function isSymbol(arg) {
  return typeof arg === 'symbol';
}
exports.isSymbol = isSymbol;

function isUndefined(arg) {
  return arg === void 0;
}
exports.isUndefined = isUndefined;

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

function isObject(arg) {
  return typeof arg === 'object' && arg !== null;
}
exports.isObject = isObject;

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

function isError(e) {
  return isObject(e) &&
      (objectToString(e) === '[object Error]' || e instanceof Error);
}
exports.isError = isError;

function isFunction(arg) {
  return typeof arg === 'function';
}
exports.isFunction = isFunction;

function isPrimitive(arg) {
  return arg === null ||
         typeof arg === 'boolean' ||
         typeof arg === 'number' ||
         typeof arg === 'string' ||
         typeof arg === 'symbol' ||  // ES6 symbol
         typeof arg === 'undefined';
}
exports.isPrimitive = isPrimitive;

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

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


function pad(n) {
  return n < 10 ? '0' + n.toString(10) : n.toString(10);
}


var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
              'Oct', 'Nov', 'Dec'];

// 26 Feb 16:19:34
function timestamp() {
  var d = new Date();
  var time = [pad(d.getHours()),
              pad(d.getMinutes()),
              pad(d.getSeconds())].join(':');
  return [d.getDate(), months[d.getMonth()], time].join(' ');
}


// log is just a thin wrapper to console.log that prepends a timestamp
exports.log = function() {
  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
};


/**
 * Inherit the prototype methods from one constructor into another.
 *
 * The Function.prototype.inherits from lang.js rewritten as a standalone
 * function (not on Function.prototype). NOTE: If this file is to be loaded
 * during bootstrapping this function needs to be rewritten using some native
 * functions as prototype setup using normal JavaScript does not work as
 * expected during bootstrapping (see mirror.js in r114903).
 *
 * @param {function} ctor Constructor function which needs to inherit the
 *     prototype.
 * @param {function} superCtor Constructor function to inherit prototype from.
 */
exports.inherits = require('inherits');

exports._extend = function(origin, add) {
  // Don't do anything if add isn't an object
  if (!add || !isObject(add)) return origin;

  var keys = Object.keys(add);
  var i = keys.length;
  while (i--) {
    origin[keys[i]] = add[keys[i]];
  }
  return origin;
};

function hasOwnProperty(obj, prop) {
  return Object.prototype.hasOwnProperty.call(obj, prop);
}

}).call(this,require("1YiZ5S"),typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
},{"./support/isBuffer":115,"1YiZ5S":114,"inherits":113}],117:[function(require,module,exports){
module.exports=require(37)
},{}],118:[function(require,module,exports){
module.exports=require(38)
},{"./sinon/assert":119,"./sinon/behavior":120,"./sinon/call":121,"./sinon/collection":122,"./sinon/extend":123,"./sinon/format":124,"./sinon/log_error":125,"./sinon/match":126,"./sinon/mock":127,"./sinon/sandbox":128,"./sinon/spy":129,"./sinon/stub":130,"./sinon/test":131,"./sinon/test_case":132,"./sinon/times_in_words":133,"./sinon/typeOf":134,"./sinon/util/core":135}],119:[function(require,module,exports){
module.exports=require(39)
},{"./format":124,"./match":126,"./util/core":135}],120:[function(require,module,exports){
module.exports=require(40)
},{"./extend":123,"./util/core":135,"1YiZ5S":114}],121:[function(require,module,exports){
module.exports=require(41)
},{"./format":124,"./match":126,"./util/core":135}],122:[function(require,module,exports){
module.exports=require(42)
},{"./mock":127,"./spy":129,"./stub":130,"./util/core":135}],123:[function(require,module,exports){
module.exports=require(43)
},{"./util/core":135}],124:[function(require,module,exports){
module.exports=require(44)
},{"./util/core":135,"formatio":142,"util":116}],125:[function(require,module,exports){
module.exports=require(45)
},{"./util/core":135}],126:[function(require,module,exports){
module.exports=require(46)
},{"./typeOf":134,"./util/core":135}],127:[function(require,module,exports){
module.exports=require(47)
},{"./call":121,"./extend":123,"./format":124,"./match":126,"./spy":129,"./stub":130,"./times_in_words":133,"./util/core":135}],128:[function(require,module,exports){
module.exports=require(48)
},{"./collection":122,"./extend":123,"./util/core":135,"./util/fake_server_with_clock":138,"./util/fake_timers":139}],129:[function(require,module,exports){
module.exports=require(49)
},{"./call":121,"./extend":123,"./format":124,"./times_in_words":133,"./util/core":135}],130:[function(require,module,exports){
module.exports=require(50)
},{"./behavior":120,"./extend":123,"./spy":129,"./util/core":135}],131:[function(require,module,exports){
module.exports=require(51)
},{"./sandbox":128,"./util/core":135}],132:[function(require,module,exports){
module.exports=require(52)
},{"./test":131,"./util/core":135}],133:[function(require,module,exports){
module.exports=require(53)
},{"./util/core":135}],134:[function(require,module,exports){
module.exports=require(54)
},{"./util/core":135}],135:[function(require,module,exports){
module.exports=require(55)
},{}],136:[function(require,module,exports){
module.exports=require(56)
},{"./core":135}],137:[function(require,module,exports){
module.exports=require(57)
},{"../format":124,"./core":135,"./fake_xdomain_request":140,"./fake_xml_http_request":141}],138:[function(require,module,exports){
module.exports=require(58)
},{"./core":135,"./fake_server":137,"./fake_timers":139}],139:[function(require,module,exports){
module.exports=require(59)
},{"./core":135,"lolex":144}],140:[function(require,module,exports){
module.exports=require(60)
},{"../extend":123,"../log_error":125,"./core":135,"./event":136}],141:[function(require,module,exports){
module.exports=require(61)
},{"../extend":123,"../log_error":125,"./core":135,"./event":136}],142:[function(require,module,exports){
module.exports=require(62)
},{"samsam":143}],143:[function(require,module,exports){
module.exports=require(63)
},{}],144:[function(require,module,exports){
module.exports=require(64)
},{}],145:[function(require,module,exports){
module.exports=require(65)
},{}],146:[function(require,module,exports){
var Connector, Test, Y, chai, expect, sinon, sinonChai, _,
  __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };

chai = require('chai');

expect = chai.expect;

sinon = require('sinon');

sinonChai = require('sinon-chai');

_ = require("underscore");

chai.use(sinonChai);

Connector = require("../../y-test/lib/y-test.coffee");

Y = null;

module.exports = Test = (function() {
  function Test(name_suffix, Yjs) {
    var gf, t, _i, _j, _len, _len1, _ref, _ref1;
    this.name_suffix = name_suffix != null ? name_suffix : "";
    this.applyRandomOp = __bind(this.applyRandomOp, this);
    this.generateRandomOp = __bind(this.generateRandomOp, this);
    this.getGeneratingFunctions = __bind(this.getGeneratingFunctions, this);
    Y = Yjs;
    this.number_of_test_cases_multiplier = 1;
    this.repeat_this = 1 * this.number_of_test_cases_multiplier;
    this.doSomething_amount = 123 * this.number_of_test_cases_multiplier;
    this.number_of_engines = 5 + this.number_of_test_cases_multiplier - 1;
    this.time = 0;
    this.ops = 0;
    this.time_now = 0;
    this.max_depth = 3;
    this.debug = false;
    this.reinitialize();
    _ref = this.getGeneratingFunctions(0);
    for (_i = 0, _len = _ref.length; _i < _len; _i++) {
      gf = _ref[_i];
      if (!((gf.types != null) && (gf.f != null))) {
        throw new Error("Generating Functions are not initialized properly!");
      }
      _ref1 = gf.types;
      for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) {
        t = _ref1[_j];
        if (t == null) {
          throw new Error("You havent includedt this type in Y (do require 'y-whatever')");
        }
      }
    }
  }

  Test.prototype.reinitialize = function() {
    var i, u, user, _i, _j, _len, _ref, _ref1;
    this.users = [];
    for (i = _i = 0, _ref = this.number_of_engines; 0 <= _ref ? _i < _ref : _i > _ref; i = 0 <= _ref ? ++_i : --_i) {
      u = this.makeNewUser(i + this.name_suffix);
      _ref1 = this.users;
      for (_j = 0, _len = _ref1.length; _j < _len; _j++) {
        user = _ref1[_j];
        u._model.connector.join(user._model.connector);
      }
      this.users.push(u);
    }
    if (typeof this.initUsers === "function") {
      this.initUsers(this.users[0]);
    }
    return this.flushAll();
  };

  Test.prototype.makeNewUser = function(user) {
    user._model.HB.stopGarbageCollection();
    return user;
  };

  Test.prototype.getSomeUser = function() {
    var i;
    i = _.random(0, this.users.length - 1);
    return this.users[i];
  };

  Test.prototype.getRandomText = function(chars, min_length) {
    var length, nextchar, text;
    if (min_length == null) {
      min_length = 0;
    }
    if (chars == null) {
      chars = "abcdefghijklmnopqrstuvwxyz";
    }
    length = _.random(min_length, 10);
    nextchar = chars[_.random(0, chars.length - 1)];
    text = "";
    _(length).times(function() {
      return text += nextchar;
    });
    return text;
  };

  Test.prototype.getRandomObject = function() {
    var key1, key2, result, val1, val2;
    result = {};
    key1 = this.getRandomKey();
    key2 = this.getRandomKey();
    val1 = this.getRandomText();
    val2 = null;
    if (_.random(0, 1) === 1) {
      val2 = this.getRandomObject();
    } else {
      val2 = this.getRandomText();
    }
    result[key1] = val1;
    result[key2] = val2;
    return result;
  };

  Test.prototype.getRandomKey = function() {
    return this.getRandomText([1, 2, 'x', 'y'], 1);
  };

  Test.prototype.getGeneratingFunctions = function(user_num) {
    var types;
    types = this.users[user_num]._model.operations;
    return [];
  };

  Test.prototype.getRandomRoot = function(user_num) {
    throw new Error("implement me!");
  };

  Test.prototype.compare = function(o1, o2, depth) {
    var i, name, o, val, _i, _j, _len, _len1, _ref, _ref1, _results, _results1, _results2;
    if (depth == null) {
      depth = this.max_depth + 1;
    }
    if (o1 === o2 || depth <= 0) {
      return true;
    } else if ((o1._name != null) && o1._name !== o2._name) {
      throw new Error("different types");
    } else if (o1._model != null) {
      return this.compare(o1._model, o2._model, depth);
    } else if (o1.type === "MapManager") {
      _ref = o1.val();
      _results = [];
      for (name in _ref) {
        val = _ref[name];
        _results.push(this.compare(val, o2.val(name), depth - 1));
      }
      return _results;
    } else if (o1.type === "ListManager") {
      _ref1 = o1.val();
      _results1 = [];
      for (i = _i = 0, _len = _ref1.length; _i < _len; i = ++_i) {
        val = _ref1[i];
        _results1.push(this.compare(val, o2.val(i), depth - 1));
      }
      return _results1;
    } else if (o1.constructor === Array && o2.constructor === Array) {
      if (o1.length !== o2.length) {
        throw new Error("The Arrays do not have the same size!");
      }
      _results2 = [];
      for (i = _j = 0, _len1 = o1.length; _j < _len1; i = ++_j) {
        o = o1[i];
        _results2.push(this.compare(o, o2[i], depth - 1));
      }
      return _results2;
    } else if (o1 !== o2) {
      throw new Error("different values");
    } else {
      throw new Error("I don't know what to do .. ");
    }
  };

  Test.prototype.generateRandomOp = function(user_num) {
    var choices, i, y;
    y = this.getRandomRoot(user_num);
    choices = this.getGeneratingFunctions(user_num).filter(function(gf) {
      return _.some(gf.types, function(type) {
        return y instanceof type;
      });
    });
    if (choices.length === 0) {
      console.dir(y);
      throw new Error("You forgot to specify a test generation methot for this Operation! (" + y.type + ")");
    }
    i = _.random(0, choices.length - 1);
    return choices[i].f(y);
  };

  Test.prototype.applyRandomOp = function(user_num) {
    var user;
    user = this.users[user_num];
    return user._model.connector.flushOneRandom();
  };

  Test.prototype.doSomething = function() {
    var choice, choices, user_num;
    user_num = _.random(this.number_of_engines - 1);
    choices = [this.applyRandomOp, this.generateRandomOp];
    choice = _.random(choices.length - 1);
    return choices[choice](user_num);
  };

  Test.prototype.flushAll = function(final) {
    var ops, user, user_number, _i, _j, _len, _len1, _ref, _ref1, _results;
    final = false;
    if (this.users.length <= 1 || !final) {
      _ref = this.users;
      _results = [];
      for (user_number = _i = 0, _len = _ref.length; _i < _len; user_number = ++_i) {
        user = _ref[user_number];
        _results.push(user._model.connector.flushAll());
      }
      return _results;
    } else {
      _ref1 = this.users.slice(1);
      for (user_number = _j = 0, _len1 = _ref1.length; _j < _len1; user_number = ++_j) {
        user = _ref1[user_number];
        user._model.connector.flushAll();
      }
      ops = this.users[1].getHistoryBuffer()._encode(this.users[0].HB.getOperationCounter());
      return this.users[0].engine.applyOpsCheckDouble(ops);
    }
  };

  Test.prototype.compareAll = function(test_number) {
    var i, j, number_of_created_operations, ops, ops_per_msek, printOpsInExecutionOrder, u, _i, _j, _k, _len, _ref, _ref1, _ref2, _results;
    this.flushAll(true);
    this.time += (new Date()).getTime() - this.time_now;
    number_of_created_operations = 0;
    for (i = _i = 0, _ref = this.users.length; 0 <= _ref ? _i < _ref : _i > _ref; i = 0 <= _ref ? ++_i : --_i) {
      number_of_created_operations += this.users[i]._model.connector.getOpsInExecutionOrder().length;
    }
    this.ops += number_of_created_operations * this.users.length;
    ops_per_msek = Math.floor(this.ops / this.time);
    if (test_number != null) {
      console.log(("" + test_number + "/" + this.repeat_this + ": " + number_of_created_operations + " were created and applied on (" + this.users.length + ") users ops in a different order.") + (" Over all we consumed " + this.ops + " operations in " + (this.time / 1000) + " seconds (" + ops_per_msek + " ops/msek)."));
    }
    _results = [];
    for (i = _j = 0, _ref1 = this.users.length - 1; 0 <= _ref1 ? _j < _ref1 : _j > _ref1; i = 0 <= _ref1 ? ++_j : --_j) {
      if (this.debug) {
        if (!_.isEqual(this.getContent(i), this.getContent(i + 1))) {
          printOpsInExecutionOrder = (function(_this) {
            return function(otnumber, otherotnumber) {
              var j, o, ops, s, _k, _l, _len, _len1;
              ops = _.filter(_this.users[otnumber]._model.connector.getOpsInExecutionOrder(), function(o) {
                return typeof o.uid.op_name !== 'string' && o.uid.creator !== '_';
              });
              for (j = _k = 0, _len = ops.length; _k < _len; j = ++_k) {
                s = ops[j];
                console.log(("op" + j + " = ") + (JSON.stringify(s)));
              }
              console.log("");
              s = "ops = [";
              for (j = _l = 0, _len1 = ops.length; _l < _len1; j = ++_l) {
                o = ops[j];
                if (j !== 0) {
                  s += ", ";
                }
                s += "op" + j;
              }
              s += "]";
              console.log(s);
              console.log("@test_user.engine.applyOps ops");
              console.log("expect(@test_user.val('name').val()).to.equal(\"" + (_this.users[otherotnumber].val('name').val()) + "\")");
              return ops;
            };
          })(this);
          console.log("");
          console.log("Found an OT Puzzle!");
          console.log("OT states:");
          _ref2 = this.users;
          for (j = _k = 0, _len = _ref2.length; _k < _len; j = ++_k) {
            u = _ref2[j];
            console.log(("OT" + j + ": ") + u.val('name').val());
          }
          console.log("\nOT execution order (" + i + "," + (i + 1) + "):");
          printOpsInExecutionOrder(i, i + 1);
          console.log("");
          ops = printOpsInExecutionOrder(i + 1, i);
          console.log("");
        }
      }
      _results.push(expect(this.compare(this.users[i], this.users[i + 1])).to.not.be.undefined);
    }
    return _results;
  };

  Test.prototype.run = function() {
    var i, times, u, _i, _j, _k, _l, _len, _ref, _ref1, _ref2, _ref3, _results;
    if (this.debug) {
      console.log('');
    }
    _results = [];
    for (times = _i = 1, _ref = this.repeat_this; 1 <= _ref ? _i <= _ref : _i >= _ref; times = 1 <= _ref ? ++_i : --_i) {
      this.time_now = (new Date).getTime();
      for (i = _j = 1, _ref1 = Math.floor(this.doSomething_amount / 2); 1 <= _ref1 ? _j <= _ref1 : _j >= _ref1; i = 1 <= _ref1 ? ++_j : --_j) {
        this.doSomething();
      }
      this.flushAll(false);
      _ref2 = this.users;
      for (_k = 0, _len = _ref2.length; _k < _len; _k++) {
        u = _ref2[_k];
        u._model.HB.emptyGarbage();
      }
      for (i = _l = 1, _ref3 = Math.floor(this.doSomething_amount / 2); 1 <= _ref3 ? _l <= _ref3 : _l >= _ref3; i = 1 <= _ref3 ? ++_l : --_l) {
        this.doSomething();
      }
      this.compareAll(times);
      this.testHBencoding();
      if (times !== this.repeat_this) {
        _results.push(this.reinitialize());
      } else {
        _results.push(void 0);
      }
    }
    return _results;
  };

  Test.prototype.testHBencoding = function() {
    this.users[this.users.length] = this.makeNewUser(-1.);
    this.users[this.users.length - 1]._model.HB.renewStateVector(this.users[0]._model.HB.getOperationCounter());
    this.users[this.users.length - 1]._model.engine.applyOps(this.users[0]._model.HB._encode());
    return expect(this.compare(this.users[this.users.length - 1], this.users[0])).to.not.be.undefined;
  };

  return Test;

})();


},{"../../y-test/lib/y-test.coffee":67,"chai":76,"sinon":118,"sinon-chai":117,"underscore":145}]},{},[66])
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/dmonad/git/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/browser-pack/_prelude.js","/home/dmonad/git/y-list/lib/y-list.coffee","/home/dmonad/git/y-selections/lib/y-selections.coffee","/home/dmonad/git/y-selections/node_modules/chai/index.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/assertion.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/config.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/core/assertions.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/interface/assert.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/interface/expect.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/interface/should.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/addChainableMethod.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/addMethod.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/addProperty.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/flag.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/getActual.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/getEnumerableProperties.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/getMessage.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/getName.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/getPathInfo.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/getPathValue.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/getProperties.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/hasProperty.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/index.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/inspect.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/objDisplay.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/overwriteChainableMethod.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/overwriteMethod.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/overwriteProperty.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/test.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/transferFlags.js","/home/dmonad/git/y-selections/node_modules/chai/lib/chai/utils/type.js","/home/dmonad/git/y-selections/node_modules/chai/node_modules/assertion-error/index.js","/home/dmonad/git/y-selections/node_modules/chai/node_modules/deep-eql/index.js","/home/dmonad/git/y-selections/node_modules/chai/node_modules/deep-eql/lib/eql.js","/home/dmonad/git/y-selections/node_modules/chai/node_modules/deep-eql/node_modules/type-detect/index.js","/home/dmonad/git/y-selections/node_modules/chai/node_modules/deep-eql/node_modules/type-detect/lib/type.js","/home/dmonad/git/y-selections/node_modules/sinon-chai/lib/sinon-chai.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/assert.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/behavior.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/call.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/collection.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/extend.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/format.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/log_error.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/match.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/mock.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/sandbox.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/spy.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/stub.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/test.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/test_case.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/times_in_words.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/typeOf.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/util/core.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/util/event.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/util/fake_server.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/util/fake_server_with_clock.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/util/fake_timers.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/util/fake_xdomain_request.js","/home/dmonad/git/y-selections/node_modules/sinon/lib/sinon/util/fake_xml_http_request.js","/home/dmonad/git/y-selections/node_modules/sinon/node_modules/formatio/lib/formatio.js","/home/dmonad/git/y-selections/node_modules/sinon/node_modules/formatio/node_modules/samsam/lib/samsam.js","/home/dmonad/git/y-selections/node_modules/sinon/node_modules/lolex/src/lolex.js","/home/dmonad/git/y-selections/node_modules/underscore/underscore.js","/home/dmonad/git/y-selections/test/selections-test.coffee","/home/dmonad/git/y-test/lib/y-test.coffee","/home/dmonad/git/yjs/lib/ConnectorAdapter.coffee","/home/dmonad/git/yjs/lib/ConnectorClass.coffee","/home/dmonad/git/yjs/lib/Engine.coffee","/home/dmonad/git/yjs/lib/HistoryBuffer.coffee","/home/dmonad/git/yjs/lib/ObjectType.coffee","/home/dmonad/git/yjs/lib/Operations/Basic.coffee","/home/dmonad/git/yjs/lib/Operations/Structured.coffee","/home/dmonad/git/yjs/lib/y.coffee","/home/dmonad/git/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/buffer/index.js","/home/dmonad/git/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/buffer/node_modules/base64-js/lib/b64.js","/home/dmonad/git/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/buffer/node_modules/ieee754/index.js","/home/dmonad/git/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/inherits/inherits_browser.js","/home/dmonad/git/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/process/browser.js","/home/dmonad/git/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/util/support/isBufferBrowser.js","/home/dmonad/git/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/util/util.js","/home/dmonad/git/yjs/test/TestSuite.coffee"],"names":[],"mappings":"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AAjB,EADO;EAAA,CArcT,CAAA;;AAAA,wBAwcA,SAAA,GAAW,SAAC,CAAD,GAAA;WACT,IAAC,CAAA,UAAD,GAAc,IAAC,CAAA,UAAU,CAAC,MAAZ,CAAmB,SAAC,CAAD,GAAA;aAC/B,CAAA,KAAK,EAD0B;IAAA,CAAnB,EADL;EAAA,CAxcX,CAAA;;qBAAA;;IAXF,CAAA;;AAwdA,IAAG,gDAAH;AACE,EAAA,IAAG,gBAAH;AACE,IAAA,MAAM,CAAC,CAAC,CAAC,UAAT,GAAsB,WAAtB,CADF;GAAA,MAAA;AAGE,UAAU,IAAA,KAAA,CAAM,0BAAN,CAAV,CAHF;GADF;CAxdA;;AA8dA,IAAG,gDAAH;AACE,EAAA,MAAM,CAAC,OAAP,GAAiB,WAAjB,CADF;CA9dA;;;;ACFA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7FA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChhDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/uCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC7UA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACt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jQA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9IA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACzWA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3NA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9PA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxcA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtcA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtYA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChPA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACr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mBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/YA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxaA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AA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;;;;;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrlCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5HA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACpFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACv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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error(\"Cannot find module '\"+o+\"'\")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","class YList\n\n  #\n  # @private\n  # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n  #\n  constructor: (list)->\n    if not list?\n      @_list = []\n    else if list.constructor is Array\n      @_list = list\n    else\n      throw new Error \"Y.List expects an Array as a parameter\"\n\n  _name: \"List\"\n\n  _getModel: (types, ops)->\n    if not @_model?\n      @_model = new ops.ListManager(@).execute()\n      @_model.insert 0, @_list\n    delete @_list\n    @_model\n\n  _setModel: (@_model)->\n    delete @_list\n\n  val: ()->\n    @_model.val.apply @_model, arguments\n\n  ref: ()->\n    @_model.ref.apply @_model, arguments\n\n\n  observe: ()->\n    @_model.observe.apply @_model, arguments\n    @\n\n  unobserve: ()->\n    @_model.unobserve.apply @_model, arguments\n    @\n\n  #\n  # Inserts an Object into the list.\n  #\n  # @return {ListManager Type} This String object.\n  #\n  insert: (position, content)->\n    if typeof position isnt \"number\"\n      throw new Error \"Y.List.insert expects a Number as the first parameter!\"\n    @_model.insert position, [content]\n    @\n\n  insertContents: (position, contents)->\n    if typeof position isnt \"number\"\n      throw new Error \"Y.List.insert expects a Number as the first parameter!\"\n    @_model.insert position, contents\n    @\n\n  delete: (position, length)->\n    @_model.delete position, length\n    @\n\n  push: (content)->\n    @_model.push content\n    @\n\nif window?\n  if window.Y?\n    window.Y.List = YList\n  else\n    throw new Error \"You must first import Y!\"\n\nif module?\n  module.exports = YList\n\n\n\n\n\n\n\n\n\n\n","\n# compare two object for equality (no deep check!)\ncompare_objects = (o, p, doAgain=true)->\n  for n,v of o\n    if not (p[n]? and p[n] is v)\n      return false\n  if doAgain\n    compare_objects(p,o,false)\n  else\n    true\n\n\nclass YSelections\n  constructor: ()->\n    @_listeners = []\n    @_composition_value = []\n    # we put all the lists we use in this array\n    @_lists = []\n\n  _name: \"Selections\"\n\n  _getModel: (Y, Operation) ->\n    if not @_model?\n      @_model = new Operation.Composition(@, []).execute()\n    @_model\n\n  _setModel: (@_model)->\n\n  _getCompositionValue: ()->\n    composition_value_operations = {}\n    composition_value = for v,i in @_composition_value\n      composition_value_operations[\"\"+i+\"/from\"] = v.from\n      composition_value_operations[\"\"+i+\"/to\"] = v.to\n      {\n        attrs: v.attrs\n      }\n\n    return {\n      composition_value : composition_value\n      composition_value_operations: composition_value_operations\n    }\n\n\n  _setCompositionValue: (composition_value)->\n    for v in composition_value\n      v.type = \"select\"\n      @_apply v\n\n  _apply: (delta)->\n    undos = [] # list of deltas that are necessary to undo the change\n\n    if delta.from.isDeleted()\n      delta.from = delta.from.getNext()\n    if delta.to.isDeleted()\n      delta.to = delta.to.getPrev()\n\n    from = delta.from\n    to = delta.to\n    if from.getPrev() is to\n      # There is nothing to select anymore!\n      return undos\n\n\n    #\n    # Assuming $from is deleted at some point. We need to change the selection\n    # _before_ the GC removes it completely from the list. Therefore, we listen to\n    # \"delete\" events, and if that particular operation has a selection\n    # (o.sselection?) we move the selection to the next undeleted operation, if\n    # any. It also handles the case that there is nothing to select anymore (e.g.\n    # everything inside the selection is deleted). Then we remove the selection\n    # completely\n    #\n    # if never applied a delta on this list, add a listener to it in order to change selections if necessary\n    if delta.type is \"select\"\n      parent = from.getParent()\n      parent_exists = false\n      for p in @_lists\n        if parent is @_lists[p]\n          parent_exists = true\n          break\n      if not parent_exists\n        @_lists.push parent\n        parent.observe (events)=>\n          for event in events\n            if event.type is \"delete\"\n              if event.reference.selection?\n                ref = event.reference\n                sel = ref.selection\n                delete ref.selection # delete it, because ref is going to get deleted!\n                if sel.from is ref and sel.to is ref\n                  @_removeFromCompositionValue sel\n                else if sel.from is ref\n                  prev = ref.getNext()\n                  sel.from = prev\n                  prev.selection = sel\n                else if sel.to is ref\n                  next = ref.getPrev()\n                  sel.to = next\n                  next.selection = sel\n                else\n                  throw new Error \"Found weird inconsistency! Y.Selections is no longer safe to use!\"\n              next = event.reference.getNext()\n              if next.selection?\n                @_combine_selection_to_left next.selection\n\n    # notify listeners:\n    observer_call =\n      from: from\n      to: to\n      type: delta.type\n      attrs: delta.attrs\n    for l in @_listeners\n      l.call this, observer_call\n    createSelection = (from, to, attrs)=>\n      new_attrs = {}\n      for n,v of attrs\n        new_attrs[n] = v\n      new_sel = {\n        from: from\n        to: to\n        attrs: new_attrs\n      }\n      @_composition_value.push new_sel\n      new_sel\n\n    extendSelection = (selection)->\n      if delta.type is \"unselect\"\n        undo_attrs = {}\n        for n in delta.attrs\n          if selection.attrs[n]?\n            undo_attrs[n] = selection.attrs[n]\n          delete selection.attrs[n]\n        undos.push\n          from: delta.from\n          to: delta.to\n          attrs: undo_attrs\n          type: \"select\"\n      else\n        undo_attrs = {} # for undo selection (overwrite of existing selection)\n        undo_attrs_list = [] # for undo selection (not overwrite)\n        undo_need_unselect = false\n        undo_need_select = false\n        if delta.overwrite? and delta.overwrite\n          # overwrite everything that the delta doesn't expect\n          for n,v of selection.attrs\n            if not delta.attrs[n]?\n              undo_need_select = true\n              undo_attrs[n] = v\n              # must not delete attributes of $selection.attrs in this loop,\n              # so we do it in the next one\n          for n,v of undo_attrs\n            delete selection.attrs[n]\n\n        # apply the delta on the selection\n        for n,v of delta.attrs\n          if selection.attrs[n]?\n            undo_attrs[n] = selection.attrs[n]\n            undo_need_select = true\n          else\n            undo_attrs_list.push n\n            undo_need_unselect = true\n          selection.attrs[n] = v\n        if undo_need_select\n          undos.push\n            from: selection.from\n            to: selection.to\n            attrs: undo_attrs\n            type: \"select\"\n        if undo_need_unselect\n          undos.push\n            from: selection.from\n            to: selection.to\n            attrs: undo_attrs_list\n            type: \"unselect\"\n\n    # Algorithm overview:\n    # 1. cut off the selection that intersects with from\n    # 2. cut off the selection that intersects with to\n    # 3. extend / add selections inbetween\n    #\n    #### 1. cut off the selection that intersects with from\n    #\n    cut_off_from = ()->\n      # check if a selection (to the left of $from) intersects with $from\n      if from.selection? and from.selection.from is from\n        # does not intersect, because the start is already selected\n        return\n      # find first selection to the left\n      o = from.getPrev()\n      while (not o.selection?) and (o.type isnt \"Delimiter\")\n        o = o.getPrev()\n      if (not o.selection?) or o.selection.to is o\n        # no intersection\n        return\n      # We found a selection that intersects with $from.\n      # Now we have to check if it also intersects with $to.\n      # Then we cut it in such a way,\n      # that the selection does not intersect with $from and $to anymore.\n\n      # this is a reference for the selections that are created/modified:\n      # old_selection is outer (not between $from $to)\n      #   - will be changed in such a way that it is to the left of $from\n      # new_selection is inner (inbetween $from $to)\n      #   - created, right after $from\n      # opt_selection is outer (after $to)\n      #   - created (if necessary), right after $to\n      old_selection = o.selection\n\n      # check if found selection also intersects with $to\n      # * starting from $from, go to the right until you found either $to or old_selection.to\n      # ** if $to: no intersection with $to\n      # ** if $old_selection.to: intersection with $to!\n      o = from\n      while (o isnt old_selection.to) and (o isnt to)\n        o = o.getNext()\n\n      if o is old_selection.to\n        # no intersection with to!\n        # create $new_selection\n        new_selection = createSelection from, old_selection.to, old_selection.attrs\n\n        # update references\n        old_selection.to = from.getPrev()\n        # update references (pointers to respective selections)\n        old_selection.to.selection = old_selection\n\n        new_selection.from.selection = new_selection\n        new_selection.to.selection = new_selection\n      else\n        # there is an intersection with to!\n\n        # create $new_selection\n        new_selection = createSelection from, to, old_selection.attrs\n\n        # create $opt_selection\n        opt_selection = createSelection to.getNext(), old_selection.to, old_selection.attrs\n\n        # update references\n        old_selection.to = from.getPrev()\n        # update references (pointers to respective selections)\n        old_selection.to.selection = old_selection\n\n        opt_selection.from.selection = opt_selection\n        opt_selection.to.selection = opt_selection\n\n        new_selection.from.selection = new_selection\n        new_selection.to.selection = new_selection\n\n\n    cut_off_from()\n\n    # 2. cut off the selection that intersects with $to\n    cut_off_to = ()->\n      # check if a selection (to the left of $to) intersects with $to\n      if to.selection? and to.selection.to is to\n        # does not intersect, because the end is already selected\n        return\n      # find first selection to the left\n      o = to\n      while (not o.selection?) and (o isnt from)\n        o = o.getPrev()\n      if (not o.selection?) or o.selection[\"to\"] is o\n        # no intersection\n        return\n      # We found a selection that intersects with $to.\n      # Now we have to cut it in such a way,\n      # that the selection does not intersect with $to anymore.\n\n      # this is a reference for the selections that are created/modified:\n      # it is similar to the one above, except that we do not need opt_selection anymore!\n      # old_selection is inner (between $from and $to)\n      #   - will be changed in such a way that it is to the left of $to\n      # new_selection is outer ( outer $from and $to)\n      #   - created, right after $to\n      old_selection = o.selection\n\n      # create $new_selection\n      new_selection = createSelection to.getNext(), old_selection.to, old_selection.attrs\n\n      # update references\n      old_selection.to = to\n      # update references (pointers to respective selections)\n      old_selection.to.selection = old_selection\n\n      new_selection.from.selection = new_selection\n      new_selection.to.selection = new_selection\n\n    cut_off_to()\n\n    delta_has_attrs = false\n    for a of delta.attrs\n      delta_has_attrs = true\n      break\n    # 3. extend / add selections in between\n    o = from\n    to_next = to.getNext()\n    while (o isnt to_next)\n      if o.selection?\n        # just extend the existing selection\n        extendSelection o.selection, delta # will push undo-deltas to $undos\n        selection = o.selection\n        @_combine_selection_to_left selection\n\n        o = selection.to.getNext()\n        selection_is_empty = true\n        for attr of selection.attrs\n          selection_is_empty = false\n          break\n        if selection_is_empty\n          @_removeFromCompositionValue selection\n      else\n        # create a new selection (until you find the next one)\n        start = o\n        o_next = o.getNext()\n        while (not o_next.selection?) and (o isnt to)\n          o = o_next\n          o_next = o.getNext()\n        end = o\n        if delta.type isnt \"unselect\" and delta_has_attrs\n          attr_list = []\n          for n,v of delta.attrs\n            attr_list.push n\n          undos.push\n            from: start\n            to: end\n            attrs: attr_list\n            type: \"unselect\"\n          selection = createSelection start, end, delta.attrs\n          start.selection = selection\n          end.selection = selection\n          @_combine_selection_to_left o.selection\n        o = o.getNext()\n\n    if o.selection?\n      # and check if you can combine o.selection\n      @_combine_selection_to_left o.selection\n    # also re-connect from\n    if from.selection?\n      @_combine_selection_to_left from.selection\n\n    return undos # it is necessary that delta is returned in the way it was applied on the global delta.\n    # so that yjs knows exactly what was applied (and how to undo it).\n\n  _removeFromCompositionValue: (sel)->\n    @_composition_value = @_composition_value.filter (o)->\n      o isnt sel\n    delete sel.from.selection\n    delete sel.to.selection\n\n  # try to combine a selection, to the selection to its left (if there is any)\n  _combine_selection_to_left: (sel)->\n    first_o = sel.from.getPrev()\n    if not first_o.selection?\n      # there is no selection to the left\n      return\n    else\n      if compare_objects(first_o.selection.attrs, sel.attrs)\n        # we are going to remove the left selection\n        # First, remove every trace of first_o.selection (save what is necessary)\n        # Then, re-set sel.from\n        #\n        new_from = first_o.selection.from\n        @_removeFromCompositionValue first_o.selection\n\n        if sel.from isnt sel.to\n          delete sel.from.selection\n\n        sel.from = new_from\n        new_from.selection = sel\n      else\n        return\n\n  # \"undo\" a delta from the composition_value\n  _unapply: (deltas)->\n    # _apply returns a _list_ of deltas, that are neccessary to undo the change. Now we _apply every delta in the list (and discard the results)\n    for delta in deltas\n      @_apply delta\n    return\n\n  # update the globalDelta with delta\n\n\n  # select _from_, _to_ with an _attribute_\n  select: (from, to, attrs, overwrite)->\n    length = 0\n    for a of attrs\n      length++\n      break\n    if length <= 0 and not (overwrite? and overwrite)\n      return\n\n    delta_operations =\n      from: from\n      to: to\n\n    delta =\n      attrs: attrs\n      type: \"select\"\n\n    if overwrite? and overwrite\n      delta.overwrite = true\n\n    @_model.applyDelta(delta, delta_operations)\n\n  unselectAll: (from, to)->\n    select from, to, {}, true\n\n  # unselect _from_, _to_ with an _attribute_\n  unselect: (from, to, attrs)->\n    if typeof attrs is \"string\"\n      attrs = [attrs]\n    if attrs.constructor isnt Array\n      throw new Error \"Y.Selections.prototype.unselect expects an Array or String as the third parameter (attributes)!\"\n    if attrs.length <= 0\n      return\n    delta_operations =\n      from: from\n      to: to\n    delta =\n      attrs: attrs\n      type: \"unselect\"\n\n    @_model.applyDelta(delta, delta_operations)\n\n  # * get all the selections of a y-list\n  # * this will also test if the selections are well formed (after $from follows $to follows $from ..)\n  getSelections: (list)->\n    o = list.ref(0)\n    if not o?\n      return []\n\n    sel_start = null\n    pos = 0\n    result = []\n\n    while o.next_cl?\n      if o.isDeleted()\n        if o.selection?\n          console.log \"You forgot to delete the selection from this operation! Please write an issue how to reproduce this bug! (it could lead to inconsistencies!)\"\n        o = o.next_cl\n        continue\n      if o.selection?\n        if o.selection.from is o\n          if sel_start?\n            throw new Error \"Found two consecutive from elements. The selections are no longer safe to use! (contact the owner of the repository)\"\n          else\n            sel_start = pos\n        if o.selection.to is o\n          if sel_start?\n            number_of_attrs = 0\n            attrs = {}\n            for n,v of o.selection.attrs\n              attrs[n] = v\n            result.push\n              from: sel_start\n              to: pos\n              attrs: attrs\n            sel_start = null\n          else\n            throw new Error \"Found two consecutive to elements. The selections are no longer safe to use! (contact the owner of the repository)\"\n        else if o.selection.from isnt o\n          throw new Error \"This reference should not point to this selection, because the selection does not point to the reference. The selections are no longer safe to use! (contact the owner of the repository)\"\n      pos++\n      o = o.next_cl\n    return result\n\n  observe: (f)->\n    @_listeners.push f\n\n  unobserve: (f)->\n    @_listeners = @_listeners.filter (g)->\n      f != g\n\n\nif window?\n  if window.Y?\n    window.Y.Selections = YSelections\n  else\n    throw new Error \"You must first import Y!\"\n\nif module?\n  module.exports = YSelections\n","module.exports = require('./lib/chai');\n","/*!\n * chai\n * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nvar used = []\n  , exports = module.exports = {};\n\n/*!\n * Chai version\n */\n\nexports.version = '2.2.0';\n\n/*!\n * Assertion Error\n */\n\nexports.AssertionError = require('assertion-error');\n\n/*!\n * Utils for plugins (not exported)\n */\n\nvar util = require('./chai/utils');\n\n/**\n * # .use(function)\n *\n * Provides a way to extend the internals of Chai\n *\n * @param {Function}\n * @returns {this} for chaining\n * @api public\n */\n\nexports.use = function (fn) {\n  if (!~used.indexOf(fn)) {\n    fn(this, util);\n    used.push(fn);\n  }\n\n  return this;\n};\n\n/*!\n * Utility Functions\n */\n\nexports.util = util;\n\n/*!\n * Configuration\n */\n\nvar config = require('./chai/config');\nexports.config = config;\n\n/*!\n * Primary `Assertion` prototype\n */\n\nvar assertion = require('./chai/assertion');\nexports.use(assertion);\n\n/*!\n * Core Assertions\n */\n\nvar core = require('./chai/core/assertions');\nexports.use(core);\n\n/*!\n * Expect interface\n */\n\nvar expect = require('./chai/interface/expect');\nexports.use(expect);\n\n/*!\n * Should interface\n */\n\nvar should = require('./chai/interface/should');\nexports.use(should);\n\n/*!\n * Assert interface\n */\n\nvar assert = require('./chai/interface/assert');\nexports.use(assert);\n","/*!\n * chai\n * http://chaijs.com\n * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nvar config = require('./config');\n\nmodule.exports = function (_chai, util) {\n  /*!\n   * Module dependencies.\n   */\n\n  var AssertionError = _chai.AssertionError\n    , flag = util.flag;\n\n  /*!\n   * Module export.\n   */\n\n  _chai.Assertion = Assertion;\n\n  /*!\n   * Assertion Constructor\n   *\n   * Creates object for chaining.\n   *\n   * @api private\n   */\n\n  function Assertion (obj, msg, stack) {\n    flag(this, 'ssfi', stack || arguments.callee);\n    flag(this, 'object', obj);\n    flag(this, 'message', msg);\n  }\n\n  Object.defineProperty(Assertion, 'includeStack', {\n    get: function() {\n      console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.');\n      return config.includeStack;\n    },\n    set: function(value) {\n      console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.');\n      config.includeStack = value;\n    }\n  });\n\n  Object.defineProperty(Assertion, 'showDiff', {\n    get: function() {\n      console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.');\n      return config.showDiff;\n    },\n    set: function(value) {\n      console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.');\n      config.showDiff = value;\n    }\n  });\n\n  Assertion.addProperty = function (name, fn) {\n    util.addProperty(this.prototype, name, fn);\n  };\n\n  Assertion.addMethod = function (name, fn) {\n    util.addMethod(this.prototype, name, fn);\n  };\n\n  Assertion.addChainableMethod = function (name, fn, chainingBehavior) {\n    util.addChainableMethod(this.prototype, name, fn, chainingBehavior);\n  };\n\n  Assertion.overwriteProperty = function (name, fn) {\n    util.overwriteProperty(this.prototype, name, fn);\n  };\n\n  Assertion.overwriteMethod = function (name, fn) {\n    util.overwriteMethod(this.prototype, name, fn);\n  };\n\n  Assertion.overwriteChainableMethod = function (name, fn, chainingBehavior) {\n    util.overwriteChainableMethod(this.prototype, name, fn, chainingBehavior);\n  };\n\n  /*!\n   * ### .assert(expression, message, negateMessage, expected, actual)\n   *\n   * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass.\n   *\n   * @name assert\n   * @param {Philosophical} expression to be tested\n   * @param {String or Function} message or function that returns message to display if expression fails\n   * @param {String or Function} negatedMessage or function that returns negatedMessage to display if negated expression fails\n   * @param {Mixed} expected value (remember to check for negation)\n   * @param {Mixed} actual (optional) will default to `this.obj`\n   * @param {Boolean} showDiff (optional) when set to `true`, assert will display a diff in addition to the message if expression fails\n   * @api private\n   */\n\n  Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) {\n    var ok = util.test(this, arguments);\n    if (true !== showDiff) showDiff = false;\n    if (true !== config.showDiff) showDiff = false;\n\n    if (!ok) {\n      var msg = util.getMessage(this, arguments)\n        , actual = util.getActual(this, arguments);\n      throw new AssertionError(msg, {\n          actual: actual\n        , expected: expected\n        , showDiff: showDiff\n      }, (config.includeStack) ? this.assert : flag(this, 'ssfi'));\n    }\n  };\n\n  /*!\n   * ### ._obj\n   *\n   * Quick reference to stored `actual` value for plugin developers.\n   *\n   * @api private\n   */\n\n  Object.defineProperty(Assertion.prototype, '_obj',\n    { get: function () {\n        return flag(this, 'object');\n      }\n    , set: function (val) {\n        flag(this, 'object', val);\n      }\n  });\n};\n","module.exports = {\n\n  /**\n   * ### config.includeStack\n   *\n   * User configurable property, influences whether stack trace\n   * is included in Assertion error message. Default of false\n   * suppresses stack trace in the error message.\n   *\n   *     chai.config.includeStack = true;  // enable stack on error\n   *\n   * @param {Boolean}\n   * @api public\n   */\n\n   includeStack: false,\n\n  /**\n   * ### config.showDiff\n   *\n   * User configurable property, influences whether or not\n   * the `showDiff` flag should be included in the thrown\n   * AssertionErrors. `false` will always be `false`; `true`\n   * will be true when the assertion has requested a diff\n   * be shown.\n   *\n   * @param {Boolean}\n   * @api public\n   */\n\n  showDiff: true,\n\n  /**\n   * ### config.truncateThreshold\n   *\n   * User configurable property, sets length threshold for actual and\n   * expected values in assertion errors. If this threshold is exceeded, for\n   * example for large data structures, the value is replaced with something\n   * like `[ Array(3) ]` or `{ Object (prop1, prop2) }`.\n   *\n   * Set it to zero if you want to disable truncating altogether.\n   *\n   * This is especially userful when doing assertions on arrays: having this\n   * set to a reasonable large value makes the failure messages readily\n   * inspectable.\n   *\n   *     chai.config.truncateThreshold = 0;  // disable truncating\n   *\n   * @param {Number}\n   * @api public\n   */\n\n  truncateThreshold: 40\n\n};\n","/*!\n * chai\n * http://chaijs.com\n * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nmodule.exports = function (chai, _) {\n  var Assertion = chai.Assertion\n    , toString = Object.prototype.toString\n    , flag = _.flag;\n\n  /**\n   * ### Language Chains\n   *\n   * The following are provided as chainable getters to\n   * improve the readability of your assertions. They\n   * do not provide testing capabilities unless they\n   * have been overwritten by a plugin.\n   *\n   * **Chains**\n   *\n   * - to\n   * - be\n   * - been\n   * - is\n   * - that\n   * - which\n   * - and\n   * - has\n   * - have\n   * - with\n   * - at\n   * - of\n   * - same\n   *\n   * @name language chains\n   * @api public\n   */\n\n  [ 'to', 'be', 'been'\n  , 'is', 'and', 'has', 'have'\n  , 'with', 'that', 'which', 'at'\n  , 'of', 'same' ].forEach(function (chain) {\n    Assertion.addProperty(chain, function () {\n      return this;\n    });\n  });\n\n  /**\n   * ### .not\n   *\n   * Negates any of assertions following in the chain.\n   *\n   *     expect(foo).to.not.equal('bar');\n   *     expect(goodFn).to.not.throw(Error);\n   *     expect({ foo: 'baz' }).to.have.property('foo')\n   *       .and.not.equal('bar');\n   *\n   * @name not\n   * @api public\n   */\n\n  Assertion.addProperty('not', function () {\n    flag(this, 'negate', true);\n  });\n\n  /**\n   * ### .deep\n   *\n   * Sets the `deep` flag, later used by the `equal` and\n   * `property` assertions.\n   *\n   *     expect(foo).to.deep.equal({ bar: 'baz' });\n   *     expect({ foo: { bar: { baz: 'quux' } } })\n   *       .to.have.deep.property('foo.bar.baz', 'quux');\n   *\n   * `.deep.property` special characters can be escaped\n   * by adding two slashes before the `.` or `[]`.\n   *\n   *     var deepCss = { '.link': { '[target]': 42 }};\n   *     expect(deepCss).to.have.deep.property('\\\\.link.\\\\[target\\\\]', 42);\n   *\n   * @name deep\n   * @api public\n   */\n\n  Assertion.addProperty('deep', function () {\n    flag(this, 'deep', true);\n  });\n\n  /**\n   * ### .any\n   *\n   * Sets the `any` flag, (opposite of the `all` flag)\n   * later used in the `keys` assertion. \n   *\n   *     expect(foo).to.have.any.keys('bar', 'baz');\n   *\n   * @name any\n   * @api public\n   */\n\n  Assertion.addProperty('any', function () {\n    flag(this, 'any', true);\n    flag(this, 'all', false)\n  });\n\n\n  /**\n   * ### .all\n   *\n   * Sets the `all` flag (opposite of the `any` flag) \n   * later used by the `keys` assertion.\n   *\n   *     expect(foo).to.have.all.keys('bar', 'baz');\n   *\n   * @name all\n   * @api public\n   */\n\n  Assertion.addProperty('all', function () {\n    flag(this, 'all', true);\n    flag(this, 'any', false);\n  });\n\n  /**\n   * ### .a(type)\n   *\n   * The `a` and `an` assertions are aliases that can be\n   * used either as language chains or to assert a value's\n   * type.\n   *\n   *     // typeof\n   *     expect('test').to.be.a('string');\n   *     expect({ foo: 'bar' }).to.be.an('object');\n   *     expect(null).to.be.a('null');\n   *     expect(undefined).to.be.an('undefined');\n   *\n   *     // language chain\n   *     expect(foo).to.be.an.instanceof(Foo);\n   *\n   * @name a\n   * @alias an\n   * @param {String} type\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  function an (type, msg) {\n    if (msg) flag(this, 'message', msg);\n    type = type.toLowerCase();\n    var obj = flag(this, 'object')\n      , article = ~[ 'a', 'e', 'i', 'o', 'u' ].indexOf(type.charAt(0)) ? 'an ' : 'a ';\n\n    this.assert(\n        type === _.type(obj)\n      , 'expected #{this} to be ' + article + type\n      , 'expected #{this} not to be ' + article + type\n    );\n  }\n\n  Assertion.addChainableMethod('an', an);\n  Assertion.addChainableMethod('a', an);\n\n  /**\n   * ### .include(value)\n   *\n   * The `include` and `contain` assertions can be used as either property\n   * based language chains or as methods to assert the inclusion of an object\n   * in an array or a substring in a string. When used as language chains,\n   * they toggle the `contains` flag for the `keys` assertion.\n   *\n   *     expect([1,2,3]).to.include(2);\n   *     expect('foobar').to.contain('foo');\n   *     expect({ foo: 'bar', hello: 'universe' }).to.include.keys('foo');\n   *\n   * @name include\n   * @alias contain\n   * @alias includes\n   * @alias contains\n   * @param {Object|String|Number} obj\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  function includeChainingBehavior () {\n    flag(this, 'contains', true);\n  }\n\n  function include (val, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    var expected = false;\n    if (_.type(obj) === 'array' && _.type(val) === 'object') {\n      for (var i in obj) {\n        if (_.eql(obj[i], val)) {\n          expected = true;\n          break;\n        }\n      }\n    } else if (_.type(val) === 'object') {\n      if (!flag(this, 'negate')) {\n        for (var k in val) new Assertion(obj).property(k, val[k]);\n        return;\n      }\n      var subset = {};\n      for (var k in val) subset[k] = obj[k];\n      expected = _.eql(subset, val);\n    } else {\n      expected = obj && ~obj.indexOf(val);\n    }\n    this.assert(\n        expected\n      , 'expected #{this} to include ' + _.inspect(val)\n      , 'expected #{this} to not include ' + _.inspect(val));\n  }\n\n  Assertion.addChainableMethod('include', include, includeChainingBehavior);\n  Assertion.addChainableMethod('contain', include, includeChainingBehavior);\n  Assertion.addChainableMethod('contains', include, includeChainingBehavior);\n  Assertion.addChainableMethod('includes', include, includeChainingBehavior);\n\n  /**\n   * ### .ok\n   *\n   * Asserts that the target is truthy.\n   *\n   *     expect('everthing').to.be.ok;\n   *     expect(1).to.be.ok;\n   *     expect(false).to.not.be.ok;\n   *     expect(undefined).to.not.be.ok;\n   *     expect(null).to.not.be.ok;\n   *\n   * @name ok\n   * @api public\n   */\n\n  Assertion.addProperty('ok', function () {\n    this.assert(\n        flag(this, 'object')\n      , 'expected #{this} to be truthy'\n      , 'expected #{this} to be falsy');\n  });\n\n  /**\n   * ### .true\n   *\n   * Asserts that the target is `true`.\n   *\n   *     expect(true).to.be.true;\n   *     expect(1).to.not.be.true;\n   *\n   * @name true\n   * @api public\n   */\n\n  Assertion.addProperty('true', function () {\n    this.assert(\n        true === flag(this, 'object')\n      , 'expected #{this} to be true'\n      , 'expected #{this} to be false'\n      , this.negate ? false : true\n    );\n  });\n\n  /**\n   * ### .false\n   *\n   * Asserts that the target is `false`.\n   *\n   *     expect(false).to.be.false;\n   *     expect(0).to.not.be.false;\n   *\n   * @name false\n   * @api public\n   */\n\n  Assertion.addProperty('false', function () {\n    this.assert(\n        false === flag(this, 'object')\n      , 'expected #{this} to be false'\n      , 'expected #{this} to be true'\n      , this.negate ? true : false\n    );\n  });\n\n  /**\n   * ### .null\n   *\n   * Asserts that the target is `null`.\n   *\n   *     expect(null).to.be.null;\n   *     expect(undefined).not.to.be.null;\n   *\n   * @name null\n   * @api public\n   */\n\n  Assertion.addProperty('null', function () {\n    this.assert(\n        null === flag(this, 'object')\n      , 'expected #{this} to be null'\n      , 'expected #{this} not to be null'\n    );\n  });\n\n  /**\n   * ### .undefined\n   *\n   * Asserts that the target is `undefined`.\n   *\n   *     expect(undefined).to.be.undefined;\n   *     expect(null).to.not.be.undefined;\n   *\n   * @name undefined\n   * @api public\n   */\n\n  Assertion.addProperty('undefined', function () {\n    this.assert(\n        undefined === flag(this, 'object')\n      , 'expected #{this} to be undefined'\n      , 'expected #{this} not to be undefined'\n    );\n  });\n\n  /**\n   * ### .exist\n   *\n   * Asserts that the target is neither `null` nor `undefined`.\n   *\n   *     var foo = 'hi'\n   *       , bar = null\n   *       , baz;\n   *\n   *     expect(foo).to.exist;\n   *     expect(bar).to.not.exist;\n   *     expect(baz).to.not.exist;\n   *\n   * @name exist\n   * @api public\n   */\n\n  Assertion.addProperty('exist', function () {\n    this.assert(\n        null != flag(this, 'object')\n      , 'expected #{this} to exist'\n      , 'expected #{this} to not exist'\n    );\n  });\n\n\n  /**\n   * ### .empty\n   *\n   * Asserts that the target's length is `0`. For arrays and strings, it checks\n   * the `length` property. For objects, it gets the count of\n   * enumerable keys.\n   *\n   *     expect([]).to.be.empty;\n   *     expect('').to.be.empty;\n   *     expect({}).to.be.empty;\n   *\n   * @name empty\n   * @api public\n   */\n\n  Assertion.addProperty('empty', function () {\n    var obj = flag(this, 'object')\n      , expected = obj;\n\n    if (Array.isArray(obj) || 'string' === typeof object) {\n      expected = obj.length;\n    } else if (typeof obj === 'object') {\n      expected = Object.keys(obj).length;\n    }\n\n    this.assert(\n        !expected\n      , 'expected #{this} to be empty'\n      , 'expected #{this} not to be empty'\n    );\n  });\n\n  /**\n   * ### .arguments\n   *\n   * Asserts that the target is an arguments object.\n   *\n   *     function test () {\n   *       expect(arguments).to.be.arguments;\n   *     }\n   *\n   * @name arguments\n   * @alias Arguments\n   * @api public\n   */\n\n  function checkArguments () {\n    var obj = flag(this, 'object')\n      , type = Object.prototype.toString.call(obj);\n    this.assert(\n        '[object Arguments]' === type\n      , 'expected #{this} to be arguments but got ' + type\n      , 'expected #{this} to not be arguments'\n    );\n  }\n\n  Assertion.addProperty('arguments', checkArguments);\n  Assertion.addProperty('Arguments', checkArguments);\n\n  /**\n   * ### .equal(value)\n   *\n   * Asserts that the target is strictly equal (`===`) to `value`.\n   * Alternately, if the `deep` flag is set, asserts that\n   * the target is deeply equal to `value`.\n   *\n   *     expect('hello').to.equal('hello');\n   *     expect(42).to.equal(42);\n   *     expect(1).to.not.equal(true);\n   *     expect({ foo: 'bar' }).to.not.equal({ foo: 'bar' });\n   *     expect({ foo: 'bar' }).to.deep.equal({ foo: 'bar' });\n   *\n   * @name equal\n   * @alias equals\n   * @alias eq\n   * @alias deep.equal\n   * @param {Mixed} value\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  function assertEqual (val, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    if (flag(this, 'deep')) {\n      return this.eql(val);\n    } else {\n      this.assert(\n          val === obj\n        , 'expected #{this} to equal #{exp}'\n        , 'expected #{this} to not equal #{exp}'\n        , val\n        , this._obj\n        , true\n      );\n    }\n  }\n\n  Assertion.addMethod('equal', assertEqual);\n  Assertion.addMethod('equals', assertEqual);\n  Assertion.addMethod('eq', assertEqual);\n\n  /**\n   * ### .eql(value)\n   *\n   * Asserts that the target is deeply equal to `value`.\n   *\n   *     expect({ foo: 'bar' }).to.eql({ foo: 'bar' });\n   *     expect([ 1, 2, 3 ]).to.eql([ 1, 2, 3 ]);\n   *\n   * @name eql\n   * @alias eqls\n   * @param {Mixed} value\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  function assertEql(obj, msg) {\n    if (msg) flag(this, 'message', msg);\n    this.assert(\n        _.eql(obj, flag(this, 'object'))\n      , 'expected #{this} to deeply equal #{exp}'\n      , 'expected #{this} to not deeply equal #{exp}'\n      , obj\n      , this._obj\n      , true\n    );\n  }\n\n  Assertion.addMethod('eql', assertEql);\n  Assertion.addMethod('eqls', assertEql);\n\n  /**\n   * ### .above(value)\n   *\n   * Asserts that the target is greater than `value`.\n   *\n   *     expect(10).to.be.above(5);\n   *\n   * Can also be used in conjunction with `length` to\n   * assert a minimum length. The benefit being a\n   * more informative error message than if the length\n   * was supplied directly.\n   *\n   *     expect('foo').to.have.length.above(2);\n   *     expect([ 1, 2, 3 ]).to.have.length.above(2);\n   *\n   * @name above\n   * @alias gt\n   * @alias greaterThan\n   * @param {Number} value\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  function assertAbove (n, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    if (flag(this, 'doLength')) {\n      new Assertion(obj, msg).to.have.property('length');\n      var len = obj.length;\n      this.assert(\n          len > n\n        , 'expected #{this} to have a length above #{exp} but got #{act}'\n        , 'expected #{this} to not have a length above #{exp}'\n        , n\n        , len\n      );\n    } else {\n      this.assert(\n          obj > n\n        , 'expected #{this} to be above ' + n\n        , 'expected #{this} to be at most ' + n\n      );\n    }\n  }\n\n  Assertion.addMethod('above', assertAbove);\n  Assertion.addMethod('gt', assertAbove);\n  Assertion.addMethod('greaterThan', assertAbove);\n\n  /**\n   * ### .least(value)\n   *\n   * Asserts that the target is greater than or equal to `value`.\n   *\n   *     expect(10).to.be.at.least(10);\n   *\n   * Can also be used in conjunction with `length` to\n   * assert a minimum length. The benefit being a\n   * more informative error message than if the length\n   * was supplied directly.\n   *\n   *     expect('foo').to.have.length.of.at.least(2);\n   *     expect([ 1, 2, 3 ]).to.have.length.of.at.least(3);\n   *\n   * @name least\n   * @alias gte\n   * @param {Number} value\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  function assertLeast (n, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    if (flag(this, 'doLength')) {\n      new Assertion(obj, msg).to.have.property('length');\n      var len = obj.length;\n      this.assert(\n          len >= n\n        , 'expected #{this} to have a length at least #{exp} but got #{act}'\n        , 'expected #{this} to have a length below #{exp}'\n        , n\n        , len\n      );\n    } else {\n      this.assert(\n          obj >= n\n        , 'expected #{this} to be at least ' + n\n        , 'expected #{this} to be below ' + n\n      );\n    }\n  }\n\n  Assertion.addMethod('least', assertLeast);\n  Assertion.addMethod('gte', assertLeast);\n\n  /**\n   * ### .below(value)\n   *\n   * Asserts that the target is less than `value`.\n   *\n   *     expect(5).to.be.below(10);\n   *\n   * Can also be used in conjunction with `length` to\n   * assert a maximum length. The benefit being a\n   * more informative error message than if the length\n   * was supplied directly.\n   *\n   *     expect('foo').to.have.length.below(4);\n   *     expect([ 1, 2, 3 ]).to.have.length.below(4);\n   *\n   * @name below\n   * @alias lt\n   * @alias lessThan\n   * @param {Number} value\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  function assertBelow (n, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    if (flag(this, 'doLength')) {\n      new Assertion(obj, msg).to.have.property('length');\n      var len = obj.length;\n      this.assert(\n          len < n\n        , 'expected #{this} to have a length below #{exp} but got #{act}'\n        , 'expected #{this} to not have a length below #{exp}'\n        , n\n        , len\n      );\n    } else {\n      this.assert(\n          obj < n\n        , 'expected #{this} to be below ' + n\n        , 'expected #{this} to be at least ' + n\n      );\n    }\n  }\n\n  Assertion.addMethod('below', assertBelow);\n  Assertion.addMethod('lt', assertBelow);\n  Assertion.addMethod('lessThan', assertBelow);\n\n  /**\n   * ### .most(value)\n   *\n   * Asserts that the target is less than or equal to `value`.\n   *\n   *     expect(5).to.be.at.most(5);\n   *\n   * Can also be used in conjunction with `length` to\n   * assert a maximum length. The benefit being a\n   * more informative error message than if the length\n   * was supplied directly.\n   *\n   *     expect('foo').to.have.length.of.at.most(4);\n   *     expect([ 1, 2, 3 ]).to.have.length.of.at.most(3);\n   *\n   * @name most\n   * @alias lte\n   * @param {Number} value\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  function assertMost (n, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    if (flag(this, 'doLength')) {\n      new Assertion(obj, msg).to.have.property('length');\n      var len = obj.length;\n      this.assert(\n          len <= n\n        , 'expected #{this} to have a length at most #{exp} but got #{act}'\n        , 'expected #{this} to have a length above #{exp}'\n        , n\n        , len\n      );\n    } else {\n      this.assert(\n          obj <= n\n        , 'expected #{this} to be at most ' + n\n        , 'expected #{this} to be above ' + n\n      );\n    }\n  }\n\n  Assertion.addMethod('most', assertMost);\n  Assertion.addMethod('lte', assertMost);\n\n  /**\n   * ### .within(start, finish)\n   *\n   * Asserts that the target is within a range.\n   *\n   *     expect(7).to.be.within(5,10);\n   *\n   * Can also be used in conjunction with `length` to\n   * assert a length range. The benefit being a\n   * more informative error message than if the length\n   * was supplied directly.\n   *\n   *     expect('foo').to.have.length.within(2,4);\n   *     expect([ 1, 2, 3 ]).to.have.length.within(2,4);\n   *\n   * @name within\n   * @param {Number} start lowerbound inclusive\n   * @param {Number} finish upperbound inclusive\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  Assertion.addMethod('within', function (start, finish, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object')\n      , range = start + '..' + finish;\n    if (flag(this, 'doLength')) {\n      new Assertion(obj, msg).to.have.property('length');\n      var len = obj.length;\n      this.assert(\n          len >= start && len <= finish\n        , 'expected #{this} to have a length within ' + range\n        , 'expected #{this} to not have a length within ' + range\n      );\n    } else {\n      this.assert(\n          obj >= start && obj <= finish\n        , 'expected #{this} to be within ' + range\n        , 'expected #{this} to not be within ' + range\n      );\n    }\n  });\n\n  /**\n   * ### .instanceof(constructor)\n   *\n   * Asserts that the target is an instance of `constructor`.\n   *\n   *     var Tea = function (name) { this.name = name; }\n   *       , Chai = new Tea('chai');\n   *\n   *     expect(Chai).to.be.an.instanceof(Tea);\n   *     expect([ 1, 2, 3 ]).to.be.instanceof(Array);\n   *\n   * @name instanceof\n   * @param {Constructor} constructor\n   * @param {String} message _optional_\n   * @alias instanceOf\n   * @api public\n   */\n\n  function assertInstanceOf (constructor, msg) {\n    if (msg) flag(this, 'message', msg);\n    var name = _.getName(constructor);\n    this.assert(\n        flag(this, 'object') instanceof constructor\n      , 'expected #{this} to be an instance of ' + name\n      , 'expected #{this} to not be an instance of ' + name\n    );\n  };\n\n  Assertion.addMethod('instanceof', assertInstanceOf);\n  Assertion.addMethod('instanceOf', assertInstanceOf);\n\n  /**\n   * ### .property(name, [value])\n   *\n   * Asserts that the target has a property `name`, optionally asserting that\n   * the value of that property is strictly equal to  `value`.\n   * If the `deep` flag is set, you can use dot- and bracket-notation for deep\n   * references into objects and arrays.\n   *\n   *     // simple referencing\n   *     var obj = { foo: 'bar' };\n   *     expect(obj).to.have.property('foo');\n   *     expect(obj).to.have.property('foo', 'bar');\n   *\n   *     // deep referencing\n   *     var deepObj = {\n   *         green: { tea: 'matcha' }\n   *       , teas: [ 'chai', 'matcha', { tea: 'konacha' } ]\n   *     };\n   * \n   *     expect(deepObj).to.have.deep.property('green.tea', 'matcha');\n   *     expect(deepObj).to.have.deep.property('teas[1]', 'matcha');\n   *     expect(deepObj).to.have.deep.property('teas[2].tea', 'konacha');\n   *\n   * You can also use an array as the starting point of a `deep.property`\n   * assertion, or traverse nested arrays.\n   *\n   *     var arr = [\n   *         [ 'chai', 'matcha', 'konacha' ]\n   *       , [ { tea: 'chai' }\n   *         , { tea: 'matcha' }\n   *         , { tea: 'konacha' } ]\n   *     ];\n   *\n   *     expect(arr).to.have.deep.property('[0][1]', 'matcha');\n   *     expect(arr).to.have.deep.property('[1][2].tea', 'konacha');\n   *\n   * Furthermore, `property` changes the subject of the assertion\n   * to be the value of that property from the original object. This\n   * permits for further chainable assertions on that property.\n   *\n   *     expect(obj).to.have.property('foo')\n   *       .that.is.a('string');\n   *     expect(deepObj).to.have.property('green')\n   *       .that.is.an('object')\n   *       .that.deep.equals({ tea: 'matcha' });\n   *     expect(deepObj).to.have.property('teas')\n   *       .that.is.an('array')\n   *       .with.deep.property('[2]')\n   *         .that.deep.equals({ tea: 'konacha' });\n   *\n   * Note that dots and bracket in `name` must be backslash-escaped when\n   * the `deep` flag is set, while they must NOT be escaped when the `deep`\n   * flag is not set.\n   *\n   *     // simple referencing\n   *     var css = { '.link[target]': 42 };\n   *     expect(css).to.have.property('.link[target]', 42);\n   *\n   *     // deep referencing\n   *     var deepCss = { '.link': { '[target]': 42 }};\n   *     expect(deepCss).to.have.deep.property('\\\\.link.\\\\[target\\\\]', 42);\n   *\n   * @name property\n   * @alias deep.property\n   * @param {String} name\n   * @param {Mixed} value (optional)\n   * @param {String} message _optional_\n   * @returns value of property for chaining\n   * @api public\n   */\n\n  Assertion.addMethod('property', function (name, val, msg) {\n    if (msg) flag(this, 'message', msg);\n\n    var isDeep = !!flag(this, 'deep')\n      , descriptor = isDeep ? 'deep property ' : 'property '\n      , negate = flag(this, 'negate')\n      , obj = flag(this, 'object')\n      , pathInfo = isDeep ? _.getPathInfo(name, obj) : null\n      , hasProperty = isDeep\n        ? pathInfo.exists\n        : _.hasProperty(name, obj)\n      , value = isDeep\n        ? pathInfo.value\n        : obj[name];\n\n    if (negate && undefined !== val) {\n      if (undefined === value) {\n        msg = (msg != null) ? msg + ': ' : '';\n        throw new Error(msg + _.inspect(obj) + ' has no ' + descriptor + _.inspect(name));\n      }\n    } else {\n      this.assert(\n          hasProperty\n        , 'expected #{this} to have a ' + descriptor + _.inspect(name)\n        , 'expected #{this} to not have ' + descriptor + _.inspect(name));\n    }\n\n    if (undefined !== val) {\n      this.assert(\n          val === value\n        , 'expected #{this} to have a ' + descriptor + _.inspect(name) + ' of #{exp}, but got #{act}'\n        , 'expected #{this} to not have a ' + descriptor + _.inspect(name) + ' of #{act}'\n        , val\n        , value\n      );\n    }\n\n    flag(this, 'object', value);\n  });\n\n\n  /**\n   * ### .ownProperty(name)\n   *\n   * Asserts that the target has an own property `name`.\n   *\n   *     expect('test').to.have.ownProperty('length');\n   *\n   * @name ownProperty\n   * @alias haveOwnProperty\n   * @param {String} name\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  function assertOwnProperty (name, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    this.assert(\n        obj.hasOwnProperty(name)\n      , 'expected #{this} to have own property ' + _.inspect(name)\n      , 'expected #{this} to not have own property ' + _.inspect(name)\n    );\n  }\n\n  Assertion.addMethod('ownProperty', assertOwnProperty);\n  Assertion.addMethod('haveOwnProperty', assertOwnProperty);\n\n  /**\n   * ### .length(value)\n   *\n   * Asserts that the target's `length` property has\n   * the expected value.\n   *\n   *     expect([ 1, 2, 3]).to.have.length(3);\n   *     expect('foobar').to.have.length(6);\n   *\n   * Can also be used as a chain precursor to a value\n   * comparison for the length property.\n   *\n   *     expect('foo').to.have.length.above(2);\n   *     expect([ 1, 2, 3 ]).to.have.length.above(2);\n   *     expect('foo').to.have.length.below(4);\n   *     expect([ 1, 2, 3 ]).to.have.length.below(4);\n   *     expect('foo').to.have.length.within(2,4);\n   *     expect([ 1, 2, 3 ]).to.have.length.within(2,4);\n   *\n   * @name length\n   * @alias lengthOf\n   * @param {Number} length\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  function assertLengthChain () {\n    flag(this, 'doLength', true);\n  }\n\n  function assertLength (n, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    new Assertion(obj, msg).to.have.property('length');\n    var len = obj.length;\n\n    this.assert(\n        len == n\n      , 'expected #{this} to have a length of #{exp} but got #{act}'\n      , 'expected #{this} to not have a length of #{act}'\n      , n\n      , len\n    );\n  }\n\n  Assertion.addChainableMethod('length', assertLength, assertLengthChain);\n  Assertion.addMethod('lengthOf', assertLength);\n\n  /**\n   * ### .match(regexp)\n   *\n   * Asserts that the target matches a regular expression.\n   *\n   *     expect('foobar').to.match(/^foo/);\n   *\n   * @name match\n   * @param {RegExp} RegularExpression\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  Assertion.addMethod('match', function (re, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    this.assert(\n        re.exec(obj)\n      , 'expected #{this} to match ' + re\n      , 'expected #{this} not to match ' + re\n    );\n  });\n\n  /**\n   * ### .string(string)\n   *\n   * Asserts that the string target contains another string.\n   *\n   *     expect('foobar').to.have.string('bar');\n   *\n   * @name string\n   * @param {String} string\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  Assertion.addMethod('string', function (str, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    new Assertion(obj, msg).is.a('string');\n\n    this.assert(\n        ~obj.indexOf(str)\n      , 'expected #{this} to contain ' + _.inspect(str)\n      , 'expected #{this} to not contain ' + _.inspect(str)\n    );\n  });\n\n\n  /**\n   * ### .keys(key1, [key2], [...])\n   *\n   * Asserts that the target contains any or all of the passed-in keys.\n   * Use in combination with `any`, `all`, `contains`, or `have` will affect \n   * what will pass.\n   * \n   * When used in conjunction with `any`, at least one key that is passed \n   * in must exist in the target object. This is regardless whether or not \n   * the `have` or `contain` qualifiers are used. Note, either `any` or `all`\n   * should be used in the assertion. If neither are used, the assertion is\n   * defaulted to `all`.\n   * \n   * When both `all` and `contain` are used, the target object must have at \n   * least all of the passed-in keys but may have more keys not listed.\n   * \n   * When both `all` and `have` are used, the target object must both contain\n   * all of the passed-in keys AND the number of keys in the target object must\n   * match the number of keys passed in (in other words, a target object must \n   * have all and only all of the passed-in keys).\n   * \n   *     expect({ foo: 1, bar: 2 }).to.have.any.keys('foo', 'baz');\n   *     expect({ foo: 1, bar: 2 }).to.have.any.keys('foo');\n   *     expect({ foo: 1, bar: 2 }).to.contain.any.keys('bar', 'baz');\n   *     expect({ foo: 1, bar: 2 }).to.contain.any.keys(['foo']);\n   *     expect({ foo: 1, bar: 2 }).to.contain.any.keys({'foo': 6});\n   *     expect({ foo: 1, bar: 2 }).to.have.all.keys(['bar', 'foo']);\n   *     expect({ foo: 1, bar: 2 }).to.have.all.keys({'bar': 6, 'foo', 7});\n   *     expect({ foo: 1, bar: 2, baz: 3 }).to.contain.all.keys(['bar', 'foo']);\n   *     expect({ foo: 1, bar: 2, baz: 3 }).to.contain.all.keys([{'bar': 6}}]);\n   *\n   *\n   * @name keys\n   * @alias key\n   * @param {String...|Array|Object} keys\n   * @api public\n   */\n\n  function assertKeys (keys) {\n    var obj = flag(this, 'object')\n      , str\n      , ok = true\n      , mixedArgsMsg = 'keys must be given single argument of Array|Object|String, or multiple String arguments';\n\n    switch (_.type(keys)) {\n      case \"array\":\n        if (arguments.length > 1) throw (new Error(mixedArgsMsg));\n        break;\n      case \"object\":\n        if (arguments.length > 1) throw (new Error(mixedArgsMsg));\n        keys = Object.keys(keys);\n        break;\n      default:\n        keys = Array.prototype.slice.call(arguments);\n    }\n\n    if (!keys.length) throw new Error('keys required');\n\n    var actual = Object.keys(obj)\n      , expected = keys\n      , len = keys.length\n      , any = flag(this, 'any')\n      , all = flag(this, 'all');\n\n    if (!any && !all) {\n      all = true;\n    }\n\n    // Has any\n    if (any) {\n      var intersection = expected.filter(function(key) {\n        return ~actual.indexOf(key);\n      });\n      ok = intersection.length > 0;\n    }\n\n    // Has all\n    if (all) {\n      ok = keys.every(function(key){\n        return ~actual.indexOf(key);\n      });\n      if (!flag(this, 'negate') && !flag(this, 'contains')) {\n        ok = ok && keys.length == actual.length;\n      }\n    }\n\n    // Key string\n    if (len > 1) {\n      keys = keys.map(function(key){\n        return _.inspect(key);\n      });\n      var last = keys.pop();\n      if (all) {\n        str = keys.join(', ') + ', and ' + last;\n      }\n      if (any) {\n        str = keys.join(', ') + ', or ' + last;\n      }\n    } else {\n      str = _.inspect(keys[0]);\n    }\n\n    // Form\n    str = (len > 1 ? 'keys ' : 'key ') + str;\n\n    // Have / include\n    str = (flag(this, 'contains') ? 'contain ' : 'have ') + str;\n\n    // Assertion\n    this.assert(\n        ok\n      , 'expected #{this} to ' + str\n      , 'expected #{this} to not ' + str\n      , expected.slice(0).sort()\n      , actual.sort()\n      , true\n    );\n  }\n\n  Assertion.addMethod('keys', assertKeys);\n  Assertion.addMethod('key', assertKeys);\n\n  /**\n   * ### .throw(constructor)\n   *\n   * Asserts that the function target will throw a specific error, or specific type of error\n   * (as determined using `instanceof`), optionally with a RegExp or string inclusion test\n   * for the error's message.\n   *\n   *     var err = new ReferenceError('This is a bad function.');\n   *     var fn = function () { throw err; }\n   *     expect(fn).to.throw(ReferenceError);\n   *     expect(fn).to.throw(Error);\n   *     expect(fn).to.throw(/bad function/);\n   *     expect(fn).to.not.throw('good function');\n   *     expect(fn).to.throw(ReferenceError, /bad function/);\n   *     expect(fn).to.throw(err);\n   *     expect(fn).to.not.throw(new RangeError('Out of range.'));\n   *\n   * Please note that when a throw expectation is negated, it will check each\n   * parameter independently, starting with error constructor type. The appropriate way\n   * to check for the existence of a type of error but for a message that does not match\n   * is to use `and`.\n   *\n   *     expect(fn).to.throw(ReferenceError)\n   *        .and.not.throw(/good function/);\n   *\n   * @name throw\n   * @alias throws\n   * @alias Throw\n   * @param {ErrorConstructor} constructor\n   * @param {String|RegExp} expected error message\n   * @param {String} message _optional_\n   * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types\n   * @returns error for chaining (null if no error)\n   * @api public\n   */\n\n  function assertThrows (constructor, errMsg, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    new Assertion(obj, msg).is.a('function');\n\n    var thrown = false\n      , desiredError = null\n      , name = null\n      , thrownError = null;\n\n    if (arguments.length === 0) {\n      errMsg = null;\n      constructor = null;\n    } else if (constructor && (constructor instanceof RegExp || 'string' === typeof constructor)) {\n      errMsg = constructor;\n      constructor = null;\n    } else if (constructor && constructor instanceof Error) {\n      desiredError = constructor;\n      constructor = null;\n      errMsg = null;\n    } else if (typeof constructor === 'function') {\n      name = constructor.prototype.name || constructor.name;\n      if (name === 'Error' && constructor !== Error) {\n        name = (new constructor()).name;\n      }\n    } else {\n      constructor = null;\n    }\n\n    try {\n      obj();\n    } catch (err) {\n      // first, check desired error\n      if (desiredError) {\n        this.assert(\n            err === desiredError\n          , 'expected #{this} to throw #{exp} but #{act} was thrown'\n          , 'expected #{this} to not throw #{exp}'\n          , (desiredError instanceof Error ? desiredError.toString() : desiredError)\n          , (err instanceof Error ? err.toString() : err)\n        );\n\n        flag(this, 'object', err);\n        return this;\n      }\n\n      // next, check constructor\n      if (constructor) {\n        this.assert(\n            err instanceof constructor\n          , 'expected #{this} to throw #{exp} but #{act} was thrown'\n          , 'expected #{this} to not throw #{exp} but #{act} was thrown'\n          , name\n          , (err instanceof Error ? err.toString() : err)\n        );\n\n        if (!errMsg) {\n          flag(this, 'object', err);\n          return this;\n        }\n      }\n\n      // next, check message\n      var message = 'object' === _.type(err) && \"message\" in err\n        ? err.message\n        : '' + err;\n\n      if ((message != null) && errMsg && errMsg instanceof RegExp) {\n        this.assert(\n            errMsg.exec(message)\n          , 'expected #{this} to throw error matching #{exp} but got #{act}'\n          , 'expected #{this} to throw error not matching #{exp}'\n          , errMsg\n          , message\n        );\n\n        flag(this, 'object', err);\n        return this;\n      } else if ((message != null) && errMsg && 'string' === typeof errMsg) {\n        this.assert(\n            ~message.indexOf(errMsg)\n          , 'expected #{this} to throw error including #{exp} but got #{act}'\n          , 'expected #{this} to throw error not including #{act}'\n          , errMsg\n          , message\n        );\n\n        flag(this, 'object', err);\n        return this;\n      } else {\n        thrown = true;\n        thrownError = err;\n      }\n    }\n\n    var actuallyGot = ''\n      , expectedThrown = name !== null\n        ? name\n        : desiredError\n          ? '#{exp}' //_.inspect(desiredError)\n          : 'an error';\n\n    if (thrown) {\n      actuallyGot = ' but #{act} was thrown'\n    }\n\n    this.assert(\n        thrown === true\n      , 'expected #{this} to throw ' + expectedThrown + actuallyGot\n      , 'expected #{this} to not throw ' + expectedThrown + actuallyGot\n      , (desiredError instanceof Error ? desiredError.toString() : desiredError)\n      , (thrownError instanceof Error ? thrownError.toString() : thrownError)\n    );\n\n    flag(this, 'object', thrownError);\n  };\n\n  Assertion.addMethod('throw', assertThrows);\n  Assertion.addMethod('throws', assertThrows);\n  Assertion.addMethod('Throw', assertThrows);\n\n  /**\n   * ### .respondTo(method)\n   *\n   * Asserts that the object or class target will respond to a method.\n   *\n   *     Klass.prototype.bar = function(){};\n   *     expect(Klass).to.respondTo('bar');\n   *     expect(obj).to.respondTo('bar');\n   *\n   * To check if a constructor will respond to a static function,\n   * set the `itself` flag.\n   *\n   *     Klass.baz = function(){};\n   *     expect(Klass).itself.to.respondTo('baz');\n   *\n   * @name respondTo\n   * @param {String} method\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  Assertion.addMethod('respondTo', function (method, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object')\n      , itself = flag(this, 'itself')\n      , context = ('function' === _.type(obj) && !itself)\n        ? obj.prototype[method]\n        : obj[method];\n\n    this.assert(\n        'function' === typeof context\n      , 'expected #{this} to respond to ' + _.inspect(method)\n      , 'expected #{this} to not respond to ' + _.inspect(method)\n    );\n  });\n\n  /**\n   * ### .itself\n   *\n   * Sets the `itself` flag, later used by the `respondTo` assertion.\n   *\n   *     function Foo() {}\n   *     Foo.bar = function() {}\n   *     Foo.prototype.baz = function() {}\n   *\n   *     expect(Foo).itself.to.respondTo('bar');\n   *     expect(Foo).itself.not.to.respondTo('baz');\n   *\n   * @name itself\n   * @api public\n   */\n\n  Assertion.addProperty('itself', function () {\n    flag(this, 'itself', true);\n  });\n\n  /**\n   * ### .satisfy(method)\n   *\n   * Asserts that the target passes a given truth test.\n   *\n   *     expect(1).to.satisfy(function(num) { return num > 0; });\n   *\n   * @name satisfy\n   * @param {Function} matcher\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  Assertion.addMethod('satisfy', function (matcher, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n    var result = matcher(obj);\n    this.assert(\n        result\n      , 'expected #{this} to satisfy ' + _.objDisplay(matcher)\n      , 'expected #{this} to not satisfy' + _.objDisplay(matcher)\n      , this.negate ? false : true\n      , result\n    );\n  });\n\n  /**\n   * ### .closeTo(expected, delta)\n   *\n   * Asserts that the target is equal `expected`, to within a +/- `delta` range.\n   *\n   *     expect(1.5).to.be.closeTo(1, 0.5);\n   *\n   * @name closeTo\n   * @param {Number} expected\n   * @param {Number} delta\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  Assertion.addMethod('closeTo', function (expected, delta, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n\n    new Assertion(obj, msg).is.a('number');\n    if (_.type(expected) !== 'number' || _.type(delta) !== 'number') {\n      throw new Error('the arguments to closeTo must be numbers');\n    }\n\n    this.assert(\n        Math.abs(obj - expected) <= delta\n      , 'expected #{this} to be close to ' + expected + ' +/- ' + delta\n      , 'expected #{this} not to be close to ' + expected + ' +/- ' + delta\n    );\n  });\n\n  function isSubsetOf(subset, superset, cmp) {\n    return subset.every(function(elem) {\n      if (!cmp) return superset.indexOf(elem) !== -1;\n\n      return superset.some(function(elem2) {\n        return cmp(elem, elem2);\n      });\n    })\n  }\n\n  /**\n   * ### .members(set)\n   *\n   * Asserts that the target is a superset of `set`,\n   * or that the target and `set` have the same strictly-equal (===) members.\n   * Alternately, if the `deep` flag is set, set members are compared for deep\n   * equality.\n   *\n   *     expect([1, 2, 3]).to.include.members([3, 2]);\n   *     expect([1, 2, 3]).to.not.include.members([3, 2, 8]);\n   *\n   *     expect([4, 2]).to.have.members([2, 4]);\n   *     expect([5, 2]).to.not.have.members([5, 2, 1]);\n   *\n   *     expect([{ id: 1 }]).to.deep.include.members([{ id: 1 }]);\n   *\n   * @name members\n   * @param {Array} set\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  Assertion.addMethod('members', function (subset, msg) {\n    if (msg) flag(this, 'message', msg);\n    var obj = flag(this, 'object');\n\n    new Assertion(obj).to.be.an('array');\n    new Assertion(subset).to.be.an('array');\n\n    var cmp = flag(this, 'deep') ? _.eql : undefined;\n\n    if (flag(this, 'contains')) {\n      return this.assert(\n          isSubsetOf(subset, obj, cmp)\n        , 'expected #{this} to be a superset of #{act}'\n        , 'expected #{this} to not be a superset of #{act}'\n        , obj\n        , subset\n      );\n    }\n\n    this.assert(\n        isSubsetOf(obj, subset, cmp) && isSubsetOf(subset, obj, cmp)\n        , 'expected #{this} to have the same members as #{act}'\n        , 'expected #{this} to not have the same members as #{act}'\n        , obj\n        , subset\n    );\n  });\n\n  /**\n   * ### .change(function)\n   *\n   * Asserts that a function changes an object property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val += 3 };\n   *     var noChangeFn = function() { return 'foo' + 'bar'; }\n   *     expect(fn).to.change(obj, 'val');\n   *     expect(noChangFn).to.not.change(obj, 'val')\n   *\n   * @name change\n   * @alias changes\n   * @alias Change\n   * @param {String} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  function assertChanges (object, prop, msg) {\n    if (msg) flag(this, 'message', msg);\n    var fn = flag(this, 'object');\n    new Assertion(object, msg).to.have.property(prop);\n    new Assertion(fn).is.a('function');\n\n    var initial = object[prop];\n    fn();\n\n    this.assert(\n      initial !== object[prop]\n      , 'expected .' + prop + ' to change'\n      , 'expected .' + prop + ' to not change'\n    );\n  }\n\n  Assertion.addChainableMethod('change', assertChanges);\n  Assertion.addChainableMethod('changes', assertChanges);\n\n  /**\n   * ### .increase(function)\n   *\n   * Asserts that a function increases an object property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 15 };\n   *     expect(fn).to.increase(obj, 'val');\n   *\n   * @name increase\n   * @alias increases\n   * @alias Increase\n   * @param {String} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  function assertIncreases (object, prop, msg) {\n    if (msg) flag(this, 'message', msg);\n    var fn = flag(this, 'object');\n    new Assertion(object, msg).to.have.property(prop);\n    new Assertion(fn).is.a('function');\n\n    var initial = object[prop];\n    fn();\n\n    this.assert(\n      object[prop] - initial > 0\n      , 'expected .' + prop + ' to increase'\n      , 'expected .' + prop + ' to not increase'\n    );\n  }\n\n  Assertion.addChainableMethod('increase', assertIncreases);\n  Assertion.addChainableMethod('increases', assertIncreases);\n\n  /**\n   * ### .decrease(function)\n   *\n   * Asserts that a function decreases an object property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 5 };\n   *     expect(fn).to.decrease(obj, 'val');\n   *\n   * @name decrease\n   * @alias decreases\n   * @alias Decrease\n   * @param {String} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  function assertDecreases (object, prop, msg) {\n    if (msg) flag(this, 'message', msg);\n    var fn = flag(this, 'object');\n    new Assertion(object, msg).to.have.property(prop);\n    new Assertion(fn).is.a('function');\n\n    var initial = object[prop];\n    fn();\n\n    this.assert(\n      object[prop] - initial < 0\n      , 'expected .' + prop + ' to decrease'\n      , 'expected .' + prop + ' to not decrease'\n    );\n  }\n\n  Assertion.addChainableMethod('decrease', assertDecreases);\n  Assertion.addChainableMethod('decreases', assertDecreases);\n\n};\n","/*!\n * chai\n * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n\nmodule.exports = function (chai, util) {\n\n  /*!\n   * Chai dependencies.\n   */\n\n  var Assertion = chai.Assertion\n    , flag = util.flag;\n\n  /*!\n   * Module export.\n   */\n\n  /**\n   * ### assert(expression, message)\n   *\n   * Write your own test expressions.\n   *\n   *     assert('foo' !== 'bar', 'foo is not bar');\n   *     assert(Array.isArray([]), 'empty arrays are arrays');\n   *\n   * @param {Mixed} expression to test for truthiness\n   * @param {String} message to display on error\n   * @name assert\n   * @api public\n   */\n\n  var assert = chai.assert = function (express, errmsg) {\n    var test = new Assertion(null, null, chai.assert);\n    test.assert(\n        express\n      , errmsg\n      , '[ negation message unavailable ]'\n    );\n  };\n\n  /**\n   * ### .fail(actual, expected, [message], [operator])\n   *\n   * Throw a failure. Node.js `assert` module-compatible.\n   *\n   * @name fail\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @param {String} operator\n   * @api public\n   */\n\n  assert.fail = function (actual, expected, message, operator) {\n    message = message || 'assert.fail()';\n    throw new chai.AssertionError(message, {\n        actual: actual\n      , expected: expected\n      , operator: operator\n    }, assert.fail);\n  };\n\n  /**\n   * ### .ok(object, [message])\n   *\n   * Asserts that `object` is truthy.\n   *\n   *     assert.ok('everything', 'everything is ok');\n   *     assert.ok(false, 'this will fail');\n   *\n   * @name ok\n   * @param {Mixed} object to test\n   * @param {String} message\n   * @api public\n   */\n\n  assert.ok = function (val, msg) {\n    new Assertion(val, msg).is.ok;\n  };\n\n  /**\n   * ### .notOk(object, [message])\n   *\n   * Asserts that `object` is falsy.\n   *\n   *     assert.notOk('everything', 'this will fail');\n   *     assert.notOk(false, 'this will pass');\n   *\n   * @name notOk\n   * @param {Mixed} object to test\n   * @param {String} message\n   * @api public\n   */\n\n  assert.notOk = function (val, msg) {\n    new Assertion(val, msg).is.not.ok;\n  };\n\n  /**\n   * ### .equal(actual, expected, [message])\n   *\n   * Asserts non-strict equality (`==`) of `actual` and `expected`.\n   *\n   *     assert.equal(3, '3', '== coerces values to strings');\n   *\n   * @name equal\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @api public\n   */\n\n  assert.equal = function (act, exp, msg) {\n    var test = new Assertion(act, msg, assert.equal);\n\n    test.assert(\n        exp == flag(test, 'object')\n      , 'expected #{this} to equal #{exp}'\n      , 'expected #{this} to not equal #{act}'\n      , exp\n      , act\n    );\n  };\n\n  /**\n   * ### .notEqual(actual, expected, [message])\n   *\n   * Asserts non-strict inequality (`!=`) of `actual` and `expected`.\n   *\n   *     assert.notEqual(3, 4, 'these numbers are not equal');\n   *\n   * @name notEqual\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @api public\n   */\n\n  assert.notEqual = function (act, exp, msg) {\n    var test = new Assertion(act, msg, assert.notEqual);\n\n    test.assert(\n        exp != flag(test, 'object')\n      , 'expected #{this} to not equal #{exp}'\n      , 'expected #{this} to equal #{act}'\n      , exp\n      , act\n    );\n  };\n\n  /**\n   * ### .strictEqual(actual, expected, [message])\n   *\n   * Asserts strict equality (`===`) of `actual` and `expected`.\n   *\n   *     assert.strictEqual(true, true, 'these booleans are strictly equal');\n   *\n   * @name strictEqual\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @api public\n   */\n\n  assert.strictEqual = function (act, exp, msg) {\n    new Assertion(act, msg).to.equal(exp);\n  };\n\n  /**\n   * ### .notStrictEqual(actual, expected, [message])\n   *\n   * Asserts strict inequality (`!==`) of `actual` and `expected`.\n   *\n   *     assert.notStrictEqual(3, '3', 'no coercion for strict equality');\n   *\n   * @name notStrictEqual\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @api public\n   */\n\n  assert.notStrictEqual = function (act, exp, msg) {\n    new Assertion(act, msg).to.not.equal(exp);\n  };\n\n  /**\n   * ### .deepEqual(actual, expected, [message])\n   *\n   * Asserts that `actual` is deeply equal to `expected`.\n   *\n   *     assert.deepEqual({ tea: 'green' }, { tea: 'green' });\n   *\n   * @name deepEqual\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @api public\n   */\n\n  assert.deepEqual = function (act, exp, msg) {\n    new Assertion(act, msg).to.eql(exp);\n  };\n\n  /**\n   * ### .notDeepEqual(actual, expected, [message])\n   *\n   * Assert that `actual` is not deeply equal to `expected`.\n   *\n   *     assert.notDeepEqual({ tea: 'green' }, { tea: 'jasmine' });\n   *\n   * @name notDeepEqual\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @api public\n   */\n\n  assert.notDeepEqual = function (act, exp, msg) {\n    new Assertion(act, msg).to.not.eql(exp);\n  };\n\n  /**\n   * ### .isTrue(value, [message])\n   *\n   * Asserts that `value` is true.\n   *\n   *     var teaServed = true;\n   *     assert.isTrue(teaServed, 'the tea has been served');\n   *\n   * @name isTrue\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isAbove = function (val, abv, msg) {\n    new Assertion(val, msg).to.be.above(abv);\n  };\n\n   /**\n   * ### .isAbove(valueToCheck, valueToBeAbove, [message])\n   *\n   * Asserts `valueToCheck` is strictly greater than (>) `valueToBeAbove`\n   *\n   *     assert.isAbove(5, 2, '5 is strictly greater than 2');\n   *\n   * @name isAbove\n   * @param {Mixed} valueToCheck\n   * @param {Mixed} valueToBeAbove\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isBelow = function (val, blw, msg) {\n    new Assertion(val, msg).to.be.below(blw);\n  };\n\n   /**\n   * ### .isBelow(valueToCheck, valueToBeBelow, [message])\n   *\n   * Asserts `valueToCheck` is strictly less than (<) `valueToBeBelow`\n   *\n   *     assert.isBelow(3, 6, '3 is strictly less than 6');\n   *\n   * @name isBelow\n   * @param {Mixed} valueToCheck\n   * @param {Mixed} valueToBeBelow\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isTrue = function (val, msg) {\n    new Assertion(val, msg).is['true'];\n  };\n\n  /**\n   * ### .isFalse(value, [message])\n   *\n   * Asserts that `value` is false.\n   *\n   *     var teaServed = false;\n   *     assert.isFalse(teaServed, 'no tea yet? hmm...');\n   *\n   * @name isFalse\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isFalse = function (val, msg) {\n    new Assertion(val, msg).is['false'];\n  };\n\n  /**\n   * ### .isNull(value, [message])\n   *\n   * Asserts that `value` is null.\n   *\n   *     assert.isNull(err, 'there was no error');\n   *\n   * @name isNull\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isNull = function (val, msg) {\n    new Assertion(val, msg).to.equal(null);\n  };\n\n  /**\n   * ### .isNotNull(value, [message])\n   *\n   * Asserts that `value` is not null.\n   *\n   *     var tea = 'tasty chai';\n   *     assert.isNotNull(tea, 'great, time for tea!');\n   *\n   * @name isNotNull\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isNotNull = function (val, msg) {\n    new Assertion(val, msg).to.not.equal(null);\n  };\n\n  /**\n   * ### .isUndefined(value, [message])\n   *\n   * Asserts that `value` is `undefined`.\n   *\n   *     var tea;\n   *     assert.isUndefined(tea, 'no tea defined');\n   *\n   * @name isUndefined\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isUndefined = function (val, msg) {\n    new Assertion(val, msg).to.equal(undefined);\n  };\n\n  /**\n   * ### .isDefined(value, [message])\n   *\n   * Asserts that `value` is not `undefined`.\n   *\n   *     var tea = 'cup of chai';\n   *     assert.isDefined(tea, 'tea has been defined');\n   *\n   * @name isDefined\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isDefined = function (val, msg) {\n    new Assertion(val, msg).to.not.equal(undefined);\n  };\n\n  /**\n   * ### .isFunction(value, [message])\n   *\n   * Asserts that `value` is a function.\n   *\n   *     function serveTea() { return 'cup of tea'; };\n   *     assert.isFunction(serveTea, 'great, we can have tea now');\n   *\n   * @name isFunction\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isFunction = function (val, msg) {\n    new Assertion(val, msg).to.be.a('function');\n  };\n\n  /**\n   * ### .isNotFunction(value, [message])\n   *\n   * Asserts that `value` is _not_ a function.\n   *\n   *     var serveTea = [ 'heat', 'pour', 'sip' ];\n   *     assert.isNotFunction(serveTea, 'great, we have listed the steps');\n   *\n   * @name isNotFunction\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isNotFunction = function (val, msg) {\n    new Assertion(val, msg).to.not.be.a('function');\n  };\n\n  /**\n   * ### .isObject(value, [message])\n   *\n   * Asserts that `value` is an object (as revealed by\n   * `Object.prototype.toString`).\n   *\n   *     var selection = { name: 'Chai', serve: 'with spices' };\n   *     assert.isObject(selection, 'tea selection is an object');\n   *\n   * @name isObject\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isObject = function (val, msg) {\n    new Assertion(val, msg).to.be.a('object');\n  };\n\n  /**\n   * ### .isNotObject(value, [message])\n   *\n   * Asserts that `value` is _not_ an object.\n   *\n   *     var selection = 'chai'\n   *     assert.isNotObject(selection, 'tea selection is not an object');\n   *     assert.isNotObject(null, 'null is not an object');\n   *\n   * @name isNotObject\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isNotObject = function (val, msg) {\n    new Assertion(val, msg).to.not.be.a('object');\n  };\n\n  /**\n   * ### .isArray(value, [message])\n   *\n   * Asserts that `value` is an array.\n   *\n   *     var menu = [ 'green', 'chai', 'oolong' ];\n   *     assert.isArray(menu, 'what kind of tea do we want?');\n   *\n   * @name isArray\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isArray = function (val, msg) {\n    new Assertion(val, msg).to.be.an('array');\n  };\n\n  /**\n   * ### .isNotArray(value, [message])\n   *\n   * Asserts that `value` is _not_ an array.\n   *\n   *     var menu = 'green|chai|oolong';\n   *     assert.isNotArray(menu, 'what kind of tea do we want?');\n   *\n   * @name isNotArray\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isNotArray = function (val, msg) {\n    new Assertion(val, msg).to.not.be.an('array');\n  };\n\n  /**\n   * ### .isString(value, [message])\n   *\n   * Asserts that `value` is a string.\n   *\n   *     var teaOrder = 'chai';\n   *     assert.isString(teaOrder, 'order placed');\n   *\n   * @name isString\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isString = function (val, msg) {\n    new Assertion(val, msg).to.be.a('string');\n  };\n\n  /**\n   * ### .isNotString(value, [message])\n   *\n   * Asserts that `value` is _not_ a string.\n   *\n   *     var teaOrder = 4;\n   *     assert.isNotString(teaOrder, 'order placed');\n   *\n   * @name isNotString\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isNotString = function (val, msg) {\n    new Assertion(val, msg).to.not.be.a('string');\n  };\n\n  /**\n   * ### .isNumber(value, [message])\n   *\n   * Asserts that `value` is a number.\n   *\n   *     var cups = 2;\n   *     assert.isNumber(cups, 'how many cups');\n   *\n   * @name isNumber\n   * @param {Number} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isNumber = function (val, msg) {\n    new Assertion(val, msg).to.be.a('number');\n  };\n\n  /**\n   * ### .isNotNumber(value, [message])\n   *\n   * Asserts that `value` is _not_ a number.\n   *\n   *     var cups = '2 cups please';\n   *     assert.isNotNumber(cups, 'how many cups');\n   *\n   * @name isNotNumber\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isNotNumber = function (val, msg) {\n    new Assertion(val, msg).to.not.be.a('number');\n  };\n\n  /**\n   * ### .isBoolean(value, [message])\n   *\n   * Asserts that `value` is a boolean.\n   *\n   *     var teaReady = true\n   *       , teaServed = false;\n   *\n   *     assert.isBoolean(teaReady, 'is the tea ready');\n   *     assert.isBoolean(teaServed, 'has tea been served');\n   *\n   * @name isBoolean\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isBoolean = function (val, msg) {\n    new Assertion(val, msg).to.be.a('boolean');\n  };\n\n  /**\n   * ### .isNotBoolean(value, [message])\n   *\n   * Asserts that `value` is _not_ a boolean.\n   *\n   *     var teaReady = 'yep'\n   *       , teaServed = 'nope';\n   *\n   *     assert.isNotBoolean(teaReady, 'is the tea ready');\n   *     assert.isNotBoolean(teaServed, 'has tea been served');\n   *\n   * @name isNotBoolean\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.isNotBoolean = function (val, msg) {\n    new Assertion(val, msg).to.not.be.a('boolean');\n  };\n\n  /**\n   * ### .typeOf(value, name, [message])\n   *\n   * Asserts that `value`'s type is `name`, as determined by\n   * `Object.prototype.toString`.\n   *\n   *     assert.typeOf({ tea: 'chai' }, 'object', 'we have an object');\n   *     assert.typeOf(['chai', 'jasmine'], 'array', 'we have an array');\n   *     assert.typeOf('tea', 'string', 'we have a string');\n   *     assert.typeOf(/tea/, 'regexp', 'we have a regular expression');\n   *     assert.typeOf(null, 'null', 'we have a null');\n   *     assert.typeOf(undefined, 'undefined', 'we have an undefined');\n   *\n   * @name typeOf\n   * @param {Mixed} value\n   * @param {String} name\n   * @param {String} message\n   * @api public\n   */\n\n  assert.typeOf = function (val, type, msg) {\n    new Assertion(val, msg).to.be.a(type);\n  };\n\n  /**\n   * ### .notTypeOf(value, name, [message])\n   *\n   * Asserts that `value`'s type is _not_ `name`, as determined by\n   * `Object.prototype.toString`.\n   *\n   *     assert.notTypeOf('tea', 'number', 'strings are not numbers');\n   *\n   * @name notTypeOf\n   * @param {Mixed} value\n   * @param {String} typeof name\n   * @param {String} message\n   * @api public\n   */\n\n  assert.notTypeOf = function (val, type, msg) {\n    new Assertion(val, msg).to.not.be.a(type);\n  };\n\n  /**\n   * ### .instanceOf(object, constructor, [message])\n   *\n   * Asserts that `value` is an instance of `constructor`.\n   *\n   *     var Tea = function (name) { this.name = name; }\n   *       , chai = new Tea('chai');\n   *\n   *     assert.instanceOf(chai, Tea, 'chai is an instance of tea');\n   *\n   * @name instanceOf\n   * @param {Object} object\n   * @param {Constructor} constructor\n   * @param {String} message\n   * @api public\n   */\n\n  assert.instanceOf = function (val, type, msg) {\n    new Assertion(val, msg).to.be.instanceOf(type);\n  };\n\n  /**\n   * ### .notInstanceOf(object, constructor, [message])\n   *\n   * Asserts `value` is not an instance of `constructor`.\n   *\n   *     var Tea = function (name) { this.name = name; }\n   *       , chai = new String('chai');\n   *\n   *     assert.notInstanceOf(chai, Tea, 'chai is not an instance of tea');\n   *\n   * @name notInstanceOf\n   * @param {Object} object\n   * @param {Constructor} constructor\n   * @param {String} message\n   * @api public\n   */\n\n  assert.notInstanceOf = function (val, type, msg) {\n    new Assertion(val, msg).to.not.be.instanceOf(type);\n  };\n\n  /**\n   * ### .include(haystack, needle, [message])\n   *\n   * Asserts that `haystack` includes `needle`. Works\n   * for strings and arrays.\n   *\n   *     assert.include('foobar', 'bar', 'foobar contains string \"bar\"');\n   *     assert.include([ 1, 2, 3 ], 3, 'array contains value');\n   *\n   * @name include\n   * @param {Array|String} haystack\n   * @param {Mixed} needle\n   * @param {String} message\n   * @api public\n   */\n\n  assert.include = function (exp, inc, msg) {\n    new Assertion(exp, msg, assert.include).include(inc);\n  };\n\n  /**\n   * ### .notInclude(haystack, needle, [message])\n   *\n   * Asserts that `haystack` does not include `needle`. Works\n   * for strings and arrays.\n   *i\n   *     assert.notInclude('foobar', 'baz', 'string not include substring');\n   *     assert.notInclude([ 1, 2, 3 ], 4, 'array not include contain value');\n   *\n   * @name notInclude\n   * @param {Array|String} haystack\n   * @param {Mixed} needle\n   * @param {String} message\n   * @api public\n   */\n\n  assert.notInclude = function (exp, inc, msg) {\n    new Assertion(exp, msg, assert.notInclude).not.include(inc);\n  };\n\n  /**\n   * ### .match(value, regexp, [message])\n   *\n   * Asserts that `value` matches the regular expression `regexp`.\n   *\n   *     assert.match('foobar', /^foo/, 'regexp matches');\n   *\n   * @name match\n   * @param {Mixed} value\n   * @param {RegExp} regexp\n   * @param {String} message\n   * @api public\n   */\n\n  assert.match = function (exp, re, msg) {\n    new Assertion(exp, msg).to.match(re);\n  };\n\n  /**\n   * ### .notMatch(value, regexp, [message])\n   *\n   * Asserts that `value` does not match the regular expression `regexp`.\n   *\n   *     assert.notMatch('foobar', /^foo/, 'regexp does not match');\n   *\n   * @name notMatch\n   * @param {Mixed} value\n   * @param {RegExp} regexp\n   * @param {String} message\n   * @api public\n   */\n\n  assert.notMatch = function (exp, re, msg) {\n    new Assertion(exp, msg).to.not.match(re);\n  };\n\n  /**\n   * ### .property(object, property, [message])\n   *\n   * Asserts that `object` has a property named by `property`.\n   *\n   *     assert.property({ tea: { green: 'matcha' }}, 'tea');\n   *\n   * @name property\n   * @param {Object} object\n   * @param {String} property\n   * @param {String} message\n   * @api public\n   */\n\n  assert.property = function (obj, prop, msg) {\n    new Assertion(obj, msg).to.have.property(prop);\n  };\n\n  /**\n   * ### .notProperty(object, property, [message])\n   *\n   * Asserts that `object` does _not_ have a property named by `property`.\n   *\n   *     assert.notProperty({ tea: { green: 'matcha' }}, 'coffee');\n   *\n   * @name notProperty\n   * @param {Object} object\n   * @param {String} property\n   * @param {String} message\n   * @api public\n   */\n\n  assert.notProperty = function (obj, prop, msg) {\n    new Assertion(obj, msg).to.not.have.property(prop);\n  };\n\n  /**\n   * ### .deepProperty(object, property, [message])\n   *\n   * Asserts that `object` has a property named by `property`, which can be a\n   * string using dot- and bracket-notation for deep reference.\n   *\n   *     assert.deepProperty({ tea: { green: 'matcha' }}, 'tea.green');\n   *\n   * @name deepProperty\n   * @param {Object} object\n   * @param {String} property\n   * @param {String} message\n   * @api public\n   */\n\n  assert.deepProperty = function (obj, prop, msg) {\n    new Assertion(obj, msg).to.have.deep.property(prop);\n  };\n\n  /**\n   * ### .notDeepProperty(object, property, [message])\n   *\n   * Asserts that `object` does _not_ have a property named by `property`, which\n   * can be a string using dot- and bracket-notation for deep reference.\n   *\n   *     assert.notDeepProperty({ tea: { green: 'matcha' }}, 'tea.oolong');\n   *\n   * @name notDeepProperty\n   * @param {Object} object\n   * @param {String} property\n   * @param {String} message\n   * @api public\n   */\n\n  assert.notDeepProperty = function (obj, prop, msg) {\n    new Assertion(obj, msg).to.not.have.deep.property(prop);\n  };\n\n  /**\n   * ### .propertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` has a property named by `property` with value given\n   * by `value`.\n   *\n   *     assert.propertyVal({ tea: 'is good' }, 'tea', 'is good');\n   *\n   * @name propertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.propertyVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg).to.have.property(prop, val);\n  };\n\n  /**\n   * ### .propertyNotVal(object, property, value, [message])\n   *\n   * Asserts that `object` has a property named by `property`, but with a value\n   * different from that given by `value`.\n   *\n   *     assert.propertyNotVal({ tea: 'is good' }, 'tea', 'is bad');\n   *\n   * @name propertyNotVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.propertyNotVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg).to.not.have.property(prop, val);\n  };\n\n  /**\n   * ### .deepPropertyVal(object, property, value, [message])\n   *\n   * Asserts that `object` has a property named by `property` with value given\n   * by `value`. `property` can use dot- and bracket-notation for deep\n   * reference.\n   *\n   *     assert.deepPropertyVal({ tea: { green: 'matcha' }}, 'tea.green', 'matcha');\n   *\n   * @name deepPropertyVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.deepPropertyVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg).to.have.deep.property(prop, val);\n  };\n\n  /**\n   * ### .deepPropertyNotVal(object, property, value, [message])\n   *\n   * Asserts that `object` has a property named by `property`, but with a value\n   * different from that given by `value`. `property` can use dot- and\n   * bracket-notation for deep reference.\n   *\n   *     assert.deepPropertyNotVal({ tea: { green: 'matcha' }}, 'tea.green', 'konacha');\n   *\n   * @name deepPropertyNotVal\n   * @param {Object} object\n   * @param {String} property\n   * @param {Mixed} value\n   * @param {String} message\n   * @api public\n   */\n\n  assert.deepPropertyNotVal = function (obj, prop, val, msg) {\n    new Assertion(obj, msg).to.not.have.deep.property(prop, val);\n  };\n\n  /**\n   * ### .lengthOf(object, length, [message])\n   *\n   * Asserts that `object` has a `length` property with the expected value.\n   *\n   *     assert.lengthOf([1,2,3], 3, 'array has length of 3');\n   *     assert.lengthOf('foobar', 5, 'string has length of 6');\n   *\n   * @name lengthOf\n   * @param {Mixed} object\n   * @param {Number} length\n   * @param {String} message\n   * @api public\n   */\n\n  assert.lengthOf = function (exp, len, msg) {\n    new Assertion(exp, msg).to.have.length(len);\n  };\n\n  /**\n   * ### .throws(function, [constructor/string/regexp], [string/regexp], [message])\n   *\n   * Asserts that `function` will throw an error that is an instance of\n   * `constructor`, or alternately that it will throw an error with message\n   * matching `regexp`.\n   *\n   *     assert.throw(fn, 'function throws a reference error');\n   *     assert.throw(fn, /function throws a reference error/);\n   *     assert.throw(fn, ReferenceError);\n   *     assert.throw(fn, ReferenceError, 'function throws a reference error');\n   *     assert.throw(fn, ReferenceError, /function throws a reference error/);\n   *\n   * @name throws\n   * @alias throw\n   * @alias Throw\n   * @param {Function} function\n   * @param {ErrorConstructor} constructor\n   * @param {RegExp} regexp\n   * @param {String} message\n   * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types\n   * @api public\n   */\n\n  assert.Throw = function (fn, errt, errs, msg) {\n    if ('string' === typeof errt || errt instanceof RegExp) {\n      errs = errt;\n      errt = null;\n    }\n\n    var assertErr = new Assertion(fn, msg).to.Throw(errt, errs);\n    return flag(assertErr, 'object');\n  };\n\n  /**\n   * ### .doesNotThrow(function, [constructor/regexp], [message])\n   *\n   * Asserts that `function` will _not_ throw an error that is an instance of\n   * `constructor`, or alternately that it will not throw an error with message\n   * matching `regexp`.\n   *\n   *     assert.doesNotThrow(fn, Error, 'function does not throw');\n   *\n   * @name doesNotThrow\n   * @param {Function} function\n   * @param {ErrorConstructor} constructor\n   * @param {RegExp} regexp\n   * @param {String} message\n   * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types\n   * @api public\n   */\n\n  assert.doesNotThrow = function (fn, type, msg) {\n    if ('string' === typeof type) {\n      msg = type;\n      type = null;\n    }\n\n    new Assertion(fn, msg).to.not.Throw(type);\n  };\n\n  /**\n   * ### .operator(val1, operator, val2, [message])\n   *\n   * Compares two values using `operator`.\n   *\n   *     assert.operator(1, '<', 2, 'everything is ok');\n   *     assert.operator(1, '>', 2, 'this will fail');\n   *\n   * @name operator\n   * @param {Mixed} val1\n   * @param {String} operator\n   * @param {Mixed} val2\n   * @param {String} message\n   * @api public\n   */\n\n  assert.operator = function (val, operator, val2, msg) {\n    var ok;\n    switch(operator) {\n      case '==':\n        ok = val == val2;\n        break;\n      case '===':\n        ok = val === val2;\n        break;\n      case '>':\n        ok = val > val2;\n        break;\n      case '>=':\n        ok = val >= val2;\n        break;\n      case '<':\n        ok = val < val2;\n        break;\n      case '<=':\n        ok = val <= val2;\n        break;\n      case '!=':\n        ok = val != val2;\n        break;\n      case '!==':\n        ok = val !== val2;\n        break;\n      default:\n        throw new Error('Invalid operator \"' + operator + '\"');\n    }\n    var test = new Assertion(ok, msg);\n    test.assert(\n        true === flag(test, 'object')\n      , 'expected ' + util.inspect(val) + ' to be ' + operator + ' ' + util.inspect(val2)\n      , 'expected ' + util.inspect(val) + ' to not be ' + operator + ' ' + util.inspect(val2) );\n  };\n\n  /**\n   * ### .closeTo(actual, expected, delta, [message])\n   *\n   * Asserts that the target is equal `expected`, to within a +/- `delta` range.\n   *\n   *     assert.closeTo(1.5, 1, 0.5, 'numbers are close');\n   *\n   * @name closeTo\n   * @param {Number} actual\n   * @param {Number} expected\n   * @param {Number} delta\n   * @param {String} message\n   * @api public\n   */\n\n  assert.closeTo = function (act, exp, delta, msg) {\n    new Assertion(act, msg).to.be.closeTo(exp, delta);\n  };\n\n  /**\n   * ### .sameMembers(set1, set2, [message])\n   *\n   * Asserts that `set1` and `set2` have the same members.\n   * Order is not taken into account.\n   *\n   *     assert.sameMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'same members');\n   *\n   * @name sameMembers\n   * @param {Array} set1\n   * @param {Array} set2\n   * @param {String} message\n   * @api public\n   */\n\n  assert.sameMembers = function (set1, set2, msg) {\n    new Assertion(set1, msg).to.have.same.members(set2);\n  }\n\n  /**\n   * ### .sameDeepMembers(set1, set2, [message])\n   *\n   * Asserts that `set1` and `set2` have the same members - using a deep equality checking.\n   * Order is not taken into account.\n   *\n   *     assert.sameDeepMembers([ {b: 3}, {a: 2}, {c: 5} ], [ {c: 5}, {b: 3}, {a: 2} ], 'same deep members');\n   *\n   * @name sameDeepMembers\n   * @param {Array} set1\n   * @param {Array} set2\n   * @param {String} message\n   * @api public\n   */\n\n  assert.sameDeepMembers = function (set1, set2, msg) {\n    new Assertion(set1, msg).to.have.same.deep.members(set2);\n  }\n\n  /**\n   * ### .includeMembers(superset, subset, [message])\n   *\n   * Asserts that `subset` is included in `superset`.\n   * Order is not taken into account.\n   *\n   *     assert.includeMembers([ 1, 2, 3 ], [ 2, 1 ], 'include members');\n   *\n   * @name includeMembers\n   * @param {Array} superset\n   * @param {Array} subset\n   * @param {String} message\n   * @api public\n   */\n\n  assert.includeMembers = function (superset, subset, msg) {\n    new Assertion(superset, msg).to.include.members(subset);\n  }\n\n   /**\n   * ### .changes(function, object, property)\n   *\n   * Asserts that a function changes the value of a property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 22 };\n   *     assert.changes(fn, obj, 'val');\n   *\n   * @name changes\n   * @param {Function} modifier function\n   * @param {Object} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  assert.changes = function (fn, obj, prop) {\n    new Assertion(fn).to.change(obj, prop);\n  }\n\n   /**\n   * ### .doesNotChange(function, object, property)\n   *\n   * Asserts that a function does not changes the value of a property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { console.log('foo'); };\n   *     assert.doesNotChange(fn, obj, 'val');\n   *\n   * @name doesNotChange\n   * @param {Function} modifier function\n   * @param {Object} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  assert.doesNotChange = function (fn, obj, prop) {\n    new Assertion(fn).to.not.change(obj, prop);\n  }\n\n   /**\n   * ### .increases(function, object, property)\n   *\n   * Asserts that a function increases an object property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 13 };\n   *     assert.increases(fn, obj, 'val');\n   *\n   * @name increases\n   * @param {Function} modifier function\n   * @param {Object} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  assert.increases = function (fn, obj, prop) {\n    new Assertion(fn).to.increase(obj, prop);\n  }\n\n   /**\n   * ### .doesNotIncrease(function, object, property)\n   *\n   * Asserts that a function does not increase object property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 8 };\n   *     assert.doesNotIncrease(fn, obj, 'val');\n   *\n   * @name doesNotIncrease\n   * @param {Function} modifier function\n   * @param {Object} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  assert.doesNotIncrease = function (fn, obj, prop) {\n    new Assertion(fn).to.not.increase(obj, prop);\n  }\n\n   /**\n   * ### .decreases(function, object, property)\n   *\n   * Asserts that a function decreases an object property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 5 };\n   *     assert.decreases(fn, obj, 'val');\n   *\n   * @name decreases\n   * @param {Function} modifier function\n   * @param {Object} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  assert.decreases = function (fn, obj, prop) {\n    new Assertion(fn).to.decrease(obj, prop);\n  }\n\n   /**\n   * ### .doesNotDecrease(function, object, property)\n   *\n   * Asserts that a function does not decreases an object property\n   *\n   *     var obj = { val: 10 };\n   *     var fn = function() { obj.val = 15 };\n   *     assert.doesNotDecrease(fn, obj, 'val');\n   *\n   * @name doesNotDecrease\n   * @param {Function} modifier function\n   * @param {Object} object\n   * @param {String} property name\n   * @param {String} message _optional_\n   * @api public\n   */\n\n  assert.doesNotDecrease = function (fn, obj, prop) {\n    new Assertion(fn).to.not.decrease(obj, prop);\n  }\n\n  /*!\n   * Undocumented / untested\n   */\n\n  assert.ifError = function (val, msg) {\n    new Assertion(val, msg).to.not.be.ok;\n  };\n\n  /*!\n   * Aliases.\n   */\n\n  (function alias(name, as){\n    assert[as] = assert[name];\n    return alias;\n  })\n  ('Throw', 'throw')\n  ('Throw', 'throws');\n};\n","/*!\n * chai\n * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nmodule.exports = function (chai, util) {\n  chai.expect = function (val, message) {\n    return new chai.Assertion(val, message);\n  };\n\n  /**\n   * ### .fail(actual, expected, [message], [operator])\n   *\n   * Throw a failure.\n   *\n   * @name fail\n   * @param {Mixed} actual\n   * @param {Mixed} expected\n   * @param {String} message\n   * @param {String} operator\n   * @api public\n   */\n\n  chai.expect.fail = function (actual, expected, message, operator) {\n    message = message || 'expect.fail()';\n    throw new chai.AssertionError(message, {\n        actual: actual\n      , expected: expected\n      , operator: operator\n    }, chai.expect.fail);\n  };\n};\n","/*!\n * chai\n * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nmodule.exports = function (chai, util) {\n  var Assertion = chai.Assertion;\n\n  function loadShould () {\n    // explicitly define this method as function as to have it's name to include as `ssfi`\n    function shouldGetter() {\n      if (this instanceof String || this instanceof Number || this instanceof Boolean ) {\n        return new Assertion(this.valueOf(), null, shouldGetter);\n      }\n      return new Assertion(this, null, shouldGetter);\n    }\n    function shouldSetter(value) {\n      // See https://github.com/chaijs/chai/issues/86: this makes\n      // `whatever.should = someValue` actually set `someValue`, which is\n      // especially useful for `global.should = require('chai').should()`.\n      //\n      // Note that we have to use [[DefineProperty]] instead of [[Put]]\n      // since otherwise we would trigger this very setter!\n      Object.defineProperty(this, 'should', {\n        value: value,\n        enumerable: true,\n        configurable: true,\n        writable: true\n      });\n    }\n    // modify Object.prototype to have `should`\n    Object.defineProperty(Object.prototype, 'should', {\n      set: shouldSetter\n      , get: shouldGetter\n      , configurable: true\n    });\n\n    var should = {};\n\n    /**\n     * ### .fail(actual, expected, [message], [operator])\n     *\n     * Throw a failure.\n     *\n     * @name fail\n     * @param {Mixed} actual\n     * @param {Mixed} expected\n     * @param {String} message\n     * @param {String} operator\n     * @api public\n     */\n\n    should.fail = function (actual, expected, message, operator) {\n      message = message || 'should.fail()';\n      throw new chai.AssertionError(message, {\n          actual: actual\n        , expected: expected\n        , operator: operator\n      }, should.fail);\n    };\n\n    should.equal = function (val1, val2, msg) {\n      new Assertion(val1, msg).to.equal(val2);\n    };\n\n    should.Throw = function (fn, errt, errs, msg) {\n      new Assertion(fn, msg).to.Throw(errt, errs);\n    };\n\n    should.exist = function (val, msg) {\n      new Assertion(val, msg).to.exist;\n    }\n\n    // negation\n    should.not = {}\n\n    should.not.equal = function (val1, val2, msg) {\n      new Assertion(val1, msg).to.not.equal(val2);\n    };\n\n    should.not.Throw = function (fn, errt, errs, msg) {\n      new Assertion(fn, msg).to.not.Throw(errt, errs);\n    };\n\n    should.not.exist = function (val, msg) {\n      new Assertion(val, msg).to.not.exist;\n    }\n\n    should['throw'] = should['Throw'];\n    should.not['throw'] = should.not['Throw'];\n\n    return should;\n  };\n\n  chai.should = loadShould;\n  chai.Should = loadShould;\n};\n","/*!\n * Chai - addChainingMethod utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Module dependencies\n */\n\nvar transferFlags = require('./transferFlags');\nvar flag = require('./flag');\nvar config = require('../config');\n\n/*!\n * Module variables\n */\n\n// Check whether `__proto__` is supported\nvar hasProtoSupport = '__proto__' in Object;\n\n// Without `__proto__` support, this module will need to add properties to a function.\n// However, some Function.prototype methods cannot be overwritten,\n// and there seems no easy cross-platform way to detect them (@see chaijs/chai/issues/69).\nvar excludeNames = /^(?:length|name|arguments|caller)$/;\n\n// Cache `Function` properties\nvar call  = Function.prototype.call,\n    apply = Function.prototype.apply;\n\n/**\n * ### addChainableMethod (ctx, name, method, chainingBehavior)\n *\n * Adds a method to an object, such that the method can also be chained.\n *\n *     utils.addChainableMethod(chai.Assertion.prototype, 'foo', function (str) {\n *       var obj = utils.flag(this, 'object');\n *       new chai.Assertion(obj).to.be.equal(str);\n *     });\n *\n * Can also be accessed directly from `chai.Assertion`.\n *\n *     chai.Assertion.addChainableMethod('foo', fn, chainingBehavior);\n *\n * The result can then be used as both a method assertion, executing both `method` and\n * `chainingBehavior`, or as a language chain, which only executes `chainingBehavior`.\n *\n *     expect(fooStr).to.be.foo('bar');\n *     expect(fooStr).to.be.foo.equal('foo');\n *\n * @param {Object} ctx object to which the method is added\n * @param {String} name of method to add\n * @param {Function} method function to be used for `name`, when called\n * @param {Function} chainingBehavior function to be called every time the property is accessed\n * @name addChainableMethod\n * @api public\n */\n\nmodule.exports = function (ctx, name, method, chainingBehavior) {\n  if (typeof chainingBehavior !== 'function') {\n    chainingBehavior = function () { };\n  }\n\n  var chainableBehavior = {\n      method: method\n    , chainingBehavior: chainingBehavior\n  };\n\n  // save the methods so we can overwrite them later, if we need to.\n  if (!ctx.__methods) {\n    ctx.__methods = {};\n  }\n  ctx.__methods[name] = chainableBehavior;\n\n  Object.defineProperty(ctx, name,\n    { get: function () {\n        chainableBehavior.chainingBehavior.call(this);\n\n        var assert = function assert() {\n          var old_ssfi = flag(this, 'ssfi');\n          if (old_ssfi && config.includeStack === false)\n            flag(this, 'ssfi', assert);\n          var result = chainableBehavior.method.apply(this, arguments);\n          return result === undefined ? this : result;\n        };\n\n        // Use `__proto__` if available\n        if (hasProtoSupport) {\n          // Inherit all properties from the object by replacing the `Function` prototype\n          var prototype = assert.__proto__ = Object.create(this);\n          // Restore the `call` and `apply` methods from `Function`\n          prototype.call = call;\n          prototype.apply = apply;\n        }\n        // Otherwise, redefine all properties (slow!)\n        else {\n          var asserterNames = Object.getOwnPropertyNames(ctx);\n          asserterNames.forEach(function (asserterName) {\n            if (!excludeNames.test(asserterName)) {\n              var pd = Object.getOwnPropertyDescriptor(ctx, asserterName);\n              Object.defineProperty(assert, asserterName, pd);\n            }\n          });\n        }\n\n        transferFlags(this, assert);\n        return assert;\n      }\n    , configurable: true\n  });\n};\n","/*!\n * Chai - addMethod utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nvar config = require('../config');\n\n/**\n * ### .addMethod (ctx, name, method)\n *\n * Adds a method to the prototype of an object.\n *\n *     utils.addMethod(chai.Assertion.prototype, 'foo', function (str) {\n *       var obj = utils.flag(this, 'object');\n *       new chai.Assertion(obj).to.be.equal(str);\n *     });\n *\n * Can also be accessed directly from `chai.Assertion`.\n *\n *     chai.Assertion.addMethod('foo', fn);\n *\n * Then can be used as any other assertion.\n *\n *     expect(fooStr).to.be.foo('bar');\n *\n * @param {Object} ctx object to which the method is added\n * @param {String} name of method to add\n * @param {Function} method function to be used for name\n * @name addMethod\n * @api public\n */\nvar flag = require('./flag');\n\nmodule.exports = function (ctx, name, method) {\n  ctx[name] = function () {\n    var old_ssfi = flag(this, 'ssfi');\n    if (old_ssfi && config.includeStack === false)\n      flag(this, 'ssfi', ctx[name]);\n    var result = method.apply(this, arguments);\n    return result === undefined ? this : result;\n  };\n};\n","/*!\n * Chai - addProperty utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### addProperty (ctx, name, getter)\n *\n * Adds a property to the prototype of an object.\n *\n *     utils.addProperty(chai.Assertion.prototype, 'foo', function () {\n *       var obj = utils.flag(this, 'object');\n *       new chai.Assertion(obj).to.be.instanceof(Foo);\n *     });\n *\n * Can also be accessed directly from `chai.Assertion`.\n *\n *     chai.Assertion.addProperty('foo', fn);\n *\n * Then can be used as any other assertion.\n *\n *     expect(myFoo).to.be.foo;\n *\n * @param {Object} ctx object to which the property is added\n * @param {String} name of property to add\n * @param {Function} getter function to be used for name\n * @name addProperty\n * @api public\n */\n\nmodule.exports = function (ctx, name, getter) {\n  Object.defineProperty(ctx, name,\n    { get: function () {\n        var result = getter.call(this);\n        return result === undefined ? this : result;\n      }\n    , configurable: true\n  });\n};\n","/*!\n * Chai - flag utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### flag(object, key, [value])\n *\n * Get or set a flag value on an object. If a\n * value is provided it will be set, else it will\n * return the currently set value or `undefined` if\n * the value is not set.\n *\n *     utils.flag(this, 'foo', 'bar'); // setter\n *     utils.flag(this, 'foo'); // getter, returns `bar`\n *\n * @param {Object} object constructed Assertion\n * @param {String} key\n * @param {Mixed} value (optional)\n * @name flag\n * @api private\n */\n\nmodule.exports = function (obj, key, value) {\n  var flags = obj.__flags || (obj.__flags = Object.create(null));\n  if (arguments.length === 3) {\n    flags[key] = value;\n  } else {\n    return flags[key];\n  }\n};\n","/*!\n * Chai - getActual utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * # getActual(object, [actual])\n *\n * Returns the `actual` value for an Assertion\n *\n * @param {Object} object (constructed Assertion)\n * @param {Arguments} chai.Assertion.prototype.assert arguments\n */\n\nmodule.exports = function (obj, args) {\n  return args.length > 4 ? args[4] : obj._obj;\n};\n","/*!\n * Chai - getEnumerableProperties utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### .getEnumerableProperties(object)\n *\n * This allows the retrieval of enumerable property names of an object,\n * inherited or not.\n *\n * @param {Object} object\n * @returns {Array}\n * @name getEnumerableProperties\n * @api public\n */\n\nmodule.exports = function getEnumerableProperties(object) {\n  var result = [];\n  for (var name in object) {\n    result.push(name);\n  }\n  return result;\n};\n","/*!\n * Chai - message composition utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Module dependancies\n */\n\nvar flag = require('./flag')\n  , getActual = require('./getActual')\n  , inspect = require('./inspect')\n  , objDisplay = require('./objDisplay');\n\n/**\n * ### .getMessage(object, message, negateMessage)\n *\n * Construct the error message based on flags\n * and template tags. Template tags will return\n * a stringified inspection of the object referenced.\n *\n * Message template tags:\n * - `#{this}` current asserted object\n * - `#{act}` actual value\n * - `#{exp}` expected value\n *\n * @param {Object} object (constructed Assertion)\n * @param {Arguments} chai.Assertion.prototype.assert arguments\n * @name getMessage\n * @api public\n */\n\nmodule.exports = function (obj, args) {\n  var negate = flag(obj, 'negate')\n    , val = flag(obj, 'object')\n    , expected = args[3]\n    , actual = getActual(obj, args)\n    , msg = negate ? args[2] : args[1]\n    , flagMsg = flag(obj, 'message');\n\n  if(typeof msg === \"function\") msg = msg();\n  msg = msg || '';\n  msg = msg\n    .replace(/#{this}/g, objDisplay(val))\n    .replace(/#{act}/g, objDisplay(actual))\n    .replace(/#{exp}/g, objDisplay(expected));\n\n  return flagMsg ? flagMsg + ': ' + msg : msg;\n};\n","/*!\n * Chai - getName utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * # getName(func)\n *\n * Gets the name of a function, in a cross-browser way.\n *\n * @param {Function} a function (usually a constructor)\n */\n\nmodule.exports = function (func) {\n  if (func.name) return func.name;\n\n  var match = /^\\s?function ([^(]*)\\(/.exec(func);\n  return match && match[1] ? match[1] : \"\";\n};\n","/*!\n * Chai - getPathInfo utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nvar hasProperty = require('./hasProperty');\n\n/**\n * ### .getPathInfo(path, object)\n *\n * This allows the retrieval of property info in an\n * object given a string path.\n *\n * The path info consists of an object with the\n * following properties:\n *\n * * parent - The parent object of the property referenced by `path`\n * * name - The name of the final property, a number if it was an array indexer\n * * value - The value of the property, if it exists, otherwise `undefined`\n * * exists - Whether the property exists or not\n *\n * @param {String} path\n * @param {Object} object\n * @returns {Object} info\n * @name getPathInfo\n * @api public\n */\n\nmodule.exports = function getPathInfo(path, obj) {\n  var parsed = parsePath(path),\n      last = parsed[parsed.length - 1];\n\n  var info = {\n    parent: parsed.length > 1 ? _getPathValue(parsed, obj, parsed.length - 1) : obj,\n    name: last.p || last.i,\n    value: _getPathValue(parsed, obj),\n  };\n  info.exists = hasProperty(info.name, info.parent);\n\n  return info;\n};\n\n\n/*!\n * ## parsePath(path)\n *\n * Helper function used to parse string object\n * paths. Use in conjunction with `_getPathValue`.\n *\n *      var parsed = parsePath('myobject.property.subprop');\n *\n * ### Paths:\n *\n * * Can be as near infinitely deep and nested\n * * Arrays are also valid using the formal `myobject.document[3].property`.\n * * Literal dots and brackets (not delimiter) must be backslash-escaped.\n *\n * @param {String} path\n * @returns {Object} parsed\n * @api private\n */\n\nfunction parsePath (path) {\n  var str = path.replace(/([^\\\\])\\[/g, '$1.[')\n    , parts = str.match(/(\\\\\\.|[^.]+?)+/g);\n  return parts.map(function (value) {\n    var re = /^\\[(\\d+)\\]$/\n      , mArr = re.exec(value);\n    if (mArr) return { i: parseFloat(mArr[1]) };\n    else return { p: value.replace(/\\\\([.\\[\\]])/g, '$1') };\n  });\n}\n\n\n/*!\n * ## _getPathValue(parsed, obj)\n *\n * Helper companion function for `.parsePath` that returns\n * the value located at the parsed address.\n *\n *      var value = getPathValue(parsed, obj);\n *\n * @param {Object} parsed definition from `parsePath`.\n * @param {Object} object to search against\n * @param {Number} object to search against\n * @returns {Object|Undefined} value\n * @api private\n */\n\nfunction _getPathValue (parsed, obj, index) {\n  var tmp = obj\n    , res;\n\n  index = (index === undefined ? parsed.length : index);\n\n  for (var i = 0, l = index; i < l; i++) {\n    var part = parsed[i];\n    if (tmp) {\n      if ('undefined' !== typeof part.p)\n        tmp = tmp[part.p];\n      else if ('undefined' !== typeof part.i)\n        tmp = tmp[part.i];\n      if (i == (l - 1)) res = tmp;\n    } else {\n      res = undefined;\n    }\n  }\n  return res;\n}\n","/*!\n * Chai - getPathValue utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * @see https://github.com/logicalparadox/filtr\n * MIT Licensed\n */\n\nvar getPathInfo = require('./getPathInfo');\n\n/**\n * ### .getPathValue(path, object)\n *\n * This allows the retrieval of values in an\n * object given a string path.\n *\n *     var obj = {\n *         prop1: {\n *             arr: ['a', 'b', 'c']\n *           , str: 'Hello'\n *         }\n *       , prop2: {\n *             arr: [ { nested: 'Universe' } ]\n *           , str: 'Hello again!'\n *         }\n *     }\n *\n * The following would be the results.\n *\n *     getPathValue('prop1.str', obj); // Hello\n *     getPathValue('prop1.att[2]', obj); // b\n *     getPathValue('prop2.arr[0].nested', obj); // Universe\n *\n * @param {String} path\n * @param {Object} object\n * @returns {Object} value or `undefined`\n * @name getPathValue\n * @api public\n */\nmodule.exports = function(path, obj) {\n  var info = getPathInfo(path, obj);\n  return info.value;\n}; \n","/*!\n * Chai - getProperties utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### .getProperties(object)\n *\n * This allows the retrieval of property names of an object, enumerable or not,\n * inherited or not.\n *\n * @param {Object} object\n * @returns {Array}\n * @name getProperties\n * @api public\n */\n\nmodule.exports = function getProperties(object) {\n  var result = Object.getOwnPropertyNames(subject);\n\n  function addProperty(property) {\n    if (result.indexOf(property) === -1) {\n      result.push(property);\n    }\n  }\n\n  var proto = Object.getPrototypeOf(subject);\n  while (proto !== null) {\n    Object.getOwnPropertyNames(proto).forEach(addProperty);\n    proto = Object.getPrototypeOf(proto);\n  }\n\n  return result;\n};\n","/*!\n * Chai - hasProperty utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\nvar type = require('./type');\n\n/**\n * ### .hasProperty(object, name)\n *\n * This allows checking whether an object has\n * named property or numeric array index.\n *\n * Basically does the same thing as the `in`\n * operator but works properly with natives\n * and null/undefined values.\n *\n *     var obj = {\n *         arr: ['a', 'b', 'c']\n *       , str: 'Hello'\n *     }\n *\n * The following would be the results.\n *\n *     hasProperty('str', obj);  // true\n *     hasProperty('constructor', obj);  // true\n *     hasProperty('bar', obj);  // false\n *     \n *     hasProperty('length', obj.str); // true\n *     hasProperty(1, obj.str);  // true\n *     hasProperty(5, obj.str);  // false\n *\n *     hasProperty('length', obj.arr);  // true\n *     hasProperty(2, obj.arr);  // true\n *     hasProperty(3, obj.arr);  // false\n *\n * @param {Objuect} object\n * @param {String|Number} name\n * @returns {Boolean} whether it exists\n * @name getPathInfo\n * @api public\n */\n\nvar literals = {\n    'number': Number\n  , 'string': String\n};\n\nmodule.exports = function hasProperty(name, obj) {\n  var ot = type(obj);\n\n  // Bad Object, obviously no props at all\n  if(ot === 'null' || ot === 'undefined')\n    return false;\n\n  // The `in` operator does not work with certain literals\n  // box these before the check\n  if(literals[ot] && typeof obj !== 'object')\n    obj = new literals[ot](obj);\n\n  return name in obj;\n};\n","/*!\n * chai\n * Copyright(c) 2011 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Main exports\n */\n\nvar exports = module.exports = {};\n\n/*!\n * test utility\n */\n\nexports.test = require('./test');\n\n/*!\n * type utility\n */\n\nexports.type = require('./type');\n\n/*!\n * message utility\n */\n\nexports.getMessage = require('./getMessage');\n\n/*!\n * actual utility\n */\n\nexports.getActual = require('./getActual');\n\n/*!\n * Inspect util\n */\n\nexports.inspect = require('./inspect');\n\n/*!\n * Object Display util\n */\n\nexports.objDisplay = require('./objDisplay');\n\n/*!\n * Flag utility\n */\n\nexports.flag = require('./flag');\n\n/*!\n * Flag transferring utility\n */\n\nexports.transferFlags = require('./transferFlags');\n\n/*!\n * Deep equal utility\n */\n\nexports.eql = require('deep-eql');\n\n/*!\n * Deep path value\n */\n\nexports.getPathValue = require('./getPathValue');\n\n/*!\n * Deep path info\n */\n\nexports.getPathInfo = require('./getPathInfo');\n\n/*!\n * Check if a property exists\n */\n\nexports.hasProperty = require('./hasProperty');\n\n/*!\n * Function name\n */\n\nexports.getName = require('./getName');\n\n/*!\n * add Property\n */\n\nexports.addProperty = require('./addProperty');\n\n/*!\n * add Method\n */\n\nexports.addMethod = require('./addMethod');\n\n/*!\n * overwrite Property\n */\n\nexports.overwriteProperty = require('./overwriteProperty');\n\n/*!\n * overwrite Method\n */\n\nexports.overwriteMethod = require('./overwriteMethod');\n\n/*!\n * Add a chainable method\n */\n\nexports.addChainableMethod = require('./addChainableMethod');\n\n/*!\n * Overwrite chainable method\n */\n\nexports.overwriteChainableMethod = require('./overwriteChainableMethod');\n\n","// This is (almost) directly from Node.js utils\n// https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/util.js\n\nvar getName = require('./getName');\nvar getProperties = require('./getProperties');\nvar getEnumerableProperties = require('./getEnumerableProperties');\n\nmodule.exports = inspect;\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Boolean} showHidden Flag that shows hidden (not enumerable)\n *    properties of objects.\n * @param {Number} depth Depth in which to descend in object. Default is 2.\n * @param {Boolean} colors Flag to turn on ANSI escape codes to color the\n *    output. Default is false (no coloring).\n */\nfunction inspect(obj, showHidden, depth, colors) {\n  var ctx = {\n    showHidden: showHidden,\n    seen: [],\n    stylize: function (str) { return str; }\n  };\n  return formatValue(ctx, obj, (typeof depth === 'undefined' ? 2 : depth));\n}\n\n// Returns true if object is a DOM element.\nvar isDOMElement = function (object) {\n  if (typeof HTMLElement === 'object') {\n    return object instanceof HTMLElement;\n  } else {\n    return object &&\n      typeof object === 'object' &&\n      object.nodeType === 1 &&\n      typeof object.nodeName === 'string';\n  }\n};\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (value && typeof value.inspect === 'function' &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes);\n    if (typeof ret !== 'string') {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // If this is a DOM element, try to get the outer HTML.\n  if (isDOMElement(value)) {\n    if ('outerHTML' in value) {\n      return value.outerHTML;\n      // This value does not have an outerHTML attribute,\n      //   it could still be an XML element\n    } else {\n      // Attempt to serialize it\n      try {\n        if (document.xmlVersion) {\n          var xmlSerializer = new XMLSerializer();\n          return xmlSerializer.serializeToString(value);\n        } else {\n          // Firefox 11- do not support outerHTML\n          //   It does, however, support innerHTML\n          //   Use the following to render the element\n          var ns = \"http://www.w3.org/1999/xhtml\";\n          var container = document.createElementNS(ns, '_');\n\n          container.appendChild(value.cloneNode(false));\n          html = container.innerHTML\n            .replace('><', '>' + value.innerHTML + '<');\n          container.innerHTML = '';\n          return html;\n        }\n      } catch (err) {\n        // This could be a non-native DOM implementation,\n        //   continue with the normal flow:\n        //   printing the element as if it is an object.\n      }\n    }\n  }\n\n  // Look up the keys of the object.\n  var visibleKeys = getEnumerableProperties(value);\n  var keys = ctx.showHidden ? getProperties(value) : visibleKeys;\n\n  // Some type of object without properties can be shortcutted.\n  // In IE, errors have a single `stack` property, or if they are vanilla `Error`,\n  // a `stack` plus `description` property; ignore those for consistency.\n  if (keys.length === 0 || (isError(value) && (\n      (keys.length === 1 && keys[0] === 'stack') ||\n      (keys.length === 2 && keys[0] === 'description' && keys[1] === 'stack')\n     ))) {\n    if (typeof value === 'function') {\n      var name = getName(value);\n      var nameSuffix = name ? ': ' + name : '';\n      return ctx.stylize('[Function' + nameSuffix + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toUTCString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (typeof value === 'function') {\n    var name = getName(value);\n    var nameSuffix = name ? ': ' + name : '';\n    base = ' [Function' + nameSuffix + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    return formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  switch (typeof value) {\n    case 'undefined':\n      return ctx.stylize('undefined', 'undefined');\n\n    case 'string':\n      var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                               .replace(/'/g, \"\\\\'\")\n                                               .replace(/\\\\\"/g, '\"') + '\\'';\n      return ctx.stylize(simple, 'string');\n\n    case 'number':\n      if (value === 0 && (1/value) === -Infinity) {\n        return ctx.stylize('-0', 'number');\n      }\n      return ctx.stylize('' + value, 'number');\n\n    case 'boolean':\n      return ctx.stylize('' + value, 'boolean');\n  }\n  // For some reason typeof null is \"object\", so special case here.\n  if (value === null) {\n    return ctx.stylize('null', 'null');\n  }\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (Object.prototype.hasOwnProperty.call(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str;\n  if (value.__lookupGetter__) {\n    if (value.__lookupGetter__(key)) {\n      if (value.__lookupSetter__(key)) {\n        str = ctx.stylize('[Getter/Setter]', 'special');\n      } else {\n        str = ctx.stylize('[Getter]', 'special');\n      }\n    } else {\n      if (value.__lookupSetter__(key)) {\n        str = ctx.stylize('[Setter]', 'special');\n      }\n    }\n  }\n  if (visibleKeys.indexOf(key) < 0) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(value[key]) < 0) {\n      if (recurseTimes === null) {\n        str = formatValue(ctx, value[key], null);\n      } else {\n        str = formatValue(ctx, value[key], recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (typeof name === 'undefined') {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\nfunction isArray(ar) {\n  return Array.isArray(ar) ||\n         (typeof ar === 'object' && objectToString(ar) === '[object Array]');\n}\n\nfunction isRegExp(re) {\n  return typeof re === 'object' && objectToString(re) === '[object RegExp]';\n}\n\nfunction isDate(d) {\n  return typeof d === 'object' && objectToString(d) === '[object Date]';\n}\n\nfunction isError(e) {\n  return typeof e === 'object' && objectToString(e) === '[object Error]';\n}\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n","/*!\n * Chai - flag utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Module dependancies\n */\n\nvar inspect = require('./inspect');\nvar config = require('../config');\n\n/**\n * ### .objDisplay (object)\n *\n * Determines if an object or an array matches\n * criteria to be inspected in-line for error\n * messages or should be truncated.\n *\n * @param {Mixed} javascript object to inspect\n * @name objDisplay\n * @api public\n */\n\nmodule.exports = function (obj) {\n  var str = inspect(obj)\n    , type = Object.prototype.toString.call(obj);\n\n  if (config.truncateThreshold && str.length >= config.truncateThreshold) {\n    if (type === '[object Function]') {\n      return !obj.name || obj.name === ''\n        ? '[Function]'\n        : '[Function: ' + obj.name + ']';\n    } else if (type === '[object Array]') {\n      return '[ Array(' + obj.length + ') ]';\n    } else if (type === '[object Object]') {\n      var keys = Object.keys(obj)\n        , kstr = keys.length > 2\n          ? keys.splice(0, 2).join(', ') + ', ...'\n          : keys.join(', ');\n      return '{ Object (' + kstr + ') }';\n    } else {\n      return str;\n    }\n  } else {\n    return str;\n  }\n};\n","/*!\n * Chai - overwriteChainableMethod utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### overwriteChainableMethod (ctx, name, method, chainingBehavior)\n *\n * Overwites an already existing chainable method\n * and provides access to the previous function or\n * property.  Must return functions to be used for\n * name.\n *\n *     utils.overwriteChainableMethod(chai.Assertion.prototype, 'length',\n *       function (_super) {\n *       }\n *     , function (_super) {\n *       }\n *     );\n *\n * Can also be accessed directly from `chai.Assertion`.\n *\n *     chai.Assertion.overwriteChainableMethod('foo', fn, fn);\n *\n * Then can be used as any other assertion.\n *\n *     expect(myFoo).to.have.length(3);\n *     expect(myFoo).to.have.length.above(3);\n *\n * @param {Object} ctx object whose method / property is to be overwritten\n * @param {String} name of method / property to overwrite\n * @param {Function} method function that returns a function to be used for name\n * @param {Function} chainingBehavior function that returns a function to be used for property\n * @name overwriteChainableMethod\n * @api public\n */\n\nmodule.exports = function (ctx, name, method, chainingBehavior) {\n  var chainableBehavior = ctx.__methods[name];\n\n  var _chainingBehavior = chainableBehavior.chainingBehavior;\n  chainableBehavior.chainingBehavior = function () {\n    var result = chainingBehavior(_chainingBehavior).call(this);\n    return result === undefined ? this : result;\n  };\n\n  var _method = chainableBehavior.method;\n  chainableBehavior.method = function () {\n    var result = method(_method).apply(this, arguments);\n    return result === undefined ? this : result;\n  };\n};\n","/*!\n * Chai - overwriteMethod utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### overwriteMethod (ctx, name, fn)\n *\n * Overwites an already existing method and provides\n * access to previous function. Must return function\n * to be used for name.\n *\n *     utils.overwriteMethod(chai.Assertion.prototype, 'equal', function (_super) {\n *       return function (str) {\n *         var obj = utils.flag(this, 'object');\n *         if (obj instanceof Foo) {\n *           new chai.Assertion(obj.value).to.equal(str);\n *         } else {\n *           _super.apply(this, arguments);\n *         }\n *       }\n *     });\n *\n * Can also be accessed directly from `chai.Assertion`.\n *\n *     chai.Assertion.overwriteMethod('foo', fn);\n *\n * Then can be used as any other assertion.\n *\n *     expect(myFoo).to.equal('bar');\n *\n * @param {Object} ctx object whose method is to be overwritten\n * @param {String} name of method to overwrite\n * @param {Function} method function that returns a function to be used for name\n * @name overwriteMethod\n * @api public\n */\n\nmodule.exports = function (ctx, name, method) {\n  var _method = ctx[name]\n    , _super = function () { return this; };\n\n  if (_method && 'function' === typeof _method)\n    _super = _method;\n\n  ctx[name] = function () {\n    var result = method(_super).apply(this, arguments);\n    return result === undefined ? this : result;\n  }\n};\n","/*!\n * Chai - overwriteProperty utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### overwriteProperty (ctx, name, fn)\n *\n * Overwites an already existing property getter and provides\n * access to previous value. Must return function to use as getter.\n *\n *     utils.overwriteProperty(chai.Assertion.prototype, 'ok', function (_super) {\n *       return function () {\n *         var obj = utils.flag(this, 'object');\n *         if (obj instanceof Foo) {\n *           new chai.Assertion(obj.name).to.equal('bar');\n *         } else {\n *           _super.call(this);\n *         }\n *       }\n *     });\n *\n *\n * Can also be accessed directly from `chai.Assertion`.\n *\n *     chai.Assertion.overwriteProperty('foo', fn);\n *\n * Then can be used as any other assertion.\n *\n *     expect(myFoo).to.be.ok;\n *\n * @param {Object} ctx object whose property is to be overwritten\n * @param {String} name of property to overwrite\n * @param {Function} getter function that returns a getter function to be used for name\n * @name overwriteProperty\n * @api public\n */\n\nmodule.exports = function (ctx, name, getter) {\n  var _get = Object.getOwnPropertyDescriptor(ctx, name)\n    , _super = function () {};\n\n  if (_get && 'function' === typeof _get.get)\n    _super = _get.get\n\n  Object.defineProperty(ctx, name,\n    { get: function () {\n        var result = getter(_super).call(this);\n        return result === undefined ? this : result;\n      }\n    , configurable: true\n  });\n};\n","/*!\n * Chai - test utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Module dependancies\n */\n\nvar flag = require('./flag');\n\n/**\n * # test(object, expression)\n *\n * Test and object for expression.\n *\n * @param {Object} object (constructed Assertion)\n * @param {Arguments} chai.Assertion.prototype.assert arguments\n */\n\nmodule.exports = function (obj, args) {\n  var negate = flag(obj, 'negate')\n    , expr = args[0];\n  return negate ? !expr : expr;\n};\n","/*!\n * Chai - transferFlags utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/**\n * ### transferFlags(assertion, object, includeAll = true)\n *\n * Transfer all the flags for `assertion` to `object`. If\n * `includeAll` is set to `false`, then the base Chai\n * assertion flags (namely `object`, `ssfi`, and `message`)\n * will not be transferred.\n *\n *\n *     var newAssertion = new Assertion();\n *     utils.transferFlags(assertion, newAssertion);\n *\n *     var anotherAsseriton = new Assertion(myObj);\n *     utils.transferFlags(assertion, anotherAssertion, false);\n *\n * @param {Assertion} assertion the assertion to transfer the flags from\n * @param {Object} object the object to transfer the flags to; usually a new assertion\n * @param {Boolean} includeAll\n * @name transferFlags\n * @api private\n */\n\nmodule.exports = function (assertion, object, includeAll) {\n  var flags = assertion.__flags || (assertion.__flags = Object.create(null));\n\n  if (!object.__flags) {\n    object.__flags = Object.create(null);\n  }\n\n  includeAll = arguments.length === 3 ? includeAll : true;\n\n  for (var flag in flags) {\n    if (includeAll ||\n        (flag !== 'object' && flag !== 'ssfi' && flag != 'message')) {\n      object.__flags[flag] = flags[flag];\n    }\n  }\n};\n","/*!\n * Chai - type utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Detectable javascript natives\n */\n\nvar natives = {\n    '[object Arguments]': 'arguments'\n  , '[object Array]': 'array'\n  , '[object Date]': 'date'\n  , '[object Function]': 'function'\n  , '[object Number]': 'number'\n  , '[object RegExp]': 'regexp'\n  , '[object String]': 'string'\n};\n\n/**\n * ### type(object)\n *\n * Better implementation of `typeof` detection that can\n * be used cross-browser. Handles the inconsistencies of\n * Array, `null`, and `undefined` detection.\n *\n *     utils.type({}) // 'object'\n *     utils.type(null) // `null'\n *     utils.type(undefined) // `undefined`\n *     utils.type([]) // `array`\n *\n * @param {Mixed} object to detect type of\n * @name type\n * @api private\n */\n\nmodule.exports = function (obj) {\n  var str = Object.prototype.toString.call(obj);\n  if (natives[str]) return natives[str];\n  if (obj === null) return 'null';\n  if (obj === undefined) return 'undefined';\n  if (obj === Object(obj)) return 'object';\n  return typeof obj;\n};\n","/*!\n * assertion-error\n * Copyright(c) 2013 Jake Luer <jake@qualiancy.com>\n * MIT Licensed\n */\n\n/*!\n * Return a function that will copy properties from\n * one object to another excluding any originally\n * listed. Returned function will create a new `{}`.\n *\n * @param {String} excluded properties ...\n * @return {Function}\n */\n\nfunction exclude () {\n  var excludes = [].slice.call(arguments);\n\n  function excludeProps (res, obj) {\n    Object.keys(obj).forEach(function (key) {\n      if (!~excludes.indexOf(key)) res[key] = obj[key];\n    });\n  }\n\n  return function extendExclude () {\n    var args = [].slice.call(arguments)\n      , i = 0\n      , res = {};\n\n    for (; i < args.length; i++) {\n      excludeProps(res, args[i]);\n    }\n\n    return res;\n  };\n};\n\n/*!\n * Primary Exports\n */\n\nmodule.exports = AssertionError;\n\n/**\n * ### AssertionError\n *\n * An extension of the JavaScript `Error` constructor for\n * assertion and validation scenarios.\n *\n * @param {String} message\n * @param {Object} properties to include (optional)\n * @param {callee} start stack function (optional)\n */\n\nfunction AssertionError (message, _props, ssf) {\n  var extend = exclude('name', 'message', 'stack', 'constructor', 'toJSON')\n    , props = extend(_props || {});\n\n  // default values\n  this.message = message || 'Unspecified AssertionError';\n  this.showDiff = false;\n\n  // copy from properties\n  for (var key in props) {\n    this[key] = props[key];\n  }\n\n  // capture stack trace\n  ssf = ssf || arguments.callee;\n  if (ssf && Error.captureStackTrace) {\n    Error.captureStackTrace(this, ssf);\n  }\n}\n\n/*!\n * Inherit from Error.prototype\n */\n\nAssertionError.prototype = Object.create(Error.prototype);\n\n/*!\n * Statically set name\n */\n\nAssertionError.prototype.name = 'AssertionError';\n\n/*!\n * Ensure correct constructor\n */\n\nAssertionError.prototype.constructor = AssertionError;\n\n/**\n * Allow errors to be converted to JSON for static transfer.\n *\n * @param {Boolean} include stack (default: `true`)\n * @return {Object} object that can be `JSON.stringify`\n */\n\nAssertionError.prototype.toJSON = function (stack) {\n  var extend = exclude('constructor', 'toJSON', 'stack')\n    , props = extend({ name: this.name }, this);\n\n  // include stack if exists and not turned off\n  if (false !== stack && this.stack) {\n    props.stack = this.stack;\n  }\n\n  return props;\n};\n","module.exports = require('./lib/eql');\n","/*!\n * deep-eql\n * Copyright(c) 2013 Jake Luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Module dependencies\n */\n\nvar type = require('type-detect');\n\n/*!\n * Buffer.isBuffer browser shim\n */\n\nvar Buffer;\ntry { Buffer = require('buffer').Buffer; }\ncatch(ex) {\n  Buffer = {};\n  Buffer.isBuffer = function() { return false; }\n}\n\n/*!\n * Primary Export\n */\n\nmodule.exports = deepEqual;\n\n/**\n * Assert super-strict (egal) equality between\n * two objects of any type.\n *\n * @param {Mixed} a\n * @param {Mixed} b\n * @param {Array} memoised (optional)\n * @return {Boolean} equal match\n */\n\nfunction deepEqual(a, b, m) {\n  if (sameValue(a, b)) {\n    return true;\n  } else if ('date' === type(a)) {\n    return dateEqual(a, b);\n  } else if ('regexp' === type(a)) {\n    return regexpEqual(a, b);\n  } else if (Buffer.isBuffer(a)) {\n    return bufferEqual(a, b);\n  } else if ('arguments' === type(a)) {\n    return argumentsEqual(a, b, m);\n  } else if (!typeEqual(a, b)) {\n    return false;\n  } else if (('object' !== type(a) && 'object' !== type(b))\n  && ('array' !== type(a) && 'array' !== type(b))) {\n    return sameValue(a, b);\n  } else {\n    return objectEqual(a, b, m);\n  }\n}\n\n/*!\n * Strict (egal) equality test. Ensures that NaN always\n * equals NaN and `-0` does not equal `+0`.\n *\n * @param {Mixed} a\n * @param {Mixed} b\n * @return {Boolean} equal match\n */\n\nfunction sameValue(a, b) {\n  if (a === b) return a !== 0 || 1 / a === 1 / b;\n  return a !== a && b !== b;\n}\n\n/*!\n * Compare the types of two given objects and\n * return if they are equal. Note that an Array\n * has a type of `array` (not `object`) and arguments\n * have a type of `arguments` (not `array`/`object`).\n *\n * @param {Mixed} a\n * @param {Mixed} b\n * @return {Boolean} result\n */\n\nfunction typeEqual(a, b) {\n  return type(a) === type(b);\n}\n\n/*!\n * Compare two Date objects by asserting that\n * the time values are equal using `saveValue`.\n *\n * @param {Date} a\n * @param {Date} b\n * @return {Boolean} result\n */\n\nfunction dateEqual(a, b) {\n  if ('date' !== type(b)) return false;\n  return sameValue(a.getTime(), b.getTime());\n}\n\n/*!\n * Compare two regular expressions by converting them\n * to string and checking for `sameValue`.\n *\n * @param {RegExp} a\n * @param {RegExp} b\n * @return {Boolean} result\n */\n\nfunction regexpEqual(a, b) {\n  if ('regexp' !== type(b)) return false;\n  return sameValue(a.toString(), b.toString());\n}\n\n/*!\n * Assert deep equality of two `arguments` objects.\n * Unfortunately, these must be sliced to arrays\n * prior to test to ensure no bad behavior.\n *\n * @param {Arguments} a\n * @param {Arguments} b\n * @param {Array} memoize (optional)\n * @return {Boolean} result\n */\n\nfunction argumentsEqual(a, b, m) {\n  if ('arguments' !== type(b)) return false;\n  a = [].slice.call(a);\n  b = [].slice.call(b);\n  return deepEqual(a, b, m);\n}\n\n/*!\n * Get enumerable properties of a given object.\n *\n * @param {Object} a\n * @return {Array} property names\n */\n\nfunction enumerable(a) {\n  var res = [];\n  for (var key in a) res.push(key);\n  return res;\n}\n\n/*!\n * Simple equality for flat iterable objects\n * such as Arrays or Node.js buffers.\n *\n * @param {Iterable} a\n * @param {Iterable} b\n * @return {Boolean} result\n */\n\nfunction iterableEqual(a, b) {\n  if (a.length !==  b.length) return false;\n\n  var i = 0;\n  var match = true;\n\n  for (; i < a.length; i++) {\n    if (a[i] !== b[i]) {\n      match = false;\n      break;\n    }\n  }\n\n  return match;\n}\n\n/*!\n * Extension to `iterableEqual` specifically\n * for Node.js Buffers.\n *\n * @param {Buffer} a\n * @param {Mixed} b\n * @return {Boolean} result\n */\n\nfunction bufferEqual(a, b) {\n  if (!Buffer.isBuffer(b)) return false;\n  return iterableEqual(a, b);\n}\n\n/*!\n * Block for `objectEqual` ensuring non-existing\n * values don't get in.\n *\n * @param {Mixed} object\n * @return {Boolean} result\n */\n\nfunction isValue(a) {\n  return a !== null && a !== undefined;\n}\n\n/*!\n * Recursively check the equality of two objects.\n * Once basic sameness has been established it will\n * defer to `deepEqual` for each enumerable key\n * in the object.\n *\n * @param {Mixed} a\n * @param {Mixed} b\n * @return {Boolean} result\n */\n\nfunction objectEqual(a, b, m) {\n  if (!isValue(a) || !isValue(b)) {\n    return false;\n  }\n\n  if (a.prototype !== b.prototype) {\n    return false;\n  }\n\n  var i;\n  if (m) {\n    for (i = 0; i < m.length; i++) {\n      if ((m[i][0] === a && m[i][1] === b)\n      ||  (m[i][0] === b && m[i][1] === a)) {\n        return true;\n      }\n    }\n  } else {\n    m = [];\n  }\n\n  try {\n    var ka = enumerable(a);\n    var kb = enumerable(b);\n  } catch (ex) {\n    return false;\n  }\n\n  ka.sort();\n  kb.sort();\n\n  if (!iterableEqual(ka, kb)) {\n    return false;\n  }\n\n  m.push([ a, b ]);\n\n  var key;\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!deepEqual(a[key], b[key], m)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n","module.exports = require('./lib/type');\n","/*!\n * type-detect\n * Copyright(c) 2013 jake luer <jake@alogicalparadox.com>\n * MIT Licensed\n */\n\n/*!\n * Primary Exports\n */\n\nvar exports = module.exports = getType;\n\n/*!\n * Detectable javascript natives\n */\n\nvar natives = {\n    '[object Array]': 'array'\n  , '[object RegExp]': 'regexp'\n  , '[object Function]': 'function'\n  , '[object Arguments]': 'arguments'\n  , '[object Date]': 'date'\n};\n\n/**\n * ### typeOf (obj)\n *\n * Use several different techniques to determine\n * the type of object being tested.\n *\n *\n * @param {Mixed} object\n * @return {String} object type\n * @api public\n */\n\nfunction getType (obj) {\n  var str = Object.prototype.toString.call(obj);\n  if (natives[str]) return natives[str];\n  if (obj === null) return 'null';\n  if (obj === undefined) return 'undefined';\n  if (obj === Object(obj)) return 'object';\n  return typeof obj;\n}\n\nexports.Library = Library;\n\n/**\n * ### Library\n *\n * Create a repository for custom type detection.\n *\n * ```js\n * var lib = new type.Library;\n * ```\n *\n */\n\nfunction Library () {\n  this.tests = {};\n}\n\n/**\n * #### .of (obj)\n *\n * Expose replacement `typeof` detection to the library.\n *\n * ```js\n * if ('string' === lib.of('hello world')) {\n *   // ...\n * }\n * ```\n *\n * @param {Mixed} object to test\n * @return {String} type\n */\n\nLibrary.prototype.of = getType;\n\n/**\n * #### .define (type, test)\n *\n * Add a test to for the `.test()` assertion.\n *\n * Can be defined as a regular expression:\n *\n * ```js\n * lib.define('int', /^[0-9]+$/);\n * ```\n *\n * ... or as a function:\n *\n * ```js\n * lib.define('bln', function (obj) {\n *   if ('boolean' === lib.of(obj)) return true;\n *   var blns = [ 'yes', 'no', 'true', 'false', 1, 0 ];\n *   if ('string' === lib.of(obj)) obj = obj.toLowerCase();\n *   return !! ~blns.indexOf(obj);\n * });\n * ```\n *\n * @param {String} type\n * @param {RegExp|Function} test\n * @api public\n */\n\nLibrary.prototype.define = function (type, test) {\n  if (arguments.length === 1) return this.tests[type];\n  this.tests[type] = test;\n  return this;\n};\n\n/**\n * #### .test (obj, test)\n *\n * Assert that an object is of type. Will first\n * check natives, and if that does not pass it will\n * use the user defined custom tests.\n *\n * ```js\n * assert(lib.test('1', 'int'));\n * assert(lib.test('yes', 'bln'));\n * ```\n *\n * @param {Mixed} object\n * @param {String} type\n * @return {Boolean} result\n * @api public\n */\n\nLibrary.prototype.test = function (obj, type) {\n  if (type === getType(obj)) return true;\n  var test = this.tests[type];\n\n  if (test && 'regexp' === getType(test)) {\n    return test.test(obj);\n  } else if (test && 'function' === getType(test)) {\n    return test(obj);\n  } else {\n    throw new ReferenceError('Type test \"' + type + '\" not defined or invalid.');\n  }\n};\n","(function (sinonChai) {\n    \"use strict\";\n\n    // Module systems magic dance.\n\n    /* istanbul ignore else */\n    if (typeof require === \"function\" && typeof exports === \"object\" && typeof module === \"object\") {\n        // NodeJS\n        module.exports = sinonChai;\n    } else if (typeof define === \"function\" && define.amd) {\n        // AMD\n        define(function () {\n            return sinonChai;\n        });\n    } else {\n        // Other environment (usually <script> tag): plug in to global chai instance directly.\n        chai.use(sinonChai);\n    }\n}(function sinonChai(chai, utils) {\n    \"use strict\";\n\n    var slice = Array.prototype.slice;\n\n    function isSpy(putativeSpy) {\n        return typeof putativeSpy === \"function\" &&\n               typeof putativeSpy.getCall === \"function\" &&\n               typeof putativeSpy.calledWithExactly === \"function\";\n    }\n\n    function timesInWords(count) {\n        return count === 1 ? \"once\" :\n               count === 2 ? \"twice\" :\n               count === 3 ? \"thrice\" :\n               (count || 0) + \" times\";\n    }\n\n    function isCall(putativeCall) {\n        return putativeCall && isSpy(putativeCall.proxy);\n    }\n\n    function assertCanWorkWith(assertion) {\n        if (!isSpy(assertion._obj) && !isCall(assertion._obj)) {\n            throw new TypeError(utils.inspect(assertion._obj) + \" is not a spy or a call to a spy!\");\n        }\n    }\n\n    function getMessages(spy, action, nonNegatedSuffix, always, args) {\n        var verbPhrase = always ? \"always have \" : \"have \";\n        nonNegatedSuffix = nonNegatedSuffix || \"\";\n        if (isSpy(spy.proxy)) {\n            spy = spy.proxy;\n        }\n\n        function printfArray(array) {\n            return spy.printf.apply(spy, array);\n        }\n\n        return {\n            affirmative: function () {\n                return printfArray([\"expected %n to \" + verbPhrase + action + nonNegatedSuffix].concat(args));\n            },\n            negative: function () {\n                return printfArray([\"expected %n to not \" + verbPhrase + action].concat(args));\n            }\n        };\n    }\n\n    function sinonProperty(name, action, nonNegatedSuffix) {\n        utils.addProperty(chai.Assertion.prototype, name, function () {\n            assertCanWorkWith(this);\n\n            var messages = getMessages(this._obj, action, nonNegatedSuffix, false);\n            this.assert(this._obj[name], messages.affirmative, messages.negative);\n        });\n    }\n\n    function sinonPropertyAsBooleanMethod(name, action, nonNegatedSuffix) {\n        utils.addMethod(chai.Assertion.prototype, name, function (arg) {\n            assertCanWorkWith(this);\n\n            var messages = getMessages(this._obj, action, nonNegatedSuffix, false, [timesInWords(arg)]);\n            this.assert(this._obj[name] === arg, messages.affirmative, messages.negative);\n        });\n    }\n\n    function createSinonMethodHandler(sinonName, action, nonNegatedSuffix) {\n        return function () {\n            assertCanWorkWith(this);\n\n            var alwaysSinonMethod = \"always\" + sinonName[0].toUpperCase() + sinonName.substring(1);\n            var shouldBeAlways = utils.flag(this, \"always\") && typeof this._obj[alwaysSinonMethod] === \"function\";\n            var sinonMethod = shouldBeAlways ? alwaysSinonMethod : sinonName;\n\n            var messages = getMessages(this._obj, action, nonNegatedSuffix, shouldBeAlways, slice.call(arguments));\n            this.assert(this._obj[sinonMethod].apply(this._obj, arguments), messages.affirmative, messages.negative);\n        };\n    }\n\n    function sinonMethodAsProperty(name, action, nonNegatedSuffix) {\n        var handler = createSinonMethodHandler(name, action, nonNegatedSuffix);\n        utils.addProperty(chai.Assertion.prototype, name, handler);\n    }\n\n    function exceptionalSinonMethod(chaiName, sinonName, action, nonNegatedSuffix) {\n        var handler = createSinonMethodHandler(sinonName, action, nonNegatedSuffix);\n        utils.addMethod(chai.Assertion.prototype, chaiName, handler);\n    }\n\n    function sinonMethod(name, action, nonNegatedSuffix) {\n        exceptionalSinonMethod(name, name, action, nonNegatedSuffix);\n    }\n\n    utils.addProperty(chai.Assertion.prototype, \"always\", function () {\n        utils.flag(this, \"always\", true);\n    });\n\n    sinonProperty(\"called\", \"been called\", \" at least once, but it was never called\");\n    sinonPropertyAsBooleanMethod(\"callCount\", \"been called exactly %1\", \", but it was called %c%C\");\n    sinonProperty(\"calledOnce\", \"been called exactly once\", \", but it was called %c%C\");\n    sinonProperty(\"calledTwice\", \"been called exactly twice\", \", but it was called %c%C\");\n    sinonProperty(\"calledThrice\", \"been called exactly thrice\", \", but it was called %c%C\");\n    sinonMethodAsProperty(\"calledWithNew\", \"been called with new\");\n    sinonMethod(\"calledBefore\", \"been called before %1\");\n    sinonMethod(\"calledAfter\", \"been called after %1\");\n    sinonMethod(\"calledOn\", \"been called with %1 as this\", \", but it was called with %t instead\");\n    sinonMethod(\"calledWith\", \"been called with arguments %*\", \"%C\");\n    sinonMethod(\"calledWithExactly\", \"been called with exact arguments %*\", \"%C\");\n    sinonMethod(\"calledWithMatch\", \"been called with arguments matching %*\", \"%C\");\n    sinonMethod(\"returned\", \"returned %1\");\n    exceptionalSinonMethod(\"thrown\", \"threw\", \"thrown %1\");\n}));\n","/**\n * Sinon core utilities. For internal use only.\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2013 Christian Johansen\n */\n\"use strict\";\n\nvar sinon = (function () {\n    var sinon;\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require === \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports, module) {\n        sinon = module.exports = require(\"./sinon/util/core\");\n        require(\"./sinon/extend\");\n        require(\"./sinon/typeOf\");\n        require(\"./sinon/times_in_words\");\n        require(\"./sinon/spy\");\n        require(\"./sinon/call\");\n        require(\"./sinon/behavior\");\n        require(\"./sinon/stub\");\n        require(\"./sinon/mock\");\n        require(\"./sinon/collection\");\n        require(\"./sinon/assert\");\n        require(\"./sinon/sandbox\");\n        require(\"./sinon/test\");\n        require(\"./sinon/test_case\");\n        require(\"./sinon/match\");\n        require(\"./sinon/format\");\n        require(\"./sinon/log_error\");\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n        sinon = module.exports;\n    } else {\n        sinon = {};\n    }\n\n    return sinon;\n}());\n","(function (global){\n/**\n * @depend times_in_words.js\n * @depend util/core.js\n * @depend match.js\n * @depend format.js\n */\n/**\n * Assertions matching the test spy retrieval interface.\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2013 Christian Johansen\n */\n\"use strict\";\n\n(function (sinon, global) {\n    var slice = Array.prototype.slice;\n\n    function makeApi(sinon) {\n        var assert;\n\n        function verifyIsStub() {\n            var method;\n\n            for (var i = 0, l = arguments.length; i < l; ++i) {\n                method = arguments[i];\n\n                if (!method) {\n                    assert.fail(\"fake is not a spy\");\n                }\n\n                if (method.proxy) {\n                    verifyIsStub(method.proxy);\n                } else {\n                    if (typeof method != \"function\") {\n                        assert.fail(method + \" is not a function\");\n                    }\n\n                    if (typeof method.getCall != \"function\") {\n                        assert.fail(method + \" is not stubbed\");\n                    }\n                }\n\n            }\n        }\n\n        function failAssertion(object, msg) {\n            object = object || global;\n            var failMethod = object.fail || assert.fail;\n            failMethod.call(object, msg);\n        }\n\n        function mirrorPropAsAssertion(name, method, message) {\n            if (arguments.length == 2) {\n                message = method;\n                method = name;\n            }\n\n            assert[name] = function (fake) {\n                verifyIsStub(fake);\n\n                var args = slice.call(arguments, 1);\n                var failed = false;\n\n                if (typeof method == \"function\") {\n                    failed = !method(fake);\n                } else {\n                    failed = typeof fake[method] == \"function\" ?\n                        !fake[method].apply(fake, args) : !fake[method];\n                }\n\n                if (failed) {\n                    failAssertion(this, (fake.printf || fake.proxy.printf).apply(fake, [message].concat(args)));\n                } else {\n                    assert.pass(name);\n                }\n            };\n        }\n\n        function exposedName(prefix, prop) {\n            return !prefix || /^fail/.test(prop) ? prop :\n                prefix + prop.slice(0, 1).toUpperCase() + prop.slice(1);\n        }\n\n        assert = {\n            failException: \"AssertError\",\n\n            fail: function fail(message) {\n                var error = new Error(message);\n                error.name = this.failException || assert.failException;\n\n                throw error;\n            },\n\n            pass: function pass(assertion) {},\n\n            callOrder: function assertCallOrder() {\n                verifyIsStub.apply(null, arguments);\n                var expected = \"\", actual = \"\";\n\n                if (!sinon.calledInOrder(arguments)) {\n                    try {\n                        expected = [].join.call(arguments, \", \");\n                        var calls = slice.call(arguments);\n                        var i = calls.length;\n                        while (i) {\n                            if (!calls[--i].called) {\n                                calls.splice(i, 1);\n                            }\n                        }\n                        actual = sinon.orderByFirstCall(calls).join(\", \");\n                    } catch (e) {\n                        // If this fails, we'll just fall back to the blank string\n                    }\n\n                    failAssertion(this, \"expected \" + expected + \" to be \" +\n                                \"called in order but were called as \" + actual);\n                } else {\n                    assert.pass(\"callOrder\");\n                }\n            },\n\n            callCount: function assertCallCount(method, count) {\n                verifyIsStub(method);\n\n                if (method.callCount != count) {\n                    var msg = \"expected %n to be called \" + sinon.timesInWords(count) +\n                        \" but was called %c%C\";\n                    failAssertion(this, method.printf(msg));\n                } else {\n                    assert.pass(\"callCount\");\n                }\n            },\n\n            expose: function expose(target, options) {\n                if (!target) {\n                    throw new TypeError(\"target is null or undefined\");\n                }\n\n                var o = options || {};\n                var prefix = typeof o.prefix == \"undefined\" && \"assert\" || o.prefix;\n                var includeFail = typeof o.includeFail == \"undefined\" || !!o.includeFail;\n\n                for (var method in this) {\n                    if (method != \"expose\" && (includeFail || !/^(fail)/.test(method))) {\n                        target[exposedName(prefix, method)] = this[method];\n                    }\n                }\n\n                return target;\n            },\n\n            match: function match(actual, expectation) {\n                var matcher = sinon.match(expectation);\n                if (matcher.test(actual)) {\n                    assert.pass(\"match\");\n                } else {\n                    var formatted = [\n                        \"expected value to match\",\n                        \"    expected = \" + sinon.format(expectation),\n                        \"    actual = \" + sinon.format(actual)\n                    ]\n                    failAssertion(this, formatted.join(\"\\n\"));\n                }\n            }\n        };\n\n        mirrorPropAsAssertion(\"called\", \"expected %n to have been called at least once but was never called\");\n        mirrorPropAsAssertion(\"notCalled\", function (spy) { return !spy.called; },\n                            \"expected %n to not have been called but was called %c%C\");\n        mirrorPropAsAssertion(\"calledOnce\", \"expected %n to be called once but was called %c%C\");\n        mirrorPropAsAssertion(\"calledTwice\", \"expected %n to be called twice but was called %c%C\");\n        mirrorPropAsAssertion(\"calledThrice\", \"expected %n to be called thrice but was called %c%C\");\n        mirrorPropAsAssertion(\"calledOn\", \"expected %n to be called with %1 as this but was called with %t\");\n        mirrorPropAsAssertion(\"alwaysCalledOn\", \"expected %n to always be called with %1 as this but was called with %t\");\n        mirrorPropAsAssertion(\"calledWithNew\", \"expected %n to be called with new\");\n        mirrorPropAsAssertion(\"alwaysCalledWithNew\", \"expected %n to always be called with new\");\n        mirrorPropAsAssertion(\"calledWith\", \"expected %n to be called with arguments %*%C\");\n        mirrorPropAsAssertion(\"calledWithMatch\", \"expected %n to be called with match %*%C\");\n        mirrorPropAsAssertion(\"alwaysCalledWith\", \"expected %n to always be called with arguments %*%C\");\n        mirrorPropAsAssertion(\"alwaysCalledWithMatch\", \"expected %n to always be called with match %*%C\");\n        mirrorPropAsAssertion(\"calledWithExactly\", \"expected %n to be called with exact arguments %*%C\");\n        mirrorPropAsAssertion(\"alwaysCalledWithExactly\", \"expected %n to always be called with exact arguments %*%C\");\n        mirrorPropAsAssertion(\"neverCalledWith\", \"expected %n to never be called with arguments %*%C\");\n        mirrorPropAsAssertion(\"neverCalledWithMatch\", \"expected %n to never be called with match %*%C\");\n        mirrorPropAsAssertion(\"threw\", \"%n did not throw exception%C\");\n        mirrorPropAsAssertion(\"alwaysThrew\", \"%n did not always throw exception%C\");\n\n        sinon.assert = assert;\n        return assert;\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        require(\"./match\");\n        require(\"./format\");\n        module.exports = makeApi(sinon);\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n\n}(typeof sinon == \"object\" && sinon || null, typeof window != \"undefined\" ? window : (typeof self != \"undefined\") ? self : global));\n\n}).call(this,typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})","(function (process){\n/**\n * @depend util/core.js\n * @depend extend.js\n */\n/**\n * Stub behavior\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @author Tim Fischbach (mail@timfischbach.de)\n * @license BSD\n *\n * Copyright (c) 2010-2013 Christian Johansen\n */\n\"use strict\";\n\n(function (sinon) {\n    var slice = Array.prototype.slice;\n    var join = Array.prototype.join;\n    var useLeftMostCallback = -1;\n    var useRightMostCallback = -2;\n\n    var nextTick = (function () {\n        if (typeof process === \"object\" && typeof process.nextTick === \"function\") {\n            return process.nextTick;\n        } else if (typeof setImmediate === \"function\") {\n            return setImmediate;\n        } else {\n            return function (callback) {\n                setTimeout(callback, 0);\n            };\n        }\n    })();\n\n    function throwsException(error, message) {\n        if (typeof error == \"string\") {\n            this.exception = new Error(message || \"\");\n            this.exception.name = error;\n        } else if (!error) {\n            this.exception = new Error(\"Error\");\n        } else {\n            this.exception = error;\n        }\n\n        return this;\n    }\n\n    function getCallback(behavior, args) {\n        var callArgAt = behavior.callArgAt;\n\n        if (callArgAt >= 0) {\n            return args[callArgAt];\n        }\n\n        var argumentList;\n\n        if (callArgAt === useLeftMostCallback) {\n            argumentList = args;\n        }\n\n        if (callArgAt === useRightMostCallback) {\n            argumentList = slice.call(args).reverse();\n        }\n\n        var callArgProp = behavior.callArgProp;\n\n        for (var i = 0, l = argumentList.length; i < l; ++i) {\n            if (!callArgProp && typeof argumentList[i] == \"function\") {\n                return argumentList[i];\n            }\n\n            if (callArgProp && argumentList[i] &&\n                typeof argumentList[i][callArgProp] == \"function\") {\n                return argumentList[i][callArgProp];\n            }\n        }\n\n        return null;\n    }\n\n    function makeApi(sinon) {\n        function getCallbackError(behavior, func, args) {\n            if (behavior.callArgAt < 0) {\n                var msg;\n\n                if (behavior.callArgProp) {\n                    msg = sinon.functionName(behavior.stub) +\n                        \" expected to yield to '\" + behavior.callArgProp +\n                        \"', but no object with such a property was passed.\";\n                } else {\n                    msg = sinon.functionName(behavior.stub) +\n                        \" expected to yield, but no callback was passed.\";\n                }\n\n                if (args.length > 0) {\n                    msg += \" Received [\" + join.call(args, \", \") + \"]\";\n                }\n\n                return msg;\n            }\n\n            return \"argument at index \" + behavior.callArgAt + \" is not a function: \" + func;\n        }\n\n        function callCallback(behavior, args) {\n            if (typeof behavior.callArgAt == \"number\") {\n                var func = getCallback(behavior, args);\n\n                if (typeof func != \"function\") {\n                    throw new TypeError(getCallbackError(behavior, func, args));\n                }\n\n                if (behavior.callbackAsync) {\n                    nextTick(function () {\n                        func.apply(behavior.callbackContext, behavior.callbackArguments);\n                    });\n                } else {\n                    func.apply(behavior.callbackContext, behavior.callbackArguments);\n                }\n            }\n        }\n\n        var proto = {\n            create: function create(stub) {\n                var behavior = sinon.extend({}, sinon.behavior);\n                delete behavior.create;\n                behavior.stub = stub;\n\n                return behavior;\n            },\n\n            isPresent: function isPresent() {\n                return (typeof this.callArgAt == \"number\" ||\n                        this.exception ||\n                        typeof this.returnArgAt == \"number\" ||\n                        this.returnThis ||\n                        this.returnValueDefined);\n            },\n\n            invoke: function invoke(context, args) {\n                callCallback(this, args);\n\n                if (this.exception) {\n                    throw this.exception;\n                } else if (typeof this.returnArgAt == \"number\") {\n                    return args[this.returnArgAt];\n                } else if (this.returnThis) {\n                    return context;\n                }\n\n                return this.returnValue;\n            },\n\n            onCall: function onCall(index) {\n                return this.stub.onCall(index);\n            },\n\n            onFirstCall: function onFirstCall() {\n                return this.stub.onFirstCall();\n            },\n\n            onSecondCall: function onSecondCall() {\n                return this.stub.onSecondCall();\n            },\n\n            onThirdCall: function onThirdCall() {\n                return this.stub.onThirdCall();\n            },\n\n            withArgs: function withArgs(/* arguments */) {\n                throw new Error(\"Defining a stub by invoking \\\"stub.onCall(...).withArgs(...)\\\" is not supported. \" +\n                                \"Use \\\"stub.withArgs(...).onCall(...)\\\" to define sequential behavior for calls with certain arguments.\");\n            },\n\n            callsArg: function callsArg(pos) {\n                if (typeof pos != \"number\") {\n                    throw new TypeError(\"argument index is not number\");\n                }\n\n                this.callArgAt = pos;\n                this.callbackArguments = [];\n                this.callbackContext = undefined;\n                this.callArgProp = undefined;\n                this.callbackAsync = false;\n\n                return this;\n            },\n\n            callsArgOn: function callsArgOn(pos, context) {\n                if (typeof pos != \"number\") {\n                    throw new TypeError(\"argument index is not number\");\n                }\n                if (typeof context != \"object\") {\n                    throw new TypeError(\"argument context is not an object\");\n                }\n\n                this.callArgAt = pos;\n                this.callbackArguments = [];\n                this.callbackContext = context;\n                this.callArgProp = undefined;\n                this.callbackAsync = false;\n\n                return this;\n            },\n\n            callsArgWith: function callsArgWith(pos) {\n                if (typeof pos != \"number\") {\n                    throw new TypeError(\"argument index is not number\");\n                }\n\n                this.callArgAt = pos;\n                this.callbackArguments = slice.call(arguments, 1);\n                this.callbackContext = undefined;\n                this.callArgProp = undefined;\n                this.callbackAsync = false;\n\n                return this;\n            },\n\n            callsArgOnWith: function callsArgWith(pos, context) {\n                if (typeof pos != \"number\") {\n                    throw new TypeError(\"argument index is not number\");\n                }\n                if (typeof context != \"object\") {\n                    throw new TypeError(\"argument context is not an object\");\n                }\n\n                this.callArgAt = pos;\n                this.callbackArguments = slice.call(arguments, 2);\n                this.callbackContext = context;\n                this.callArgProp = undefined;\n                this.callbackAsync = false;\n\n                return this;\n            },\n\n            yields: function () {\n                this.callArgAt = useLeftMostCallback;\n                this.callbackArguments = slice.call(arguments, 0);\n                this.callbackContext = undefined;\n                this.callArgProp = undefined;\n                this.callbackAsync = false;\n\n                return this;\n            },\n\n            yieldsRight: function () {\n                this.callArgAt = useRightMostCallback;\n                this.callbackArguments = slice.call(arguments, 0);\n                this.callbackContext = undefined;\n                this.callArgProp = undefined;\n                this.callbackAsync = false;\n\n                return this;\n            },\n\n            yieldsOn: function (context) {\n                if (typeof context != \"object\") {\n                    throw new TypeError(\"argument context is not an object\");\n                }\n\n                this.callArgAt = useLeftMostCallback;\n                this.callbackArguments = slice.call(arguments, 1);\n                this.callbackContext = context;\n                this.callArgProp = undefined;\n                this.callbackAsync = false;\n\n                return this;\n            },\n\n            yieldsTo: function (prop) {\n                this.callArgAt = useLeftMostCallback;\n                this.callbackArguments = slice.call(arguments, 1);\n                this.callbackContext = undefined;\n                this.callArgProp = prop;\n                this.callbackAsync = false;\n\n                return this;\n            },\n\n            yieldsToOn: function (prop, context) {\n                if (typeof context != \"object\") {\n                    throw new TypeError(\"argument context is not an object\");\n                }\n\n                this.callArgAt = useLeftMostCallback;\n                this.callbackArguments = slice.call(arguments, 2);\n                this.callbackContext = context;\n                this.callArgProp = prop;\n                this.callbackAsync = false;\n\n                return this;\n            },\n\n            throws: throwsException,\n            throwsException: throwsException,\n\n            returns: function returns(value) {\n                this.returnValue = value;\n                this.returnValueDefined = true;\n\n                return this;\n            },\n\n            returnsArg: function returnsArg(pos) {\n                if (typeof pos != \"number\") {\n                    throw new TypeError(\"argument index is not number\");\n                }\n\n                this.returnArgAt = pos;\n\n                return this;\n            },\n\n            returnsThis: function returnsThis() {\n                this.returnThis = true;\n\n                return this;\n            }\n        };\n\n        // create asynchronous versions of callsArg* and yields* methods\n        for (var method in proto) {\n            // need to avoid creating anotherasync versions of the newly added async methods\n            if (proto.hasOwnProperty(method) &&\n                method.match(/^(callsArg|yields)/) &&\n                !method.match(/Async/)) {\n                proto[method + \"Async\"] = (function (syncFnName) {\n                    return function () {\n                        var result = this[syncFnName].apply(this, arguments);\n                        this.callbackAsync = true;\n                        return result;\n                    };\n                })(method);\n            }\n        }\n\n        sinon.behavior = proto;\n        return proto;\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        require(\"./extend\");\n        module.exports = makeApi(sinon);\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n}(typeof sinon == \"object\" && sinon || null));\n\n}).call(this,require(\"1YiZ5S\"))","/**\n  * @depend util/core.js\n  * @depend match.js\n  * @depend format.js\n  */\n/**\n  * Spy calls\n  *\n  * @author Christian Johansen (christian@cjohansen.no)\n  * @author Maximilian Antoni (mail@maxantoni.de)\n  * @license BSD\n  *\n  * Copyright (c) 2010-2013 Christian Johansen\n  * Copyright (c) 2013 Maximilian Antoni\n  */\n\"use strict\";\n\n(function (sinon) {\n    function makeApi(sinon) {\n        function throwYieldError(proxy, text, args) {\n            var msg = sinon.functionName(proxy) + text;\n            if (args.length) {\n                msg += \" Received [\" + slice.call(args).join(\", \") + \"]\";\n            }\n            throw new Error(msg);\n        }\n\n        var slice = Array.prototype.slice;\n\n        var callProto = {\n            calledOn: function calledOn(thisValue) {\n                if (sinon.match && sinon.match.isMatcher(thisValue)) {\n                    return thisValue.test(this.thisValue);\n                }\n                return this.thisValue === thisValue;\n            },\n\n            calledWith: function calledWith() {\n                var l = arguments.length;\n                if (l > this.args.length) {\n                    return false;\n                }\n                for (var i = 0; i < l; i += 1) {\n                    if (!sinon.deepEqual(arguments[i], this.args[i])) {\n                        return false;\n                    }\n                }\n\n                return true;\n            },\n\n            calledWithMatch: function calledWithMatch() {\n                var l = arguments.length;\n                if (l > this.args.length) {\n                    return false;\n                }\n                for (var i = 0; i < l; i += 1) {\n                    var actual = this.args[i];\n                    var expectation = arguments[i];\n                    if (!sinon.match || !sinon.match(expectation).test(actual)) {\n                        return false;\n                    }\n                }\n                return true;\n            },\n\n            calledWithExactly: function calledWithExactly() {\n                return arguments.length == this.args.length &&\n                    this.calledWith.apply(this, arguments);\n            },\n\n            notCalledWith: function notCalledWith() {\n                return !this.calledWith.apply(this, arguments);\n            },\n\n            notCalledWithMatch: function notCalledWithMatch() {\n                return !this.calledWithMatch.apply(this, arguments);\n            },\n\n            returned: function returned(value) {\n                return sinon.deepEqual(value, this.returnValue);\n            },\n\n            threw: function threw(error) {\n                if (typeof error === \"undefined\" || !this.exception) {\n                    return !!this.exception;\n                }\n\n                return this.exception === error || this.exception.name === error;\n            },\n\n            calledWithNew: function calledWithNew() {\n                return this.proxy.prototype && this.thisValue instanceof this.proxy;\n            },\n\n            calledBefore: function (other) {\n                return this.callId < other.callId;\n            },\n\n            calledAfter: function (other) {\n                return this.callId > other.callId;\n            },\n\n            callArg: function (pos) {\n                this.args[pos]();\n            },\n\n            callArgOn: function (pos, thisValue) {\n                this.args[pos].apply(thisValue);\n            },\n\n            callArgWith: function (pos) {\n                this.callArgOnWith.apply(this, [pos, null].concat(slice.call(arguments, 1)));\n            },\n\n            callArgOnWith: function (pos, thisValue) {\n                var args = slice.call(arguments, 2);\n                this.args[pos].apply(thisValue, args);\n            },\n\n            yield: function () {\n                this.yieldOn.apply(this, [null].concat(slice.call(arguments, 0)));\n            },\n\n            yieldOn: function (thisValue) {\n                var args = this.args;\n                for (var i = 0, l = args.length; i < l; ++i) {\n                    if (typeof args[i] === \"function\") {\n                        args[i].apply(thisValue, slice.call(arguments, 1));\n                        return;\n                    }\n                }\n                throwYieldError(this.proxy, \" cannot yield since no callback was passed.\", args);\n            },\n\n            yieldTo: function (prop) {\n                this.yieldToOn.apply(this, [prop, null].concat(slice.call(arguments, 1)));\n            },\n\n            yieldToOn: function (prop, thisValue) {\n                var args = this.args;\n                for (var i = 0, l = args.length; i < l; ++i) {\n                    if (args[i] && typeof args[i][prop] === \"function\") {\n                        args[i][prop].apply(thisValue, slice.call(arguments, 2));\n                        return;\n                    }\n                }\n                throwYieldError(this.proxy, \" cannot yield to '\" + prop +\n                    \"' since no callback was passed.\", args);\n            },\n\n            toString: function () {\n                var callStr = this.proxy.toString() + \"(\";\n                var args = [];\n\n                for (var i = 0, l = this.args.length; i < l; ++i) {\n                    args.push(sinon.format(this.args[i]));\n                }\n\n                callStr = callStr + args.join(\", \") + \")\";\n\n                if (typeof this.returnValue != \"undefined\") {\n                    callStr += \" => \" + sinon.format(this.returnValue);\n                }\n\n                if (this.exception) {\n                    callStr += \" !\" + this.exception.name;\n\n                    if (this.exception.message) {\n                        callStr += \"(\" + this.exception.message + \")\";\n                    }\n                }\n\n                return callStr;\n            }\n        };\n\n        callProto.invokeCallback = callProto.yield;\n\n        function createSpyCall(spy, thisValue, args, returnValue, exception, id) {\n            if (typeof id !== \"number\") {\n                throw new TypeError(\"Call id is not a number\");\n            }\n            var proxyCall = sinon.create(callProto);\n            proxyCall.proxy = spy;\n            proxyCall.thisValue = thisValue;\n            proxyCall.args = args;\n            proxyCall.returnValue = returnValue;\n            proxyCall.exception = exception;\n            proxyCall.callId = id;\n\n            return proxyCall;\n        }\n        createSpyCall.toString = callProto.toString; // used by mocks\n\n        sinon.spyCall = createSpyCall;\n        return createSpyCall;\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        require(\"./match\");\n        require(\"./format\");\n        module.exports = makeApi(sinon);\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n}(typeof sinon == \"object\" && sinon || null));\n","/**\n * @depend util/core.js\n * @depend spy.js\n * @depend stub.js\n * @depend mock.js\n */\n/**\n * Collections of stubs, spies and mocks.\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2013 Christian Johansen\n */\n\"use strict\";\n\n(function (sinon) {\n    var push = [].push;\n    var hasOwnProperty = Object.prototype.hasOwnProperty;\n\n    function getFakes(fakeCollection) {\n        if (!fakeCollection.fakes) {\n            fakeCollection.fakes = [];\n        }\n\n        return fakeCollection.fakes;\n    }\n\n    function each(fakeCollection, method) {\n        var fakes = getFakes(fakeCollection);\n\n        for (var i = 0, l = fakes.length; i < l; i += 1) {\n            if (typeof fakes[i][method] == \"function\") {\n                fakes[i][method]();\n            }\n        }\n    }\n\n    function compact(fakeCollection) {\n        var fakes = getFakes(fakeCollection);\n        var i = 0;\n        while (i < fakes.length) {\n            fakes.splice(i, 1);\n        }\n    }\n\n    function makeApi(sinon) {\n        var collection = {\n            verify: function resolve() {\n                each(this, \"verify\");\n            },\n\n            restore: function restore() {\n                each(this, \"restore\");\n                compact(this);\n            },\n\n            reset: function restore() {\n                each(this, \"reset\");\n            },\n\n            verifyAndRestore: function verifyAndRestore() {\n                var exception;\n\n                try {\n                    this.verify();\n                } catch (e) {\n                    exception = e;\n                }\n\n                this.restore();\n\n                if (exception) {\n                    throw exception;\n                }\n            },\n\n            add: function add(fake) {\n                push.call(getFakes(this), fake);\n                return fake;\n            },\n\n            spy: function spy() {\n                return this.add(sinon.spy.apply(sinon, arguments));\n            },\n\n            stub: function stub(object, property, value) {\n                if (property) {\n                    var original = object[property];\n\n                    if (typeof original != \"function\") {\n                        if (!hasOwnProperty.call(object, property)) {\n                            throw new TypeError(\"Cannot stub non-existent own property \" + property);\n                        }\n\n                        object[property] = value;\n\n                        return this.add({\n                            restore: function () {\n                                object[property] = original;\n                            }\n                        });\n                    }\n                }\n                if (!property && !!object && typeof object == \"object\") {\n                    var stubbedObj = sinon.stub.apply(sinon, arguments);\n\n                    for (var prop in stubbedObj) {\n                        if (typeof stubbedObj[prop] === \"function\") {\n                            this.add(stubbedObj[prop]);\n                        }\n                    }\n\n                    return stubbedObj;\n                }\n\n                return this.add(sinon.stub.apply(sinon, arguments));\n            },\n\n            mock: function mock() {\n                return this.add(sinon.mock.apply(sinon, arguments));\n            },\n\n            inject: function inject(obj) {\n                var col = this;\n\n                obj.spy = function () {\n                    return col.spy.apply(col, arguments);\n                };\n\n                obj.stub = function () {\n                    return col.stub.apply(col, arguments);\n                };\n\n                obj.mock = function () {\n                    return col.mock.apply(col, arguments);\n                };\n\n                return obj;\n            }\n        };\n\n        sinon.collection = collection;\n        return collection;\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        require(\"./mock\");\n        require(\"./spy\");\n        require(\"./stub\");\n        module.exports = makeApi(sinon);\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n}(typeof sinon == \"object\" && sinon || null));\n","/**\n * @depend util/core.js\n */\n\"use strict\";\n\n(function (sinon) {\n    function makeApi(sinon) {\n\n        // Adapted from https://developer.mozilla.org/en/docs/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug\n        var hasDontEnumBug = (function () {\n            var obj = {\n                constructor: function () {\n                    return \"0\";\n                },\n                toString: function () {\n                    return \"1\";\n                },\n                valueOf: function () {\n                    return \"2\";\n                },\n                toLocaleString: function () {\n                    return \"3\";\n                },\n                prototype: function () {\n                    return \"4\";\n                },\n                isPrototypeOf: function () {\n                    return \"5\";\n                },\n                propertyIsEnumerable: function () {\n                    return \"6\";\n                },\n                hasOwnProperty: function () {\n                    return \"7\";\n                },\n                length: function () {\n                    return \"8\";\n                },\n                unique: function () {\n                    return \"9\"\n                }\n            };\n\n            var result = [];\n            for (var prop in obj) {\n                result.push(obj[prop]());\n            }\n            return result.join(\"\") !== \"0123456789\";\n        })();\n\n        /* Public: Extend target in place with all (own) properties from sources in-order. Thus, last source will\n         *         override properties in previous sources.\n         *\n         * target - The Object to extend\n         * sources - Objects to copy properties from.\n         *\n         * Returns the extended target\n         */\n        function extend(target /*, sources */) {\n            var sources = Array.prototype.slice.call(arguments, 1),\n                source, i, prop;\n\n            for (i = 0; i < sources.length; i++) {\n                source = sources[i];\n\n                for (prop in source) {\n                    if (source.hasOwnProperty(prop)) {\n                        target[prop] = source[prop];\n                    }\n                }\n\n                // Make sure we copy (own) toString method even when in JScript with DontEnum bug\n                // See https://developer.mozilla.org/en/docs/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug\n                if (hasDontEnumBug && source.hasOwnProperty(\"toString\") && source.toString !== target.toString) {\n                    target.toString = source.toString;\n                }\n            }\n\n            return target;\n        };\n\n        sinon.extend = extend;\n        return sinon.extend;\n    }\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        module.exports = makeApi(sinon);\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n}(typeof sinon == \"object\" && sinon || null));\n","/**\n * @depend util/core.js\n */\n/**\n * Format functions\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2014 Christian Johansen\n */\n\"use strict\";\n\n(function (sinon, formatio) {\n    function makeApi(sinon) {\n        function valueFormatter(value) {\n            return \"\" + value;\n        }\n\n        function getFormatioFormatter() {\n            var formatter = formatio.configure({\n                    quoteStrings: false,\n                    limitChildrenCount: 250\n                });\n\n            function format() {\n                return formatter.ascii.apply(formatter, arguments);\n            };\n\n            return format;\n        }\n\n        function getNodeFormatter(value) {\n            function format(value) {\n                return typeof value == \"object\" && value.toString === Object.prototype.toString ? util.inspect(value) : value;\n            };\n\n            try {\n                var util = require(\"util\");\n            } catch (e) {\n                /* Node, but no util module - would be very old, but better safe than sorry */\n            }\n\n            return util ? format : valueFormatter;\n        }\n\n        var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\",\n            formatter;\n\n        if (isNode) {\n            try {\n                formatio = require(\"formatio\");\n            } catch (e) {}\n        }\n\n        if (formatio) {\n            formatter = getFormatioFormatter()\n        } else if (isNode) {\n            formatter = getNodeFormatter();\n        } else {\n            formatter = valueFormatter;\n        }\n\n        sinon.format = formatter;\n        return sinon.format;\n    }\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        module.exports = makeApi(sinon);\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n}(\n    (typeof sinon == \"object\" && sinon || null),\n    (typeof formatio == \"object\" && formatio)\n));\n","/**\n * @depend util/core.js\n */\n/**\n * Logs errors\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2014 Christian Johansen\n */\n\"use strict\";\n\n(function (sinon) {\n    // cache a reference to setTimeout, so that our reference won't be stubbed out\n    // when using fake timers and errors will still get logged\n    // https://github.com/cjohansen/Sinon.JS/issues/381\n    var realSetTimeout = setTimeout;\n\n    function makeApi(sinon) {\n\n        function log() {}\n\n        function logError(label, err) {\n            var msg = label + \" threw exception: \";\n\n            sinon.log(msg + \"[\" + err.name + \"] \" + err.message);\n\n            if (err.stack) {\n                sinon.log(err.stack);\n            }\n\n            logError.setTimeout(function () {\n                err.message = msg + err.message;\n                throw err;\n            }, 0);\n        };\n\n        // wrap realSetTimeout with something we can stub in tests\n        logError.setTimeout = function (func, timeout) {\n            realSetTimeout(func, timeout);\n        }\n\n        var exports = {};\n        exports.log = sinon.log = log;\n        exports.logError = sinon.logError = logError;\n\n        return exports;\n    }\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        module.exports = makeApi(sinon);\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n}(typeof sinon == \"object\" && sinon || null));\n","/**\n * @depend util/core.js\n * @depend typeOf.js\n */\n/*jslint eqeqeq: false, onevar: false, plusplus: false*/\n/*global module, require, sinon*/\n/**\n * Match functions\n *\n * @author Maximilian Antoni (mail@maxantoni.de)\n * @license BSD\n *\n * Copyright (c) 2012 Maximilian Antoni\n */\n\"use strict\";\n\n(function (sinon) {\n    function makeApi(sinon) {\n        function assertType(value, type, name) {\n            var actual = sinon.typeOf(value);\n            if (actual !== type) {\n                throw new TypeError(\"Expected type of \" + name + \" to be \" +\n                    type + \", but was \" + actual);\n            }\n        }\n\n        var matcher = {\n            toString: function () {\n                return this.message;\n            }\n        };\n\n        function isMatcher(object) {\n            return matcher.isPrototypeOf(object);\n        }\n\n        function matchObject(expectation, actual) {\n            if (actual === null || actual === undefined) {\n                return false;\n            }\n            for (var key in expectation) {\n                if (expectation.hasOwnProperty(key)) {\n                    var exp = expectation[key];\n                    var act = actual[key];\n                    if (match.isMatcher(exp)) {\n                        if (!exp.test(act)) {\n                            return false;\n                        }\n                    } else if (sinon.typeOf(exp) === \"object\") {\n                        if (!matchObject(exp, act)) {\n                            return false;\n                        }\n                    } else if (!sinon.deepEqual(exp, act)) {\n                        return false;\n                    }\n                }\n            }\n            return true;\n        }\n\n        matcher.or = function (m2) {\n            if (!arguments.length) {\n                throw new TypeError(\"Matcher expected\");\n            } else if (!isMatcher(m2)) {\n                m2 = match(m2);\n            }\n            var m1 = this;\n            var or = sinon.create(matcher);\n            or.test = function (actual) {\n                return m1.test(actual) || m2.test(actual);\n            };\n            or.message = m1.message + \".or(\" + m2.message + \")\";\n            return or;\n        };\n\n        matcher.and = function (m2) {\n            if (!arguments.length) {\n                throw new TypeError(\"Matcher expected\");\n            } else if (!isMatcher(m2)) {\n                m2 = match(m2);\n            }\n            var m1 = this;\n            var and = sinon.create(matcher);\n            and.test = function (actual) {\n                return m1.test(actual) && m2.test(actual);\n            };\n            and.message = m1.message + \".and(\" + m2.message + \")\";\n            return and;\n        };\n\n        var match = function (expectation, message) {\n            var m = sinon.create(matcher);\n            var type = sinon.typeOf(expectation);\n            switch (type) {\n            case \"object\":\n                if (typeof expectation.test === \"function\") {\n                    m.test = function (actual) {\n                        return expectation.test(actual) === true;\n                    };\n                    m.message = \"match(\" + sinon.functionName(expectation.test) + \")\";\n                    return m;\n                }\n                var str = [];\n                for (var key in expectation) {\n                    if (expectation.hasOwnProperty(key)) {\n                        str.push(key + \": \" + expectation[key]);\n                    }\n                }\n                m.test = function (actual) {\n                    return matchObject(expectation, actual);\n                };\n                m.message = \"match(\" + str.join(\", \") + \")\";\n                break;\n            case \"number\":\n                m.test = function (actual) {\n                    return expectation == actual;\n                };\n                break;\n            case \"string\":\n                m.test = function (actual) {\n                    if (typeof actual !== \"string\") {\n                        return false;\n                    }\n                    return actual.indexOf(expectation) !== -1;\n                };\n                m.message = \"match(\\\"\" + expectation + \"\\\")\";\n                break;\n            case \"regexp\":\n                m.test = function (actual) {\n                    if (typeof actual !== \"string\") {\n                        return false;\n                    }\n                    return expectation.test(actual);\n                };\n                break;\n            case \"function\":\n                m.test = expectation;\n                if (message) {\n                    m.message = message;\n                } else {\n                    m.message = \"match(\" + sinon.functionName(expectation) + \")\";\n                }\n                break;\n            default:\n                m.test = function (actual) {\n                    return sinon.deepEqual(expectation, actual);\n                };\n            }\n            if (!m.message) {\n                m.message = \"match(\" + expectation + \")\";\n            }\n            return m;\n        };\n\n        match.isMatcher = isMatcher;\n\n        match.any = match(function () {\n            return true;\n        }, \"any\");\n\n        match.defined = match(function (actual) {\n            return actual !== null && actual !== undefined;\n        }, \"defined\");\n\n        match.truthy = match(function (actual) {\n            return !!actual;\n        }, \"truthy\");\n\n        match.falsy = match(function (actual) {\n            return !actual;\n        }, \"falsy\");\n\n        match.same = function (expectation) {\n            return match(function (actual) {\n                return expectation === actual;\n            }, \"same(\" + expectation + \")\");\n        };\n\n        match.typeOf = function (type) {\n            assertType(type, \"string\", \"type\");\n            return match(function (actual) {\n                return sinon.typeOf(actual) === type;\n            }, \"typeOf(\\\"\" + type + \"\\\")\");\n        };\n\n        match.instanceOf = function (type) {\n            assertType(type, \"function\", \"type\");\n            return match(function (actual) {\n                return actual instanceof type;\n            }, \"instanceOf(\" + sinon.functionName(type) + \")\");\n        };\n\n        function createPropertyMatcher(propertyTest, messagePrefix) {\n            return function (property, value) {\n                assertType(property, \"string\", \"property\");\n                var onlyProperty = arguments.length === 1;\n                var message = messagePrefix + \"(\\\"\" + property + \"\\\"\";\n                if (!onlyProperty) {\n                    message += \", \" + value;\n                }\n                message += \")\";\n                return match(function (actual) {\n                    if (actual === undefined || actual === null ||\n                            !propertyTest(actual, property)) {\n                        return false;\n                    }\n                    return onlyProperty || sinon.deepEqual(value, actual[property]);\n                }, message);\n            };\n        }\n\n        match.has = createPropertyMatcher(function (actual, property) {\n            if (typeof actual === \"object\") {\n                return property in actual;\n            }\n            return actual[property] !== undefined;\n        }, \"has\");\n\n        match.hasOwn = createPropertyMatcher(function (actual, property) {\n            return actual.hasOwnProperty(property);\n        }, \"hasOwn\");\n\n        match.bool = match.typeOf(\"boolean\");\n        match.number = match.typeOf(\"number\");\n        match.string = match.typeOf(\"string\");\n        match.object = match.typeOf(\"object\");\n        match.func = match.typeOf(\"function\");\n        match.array = match.typeOf(\"array\");\n        match.regexp = match.typeOf(\"regexp\");\n        match.date = match.typeOf(\"date\");\n\n        sinon.match = match;\n        return match;\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        require(\"./typeOf\");\n        module.exports = makeApi(sinon);\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n}(typeof sinon == \"object\" && sinon || null));\n","/**\n * @depend times_in_words.js\n * @depend util/core.js\n * @depend call.js\n * @depend extend.js\n * @depend match.js\n * @depend spy.js\n * @depend stub.js\n * @depend format.js\n */\n/**\n * Mock functions.\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2013 Christian Johansen\n */\n\"use strict\";\n\n(function (sinon) {\n    function makeApi(sinon) {\n        var push = [].push;\n        var match = sinon.match;\n\n        function mock(object) {\n            if (!object) {\n                return sinon.expectation.create(\"Anonymous mock\");\n            }\n\n            return mock.create(object);\n        }\n\n        function each(collection, callback) {\n            if (!collection) {\n                return;\n            }\n\n            for (var i = 0, l = collection.length; i < l; i += 1) {\n                callback(collection[i]);\n            }\n        }\n\n        sinon.extend(mock, {\n            create: function create(object) {\n                if (!object) {\n                    throw new TypeError(\"object is null\");\n                }\n\n                var mockObject = sinon.extend({}, mock);\n                mockObject.object = object;\n                delete mockObject.create;\n\n                return mockObject;\n            },\n\n            expects: function expects(method) {\n                if (!method) {\n                    throw new TypeError(\"method is falsy\");\n                }\n\n                if (!this.expectations) {\n                    this.expectations = {};\n                    this.proxies = [];\n                }\n\n                if (!this.expectations[method]) {\n                    this.expectations[method] = [];\n                    var mockObject = this;\n\n                    sinon.wrapMethod(this.object, method, function () {\n                        return mockObject.invokeMethod(method, this, arguments);\n                    });\n\n                    push.call(this.proxies, method);\n                }\n\n                var expectation = sinon.expectation.create(method);\n                push.call(this.expectations[method], expectation);\n\n                return expectation;\n            },\n\n            restore: function restore() {\n                var object = this.object;\n\n                each(this.proxies, function (proxy) {\n                    if (typeof object[proxy].restore == \"function\") {\n                        object[proxy].restore();\n                    }\n                });\n            },\n\n            verify: function verify() {\n                var expectations = this.expectations || {};\n                var messages = [], met = [];\n\n                each(this.proxies, function (proxy) {\n                    each(expectations[proxy], function (expectation) {\n                        if (!expectation.met()) {\n                            push.call(messages, expectation.toString());\n                        } else {\n                            push.call(met, expectation.toString());\n                        }\n                    });\n                });\n\n                this.restore();\n\n                if (messages.length > 0) {\n                    sinon.expectation.fail(messages.concat(met).join(\"\\n\"));\n                } else if (met.length > 0) {\n                    sinon.expectation.pass(messages.concat(met).join(\"\\n\"));\n                }\n\n                return true;\n            },\n\n            invokeMethod: function invokeMethod(method, thisValue, args) {\n                var expectations = this.expectations && this.expectations[method];\n                var length = expectations && expectations.length || 0, i;\n\n                for (i = 0; i < length; i += 1) {\n                    if (!expectations[i].met() &&\n                        expectations[i].allowsCall(thisValue, args)) {\n                        return expectations[i].apply(thisValue, args);\n                    }\n                }\n\n                var messages = [], available, exhausted = 0;\n\n                for (i = 0; i < length; i += 1) {\n                    if (expectations[i].allowsCall(thisValue, args)) {\n                        available = available || expectations[i];\n                    } else {\n                        exhausted += 1;\n                    }\n                    push.call(messages, \"    \" + expectations[i].toString());\n                }\n\n                if (exhausted === 0) {\n                    return available.apply(thisValue, args);\n                }\n\n                messages.unshift(\"Unexpected call: \" + sinon.spyCall.toString.call({\n                    proxy: method,\n                    args: args\n                }));\n\n                sinon.expectation.fail(messages.join(\"\\n\"));\n            }\n        });\n\n        var times = sinon.timesInWords;\n        var slice = Array.prototype.slice;\n\n        function callCountInWords(callCount) {\n            if (callCount == 0) {\n                return \"never called\";\n            } else {\n                return \"called \" + times(callCount);\n            }\n        }\n\n        function expectedCallCountInWords(expectation) {\n            var min = expectation.minCalls;\n            var max = expectation.maxCalls;\n\n            if (typeof min == \"number\" && typeof max == \"number\") {\n                var str = times(min);\n\n                if (min != max) {\n                    str = \"at least \" + str + \" and at most \" + times(max);\n                }\n\n                return str;\n            }\n\n            if (typeof min == \"number\") {\n                return \"at least \" + times(min);\n            }\n\n            return \"at most \" + times(max);\n        }\n\n        function receivedMinCalls(expectation) {\n            var hasMinLimit = typeof expectation.minCalls == \"number\";\n            return !hasMinLimit || expectation.callCount >= expectation.minCalls;\n        }\n\n        function receivedMaxCalls(expectation) {\n            if (typeof expectation.maxCalls != \"number\") {\n                return false;\n            }\n\n            return expectation.callCount == expectation.maxCalls;\n        }\n\n        function verifyMatcher(possibleMatcher, arg) {\n            if (match && match.isMatcher(possibleMatcher)) {\n                return possibleMatcher.test(arg);\n            } else {\n                return true;\n            }\n        }\n\n        sinon.expectation = {\n            minCalls: 1,\n            maxCalls: 1,\n\n            create: function create(methodName) {\n                var expectation = sinon.extend(sinon.stub.create(), sinon.expectation);\n                delete expectation.create;\n                expectation.method = methodName;\n\n                return expectation;\n            },\n\n            invoke: function invoke(func, thisValue, args) {\n                this.verifyCallAllowed(thisValue, args);\n\n                return sinon.spy.invoke.apply(this, arguments);\n            },\n\n            atLeast: function atLeast(num) {\n                if (typeof num != \"number\") {\n                    throw new TypeError(\"'\" + num + \"' is not number\");\n                }\n\n                if (!this.limitsSet) {\n                    this.maxCalls = null;\n                    this.limitsSet = true;\n                }\n\n                this.minCalls = num;\n\n                return this;\n            },\n\n            atMost: function atMost(num) {\n                if (typeof num != \"number\") {\n                    throw new TypeError(\"'\" + num + \"' is not number\");\n                }\n\n                if (!this.limitsSet) {\n                    this.minCalls = null;\n                    this.limitsSet = true;\n                }\n\n                this.maxCalls = num;\n\n                return this;\n            },\n\n            never: function never() {\n                return this.exactly(0);\n            },\n\n            once: function once() {\n                return this.exactly(1);\n            },\n\n            twice: function twice() {\n                return this.exactly(2);\n            },\n\n            thrice: function thrice() {\n                return this.exactly(3);\n            },\n\n            exactly: function exactly(num) {\n                if (typeof num != \"number\") {\n                    throw new TypeError(\"'\" + num + \"' is not a number\");\n                }\n\n                this.atLeast(num);\n                return this.atMost(num);\n            },\n\n            met: function met() {\n                return !this.failed && receivedMinCalls(this);\n            },\n\n            verifyCallAllowed: function verifyCallAllowed(thisValue, args) {\n                if (receivedMaxCalls(this)) {\n                    this.failed = true;\n                    sinon.expectation.fail(this.method + \" already called \" + times(this.maxCalls));\n                }\n\n                if (\"expectedThis\" in this && this.expectedThis !== thisValue) {\n                    sinon.expectation.fail(this.method + \" called with \" + thisValue + \" as thisValue, expected \" +\n                        this.expectedThis);\n                }\n\n                if (!(\"expectedArguments\" in this)) {\n                    return;\n                }\n\n                if (!args) {\n                    sinon.expectation.fail(this.method + \" received no arguments, expected \" +\n                        sinon.format(this.expectedArguments));\n                }\n\n                if (args.length < this.expectedArguments.length) {\n                    sinon.expectation.fail(this.method + \" received too few arguments (\" + sinon.format(args) +\n                        \"), expected \" + sinon.format(this.expectedArguments));\n                }\n\n                if (this.expectsExactArgCount &&\n                    args.length != this.expectedArguments.length) {\n                    sinon.expectation.fail(this.method + \" received too many arguments (\" + sinon.format(args) +\n                        \"), expected \" + sinon.format(this.expectedArguments));\n                }\n\n                for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {\n\n                    if (!verifyMatcher(this.expectedArguments[i], args[i])) {\n                        sinon.expectation.fail(this.method + \" received wrong arguments \" + sinon.format(args) +\n                            \", didn't match \" + this.expectedArguments.toString());\n                    }\n\n                    if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {\n                        sinon.expectation.fail(this.method + \" received wrong arguments \" + sinon.format(args) +\n                            \", expected \" + sinon.format(this.expectedArguments));\n                    }\n                }\n            },\n\n            allowsCall: function allowsCall(thisValue, args) {\n                if (this.met() && receivedMaxCalls(this)) {\n                    return false;\n                }\n\n                if (\"expectedThis\" in this && this.expectedThis !== thisValue) {\n                    return false;\n                }\n\n                if (!(\"expectedArguments\" in this)) {\n                    return true;\n                }\n\n                args = args || [];\n\n                if (args.length < this.expectedArguments.length) {\n                    return false;\n                }\n\n                if (this.expectsExactArgCount &&\n                    args.length != this.expectedArguments.length) {\n                    return false;\n                }\n\n                for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {\n                    if (!verifyMatcher(this.expectedArguments[i], args[i])) {\n                        return false;\n                    }\n\n                    if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {\n                        return false;\n                    }\n                }\n\n                return true;\n            },\n\n            withArgs: function withArgs() {\n                this.expectedArguments = slice.call(arguments);\n                return this;\n            },\n\n            withExactArgs: function withExactArgs() {\n                this.withArgs.apply(this, arguments);\n                this.expectsExactArgCount = true;\n                return this;\n            },\n\n            on: function on(thisValue) {\n                this.expectedThis = thisValue;\n                return this;\n            },\n\n            toString: function () {\n                var args = (this.expectedArguments || []).slice();\n\n                if (!this.expectsExactArgCount) {\n                    push.call(args, \"[...]\");\n                }\n\n                var callStr = sinon.spyCall.toString.call({\n                    proxy: this.method || \"anonymous mock expectation\",\n                    args: args\n                });\n\n                var message = callStr.replace(\", [...\", \"[, ...\") + \" \" +\n                    expectedCallCountInWords(this);\n\n                if (this.met()) {\n                    return \"Expectation met: \" + message;\n                }\n\n                return \"Expected \" + message + \" (\" +\n                    callCountInWords(this.callCount) + \")\";\n            },\n\n            verify: function verify() {\n                if (!this.met()) {\n                    sinon.expectation.fail(this.toString());\n                } else {\n                    sinon.expectation.pass(this.toString());\n                }\n\n                return true;\n            },\n\n            pass: function pass(message) {\n                sinon.assert.pass(message);\n            },\n\n            fail: function fail(message) {\n                var exception = new Error(message);\n                exception.name = \"ExpectationError\";\n\n                throw exception;\n            }\n        };\n\n        sinon.mock = mock;\n        return mock;\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        require(\"./times_in_words\");\n        require(\"./call\");\n        require(\"./extend\");\n        require(\"./match\");\n        require(\"./spy\");\n        require(\"./stub\");\n        require(\"./format\");\n\n        module.exports = makeApi(sinon);\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n}(typeof sinon == \"object\" && sinon || null));\n","/**\n * @depend util/core.js\n * @depend extend.js\n * @depend collection.js\n * @depend util/fake_timers.js\n * @depend util/fake_server_with_clock.js\n */\n/**\n * Manages fake collections as well as fake utilities such as Sinon's\n * timers and fake XHR implementation in one convenient object.\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2013 Christian Johansen\n */\n\"use strict\";\n\n(function () {\n    function makeApi(sinon) {\n        var push = [].push;\n\n        function exposeValue(sandbox, config, key, value) {\n            if (!value) {\n                return;\n            }\n\n            if (config.injectInto && !(key in config.injectInto)) {\n                config.injectInto[key] = value;\n                sandbox.injectedKeys.push(key);\n            } else {\n                push.call(sandbox.args, value);\n            }\n        }\n\n        function prepareSandboxFromConfig(config) {\n            var sandbox = sinon.create(sinon.sandbox);\n\n            if (config.useFakeServer) {\n                if (typeof config.useFakeServer == \"object\") {\n                    sandbox.serverPrototype = config.useFakeServer;\n                }\n\n                sandbox.useFakeServer();\n            }\n\n            if (config.useFakeTimers) {\n                if (typeof config.useFakeTimers == \"object\") {\n                    sandbox.useFakeTimers.apply(sandbox, config.useFakeTimers);\n                } else {\n                    sandbox.useFakeTimers();\n                }\n            }\n\n            return sandbox;\n        }\n\n        sinon.sandbox = sinon.extend(sinon.create(sinon.collection), {\n            useFakeTimers: function useFakeTimers() {\n                this.clock = sinon.useFakeTimers.apply(sinon, arguments);\n\n                return this.add(this.clock);\n            },\n\n            serverPrototype: sinon.fakeServer,\n\n            useFakeServer: function useFakeServer() {\n                var proto = this.serverPrototype || sinon.fakeServer;\n\n                if (!proto || !proto.create) {\n                    return null;\n                }\n\n                this.server = proto.create();\n                return this.add(this.server);\n            },\n\n            inject: function (obj) {\n                sinon.collection.inject.call(this, obj);\n\n                if (this.clock) {\n                    obj.clock = this.clock;\n                }\n\n                if (this.server) {\n                    obj.server = this.server;\n                    obj.requests = this.server.requests;\n                }\n\n                obj.match = sinon.match;\n\n                return obj;\n            },\n\n            restore: function () {\n                sinon.collection.restore.apply(this, arguments);\n                this.restoreContext();\n            },\n\n            restoreContext: function () {\n                if (this.injectedKeys) {\n                    for (var i = 0, j = this.injectedKeys.length; i < j; i++) {\n                        delete this.injectInto[this.injectedKeys[i]];\n                    }\n                    this.injectedKeys = [];\n                }\n            },\n\n            create: function (config) {\n                if (!config) {\n                    return sinon.create(sinon.sandbox);\n                }\n\n                var sandbox = prepareSandboxFromConfig(config);\n                sandbox.args = sandbox.args || [];\n                sandbox.injectedKeys = [];\n                sandbox.injectInto = config.injectInto;\n                var prop, value, exposed = sandbox.inject({});\n\n                if (config.properties) {\n                    for (var i = 0, l = config.properties.length; i < l; i++) {\n                        prop = config.properties[i];\n                        value = exposed[prop] || prop == \"sandbox\" && sandbox;\n                        exposeValue(sandbox, config, prop, value);\n                    }\n                } else {\n                    exposeValue(sandbox, config, \"sandbox\", value);\n                }\n\n                return sandbox;\n            },\n\n            match: sinon.match\n        });\n\n        sinon.sandbox.useFakeXMLHttpRequest = sinon.sandbox.useFakeServer;\n\n        return sinon.sandbox;\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        require(\"./extend\");\n        require(\"./util/fake_server_with_clock\");\n        require(\"./util/fake_timers\");\n        require(\"./collection\");\n        module.exports = makeApi(sinon);\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n}());\n","/**\n  * @depend times_in_words.js\n  * @depend util/core.js\n  * @depend extend.js\n  * @depend call.js\n  * @depend format.js\n  */\n/**\n  * Spy functions\n  *\n  * @author Christian Johansen (christian@cjohansen.no)\n  * @license BSD\n  *\n  * Copyright (c) 2010-2013 Christian Johansen\n  */\n\"use strict\";\n\n(function (sinon) {\n\n    function makeApi(sinon) {\n        var push = Array.prototype.push;\n        var slice = Array.prototype.slice;\n        var callId = 0;\n\n        function spy(object, property, types) {\n            if (!property && typeof object == \"function\") {\n                return spy.create(object);\n            }\n\n            if (!object && !property) {\n                return spy.create(function () { });\n            }\n\n            if (types) {\n                var methodDesc = sinon.getPropertyDescriptor(object, property);\n                for (var i = 0; i < types.length; i++) {\n                    methodDesc[types[i]] = spy.create(methodDesc[types[i]]);\n                }\n                return sinon.wrapMethod(object, property, methodDesc);\n            } else {\n                var method = object[property];\n                return sinon.wrapMethod(object, property, spy.create(method));\n            }\n        }\n\n        function matchingFake(fakes, args, strict) {\n            if (!fakes) {\n                return;\n            }\n\n            for (var i = 0, l = fakes.length; i < l; i++) {\n                if (fakes[i].matches(args, strict)) {\n                    return fakes[i];\n                }\n            }\n        }\n\n        function incrementCallCount() {\n            this.called = true;\n            this.callCount += 1;\n            this.notCalled = false;\n            this.calledOnce = this.callCount == 1;\n            this.calledTwice = this.callCount == 2;\n            this.calledThrice = this.callCount == 3;\n        }\n\n        function createCallProperties() {\n            this.firstCall = this.getCall(0);\n            this.secondCall = this.getCall(1);\n            this.thirdCall = this.getCall(2);\n            this.lastCall = this.getCall(this.callCount - 1);\n        }\n\n        var vars = \"a,b,c,d,e,f,g,h,i,j,k,l\";\n        function createProxy(func, proxyLength) {\n            // Retain the function length:\n            var p;\n            if (proxyLength) {\n                eval(\"p = (function proxy(\" + vars.substring(0, proxyLength * 2 - 1) +\n                    \") { return p.invoke(func, this, slice.call(arguments)); });\");\n            } else {\n                p = function proxy() {\n                    return p.invoke(func, this, slice.call(arguments));\n                };\n            }\n            return p;\n        }\n\n        var uuid = 0;\n\n        // Public API\n        var spyApi = {\n            reset: function () {\n                if (this.invoking) {\n                    var err = new Error(\"Cannot reset Sinon function while invoking it. \" +\n                                        \"Move the call to .reset outside of the callback.\");\n                    err.name = \"InvalidResetException\";\n                    throw err;\n                }\n\n                this.called = false;\n                this.notCalled = true;\n                this.calledOnce = false;\n                this.calledTwice = false;\n                this.calledThrice = false;\n                this.callCount = 0;\n                this.firstCall = null;\n                this.secondCall = null;\n                this.thirdCall = null;\n                this.lastCall = null;\n                this.args = [];\n                this.returnValues = [];\n                this.thisValues = [];\n                this.exceptions = [];\n                this.callIds = [];\n                if (this.fakes) {\n                    for (var i = 0; i < this.fakes.length; i++) {\n                        this.fakes[i].reset();\n                    }\n                }\n\n                return this;\n            },\n\n            create: function create(func, spyLength) {\n                var name;\n\n                if (typeof func != \"function\") {\n                    func = function () { };\n                } else {\n                    name = sinon.functionName(func);\n                }\n\n                if (!spyLength) {\n                    spyLength = func.length;\n                }\n\n                var proxy = createProxy(func, spyLength);\n\n                sinon.extend(proxy, spy);\n                delete proxy.create;\n                sinon.extend(proxy, func);\n\n                proxy.reset();\n                proxy.prototype = func.prototype;\n                proxy.displayName = name || \"spy\";\n                proxy.toString = sinon.functionToString;\n                proxy.instantiateFake = sinon.spy.create;\n                proxy.id = \"spy#\" + uuid++;\n\n                return proxy;\n            },\n\n            invoke: function invoke(func, thisValue, args) {\n                var matching = matchingFake(this.fakes, args);\n                var exception, returnValue;\n\n                incrementCallCount.call(this);\n                push.call(this.thisValues, thisValue);\n                push.call(this.args, args);\n                push.call(this.callIds, callId++);\n\n                // Make call properties available from within the spied function:\n                createCallProperties.call(this);\n\n                try {\n                    this.invoking = true;\n\n                    if (matching) {\n                        returnValue = matching.invoke(func, thisValue, args);\n                    } else {\n                        returnValue = (this.func || func).apply(thisValue, args);\n                    }\n\n                    var thisCall = this.getCall(this.callCount - 1);\n                    if (thisCall.calledWithNew() && typeof returnValue !== \"object\") {\n                        returnValue = thisValue;\n                    }\n                } catch (e) {\n                    exception = e;\n                } finally {\n                    delete this.invoking;\n                }\n\n                push.call(this.exceptions, exception);\n                push.call(this.returnValues, returnValue);\n\n                // Make return value and exception available in the calls:\n                createCallProperties.call(this);\n\n                if (exception !== undefined) {\n                    throw exception;\n                }\n\n                return returnValue;\n            },\n\n            named: function named(name) {\n                this.displayName = name;\n                return this;\n            },\n\n            getCall: function getCall(i) {\n                if (i < 0 || i >= this.callCount) {\n                    return null;\n                }\n\n                return sinon.spyCall(this, this.thisValues[i], this.args[i],\n                                        this.returnValues[i], this.exceptions[i],\n                                        this.callIds[i]);\n            },\n\n            getCalls: function () {\n                var calls = [];\n                var i;\n\n                for (i = 0; i < this.callCount; i++) {\n                    calls.push(this.getCall(i));\n                }\n\n                return calls;\n            },\n\n            calledBefore: function calledBefore(spyFn) {\n                if (!this.called) {\n                    return false;\n                }\n\n                if (!spyFn.called) {\n                    return true;\n                }\n\n                return this.callIds[0] < spyFn.callIds[spyFn.callIds.length - 1];\n            },\n\n            calledAfter: function calledAfter(spyFn) {\n                if (!this.called || !spyFn.called) {\n                    return false;\n                }\n\n                return this.callIds[this.callCount - 1] > spyFn.callIds[spyFn.callCount - 1];\n            },\n\n            withArgs: function () {\n                var args = slice.call(arguments);\n\n                if (this.fakes) {\n                    var match = matchingFake(this.fakes, args, true);\n\n                    if (match) {\n                        return match;\n                    }\n                } else {\n                    this.fakes = [];\n                }\n\n                var original = this;\n                var fake = this.instantiateFake();\n                fake.matchingAguments = args;\n                fake.parent = this;\n                push.call(this.fakes, fake);\n\n                fake.withArgs = function () {\n                    return original.withArgs.apply(original, arguments);\n                };\n\n                for (var i = 0; i < this.args.length; i++) {\n                    if (fake.matches(this.args[i])) {\n                        incrementCallCount.call(fake);\n                        push.call(fake.thisValues, this.thisValues[i]);\n                        push.call(fake.args, this.args[i]);\n                        push.call(fake.returnValues, this.returnValues[i]);\n                        push.call(fake.exceptions, this.exceptions[i]);\n                        push.call(fake.callIds, this.callIds[i]);\n                    }\n                }\n                createCallProperties.call(fake);\n\n                return fake;\n            },\n\n            matches: function (args, strict) {\n                var margs = this.matchingAguments;\n\n                if (margs.length <= args.length &&\n                    sinon.deepEqual(margs, args.slice(0, margs.length))) {\n                    return !strict || margs.length == args.length;\n                }\n            },\n\n            printf: function (format) {\n                var spy = this;\n                var args = slice.call(arguments, 1);\n                var formatter;\n\n                return (format || \"\").replace(/%(.)/g, function (match, specifyer) {\n                    formatter = spyApi.formatters[specifyer];\n\n                    if (typeof formatter == \"function\") {\n                        return formatter.call(null, spy, args);\n                    } else if (!isNaN(parseInt(specifyer, 10))) {\n                        return sinon.format(args[specifyer - 1]);\n                    }\n\n                    return \"%\" + specifyer;\n                });\n            }\n        };\n\n        function delegateToCalls(method, matchAny, actual, notCalled) {\n            spyApi[method] = function () {\n                if (!this.called) {\n                    if (notCalled) {\n                        return notCalled.apply(this, arguments);\n                    }\n                    return false;\n                }\n\n                var currentCall;\n                var matches = 0;\n\n                for (var i = 0, l = this.callCount; i < l; i += 1) {\n                    currentCall = this.getCall(i);\n\n                    if (currentCall[actual || method].apply(currentCall, arguments)) {\n                        matches += 1;\n\n                        if (matchAny) {\n                            return true;\n                        }\n                    }\n                }\n\n                return matches === this.callCount;\n            };\n        }\n\n        delegateToCalls(\"calledOn\", true);\n        delegateToCalls(\"alwaysCalledOn\", false, \"calledOn\");\n        delegateToCalls(\"calledWith\", true);\n        delegateToCalls(\"calledWithMatch\", true);\n        delegateToCalls(\"alwaysCalledWith\", false, \"calledWith\");\n        delegateToCalls(\"alwaysCalledWithMatch\", false, \"calledWithMatch\");\n        delegateToCalls(\"calledWithExactly\", true);\n        delegateToCalls(\"alwaysCalledWithExactly\", false, \"calledWithExactly\");\n        delegateToCalls(\"neverCalledWith\", false, \"notCalledWith\",\n            function () { return true; });\n        delegateToCalls(\"neverCalledWithMatch\", false, \"notCalledWithMatch\",\n            function () { return true; });\n        delegateToCalls(\"threw\", true);\n        delegateToCalls(\"alwaysThrew\", false, \"threw\");\n        delegateToCalls(\"returned\", true);\n        delegateToCalls(\"alwaysReturned\", false, \"returned\");\n        delegateToCalls(\"calledWithNew\", true);\n        delegateToCalls(\"alwaysCalledWithNew\", false, \"calledWithNew\");\n        delegateToCalls(\"callArg\", false, \"callArgWith\", function () {\n            throw new Error(this.toString() + \" cannot call arg since it was not yet invoked.\");\n        });\n        spyApi.callArgWith = spyApi.callArg;\n        delegateToCalls(\"callArgOn\", false, \"callArgOnWith\", function () {\n            throw new Error(this.toString() + \" cannot call arg since it was not yet invoked.\");\n        });\n        spyApi.callArgOnWith = spyApi.callArgOn;\n        delegateToCalls(\"yield\", false, \"yield\", function () {\n            throw new Error(this.toString() + \" cannot yield since it was not yet invoked.\");\n        });\n        // \"invokeCallback\" is an alias for \"yield\" since \"yield\" is invalid in strict mode.\n        spyApi.invokeCallback = spyApi.yield;\n        delegateToCalls(\"yieldOn\", false, \"yieldOn\", function () {\n            throw new Error(this.toString() + \" cannot yield since it was not yet invoked.\");\n        });\n        delegateToCalls(\"yieldTo\", false, \"yieldTo\", function (property) {\n            throw new Error(this.toString() + \" cannot yield to '\" + property +\n                \"' since it was not yet invoked.\");\n        });\n        delegateToCalls(\"yieldToOn\", false, \"yieldToOn\", function (property) {\n            throw new Error(this.toString() + \" cannot yield to '\" + property +\n                \"' since it was not yet invoked.\");\n        });\n\n        spyApi.formatters = {\n            c: function (spy) {\n                return sinon.timesInWords(spy.callCount);\n            },\n\n            n: function (spy) {\n                return spy.toString();\n            },\n\n            C: function (spy) {\n                var calls = [];\n\n                for (var i = 0, l = spy.callCount; i < l; ++i) {\n                    var stringifiedCall = \"    \" + spy.getCall(i).toString();\n                    if (/\\n/.test(calls[i - 1])) {\n                        stringifiedCall = \"\\n\" + stringifiedCall;\n                    }\n                    push.call(calls, stringifiedCall);\n                }\n\n                return calls.length > 0 ? \"\\n\" + calls.join(\"\\n\") : \"\";\n            },\n\n            t: function (spy) {\n                var objects = [];\n\n                for (var i = 0, l = spy.callCount; i < l; ++i) {\n                    push.call(objects, sinon.format(spy.thisValues[i]));\n                }\n\n                return objects.join(\", \");\n            },\n\n            \"*\": function (spy, args) {\n                var formatted = [];\n\n                for (var i = 0, l = args.length; i < l; ++i) {\n                    push.call(formatted, sinon.format(args[i]));\n                }\n\n                return formatted.join(\", \");\n            }\n        };\n\n        sinon.extend(spy, spyApi);\n\n        spy.spyCall = sinon.spyCall;\n        sinon.spy = spy;\n\n        return spy;\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        require(\"./call\");\n        require(\"./extend\");\n        require(\"./times_in_words\");\n        require(\"./format\");\n        module.exports = makeApi(sinon);\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n}(typeof sinon == \"object\" && sinon || null));\n","/**\n * @depend util/core.js\n * @depend extend.js\n * @depend spy.js\n * @depend behavior.js\n */\n/**\n * Stub functions\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2013 Christian Johansen\n */\n\"use strict\";\n\n(function (sinon) {\n    function makeApi(sinon) {\n        function stub(object, property, func) {\n            if (!!func && typeof func != \"function\" && typeof func != \"object\") {\n                throw new TypeError(\"Custom stub should be a function or a property descriptor\");\n            }\n\n            var wrapper;\n\n            if (func) {\n                if (typeof func == \"function\") {\n                    wrapper = sinon.spy && sinon.spy.create ? sinon.spy.create(func) : func;\n                } else {\n                    wrapper = func;\n                    if (sinon.spy && sinon.spy.create) {\n                        var types = sinon.objectKeys(wrapper);\n                        for (var i = 0; i < types.length; i++) {\n                            wrapper[types[i]] = sinon.spy.create(wrapper[types[i]]);\n                        }\n                    }\n                }\n            } else {\n                var stubLength = 0;\n                if (typeof object == \"object\" && typeof object[property] == \"function\") {\n                    stubLength = object[property].length;\n                }\n                wrapper = stub.create(stubLength);\n            }\n\n            if (!object && typeof property === \"undefined\") {\n                return sinon.stub.create();\n            }\n\n            if (typeof property === \"undefined\" && typeof object == \"object\") {\n                for (var prop in object) {\n                    if (typeof object[prop] === \"function\") {\n                        stub(object, prop);\n                    }\n                }\n\n                return object;\n            }\n\n            return sinon.wrapMethod(object, property, wrapper);\n        }\n\n        function getDefaultBehavior(stub) {\n            return stub.defaultBehavior || getParentBehaviour(stub) || sinon.behavior.create(stub);\n        }\n\n        function getParentBehaviour(stub) {\n            return (stub.parent && getCurrentBehavior(stub.parent));\n        }\n\n        function getCurrentBehavior(stub) {\n            var behavior = stub.behaviors[stub.callCount - 1];\n            return behavior && behavior.isPresent() ? behavior : getDefaultBehavior(stub);\n        }\n\n        var uuid = 0;\n\n        var proto = {\n            create: function create(stubLength) {\n                var functionStub = function () {\n                    return getCurrentBehavior(functionStub).invoke(this, arguments);\n                };\n\n                functionStub.id = \"stub#\" + uuid++;\n                var orig = functionStub;\n                functionStub = sinon.spy.create(functionStub, stubLength);\n                functionStub.func = orig;\n\n                sinon.extend(functionStub, stub);\n                functionStub.instantiateFake = sinon.stub.create;\n                functionStub.displayName = \"stub\";\n                functionStub.toString = sinon.functionToString;\n\n                functionStub.defaultBehavior = null;\n                functionStub.behaviors = [];\n\n                return functionStub;\n            },\n\n            resetBehavior: function () {\n                var i;\n\n                this.defaultBehavior = null;\n                this.behaviors = [];\n\n                delete this.returnValue;\n                delete this.returnArgAt;\n                this.returnThis = false;\n\n                if (this.fakes) {\n                    for (i = 0; i < this.fakes.length; i++) {\n                        this.fakes[i].resetBehavior();\n                    }\n                }\n            },\n\n            onCall: function onCall(index) {\n                if (!this.behaviors[index]) {\n                    this.behaviors[index] = sinon.behavior.create(this);\n                }\n\n                return this.behaviors[index];\n            },\n\n            onFirstCall: function onFirstCall() {\n                return this.onCall(0);\n            },\n\n            onSecondCall: function onSecondCall() {\n                return this.onCall(1);\n            },\n\n            onThirdCall: function onThirdCall() {\n                return this.onCall(2);\n            }\n        };\n\n        for (var method in sinon.behavior) {\n            if (sinon.behavior.hasOwnProperty(method) &&\n                !proto.hasOwnProperty(method) &&\n                method != \"create\" &&\n                method != \"withArgs\" &&\n                method != \"invoke\") {\n                proto[method] = (function (behaviorMethod) {\n                    return function () {\n                        this.defaultBehavior = this.defaultBehavior || sinon.behavior.create(this);\n                        this.defaultBehavior[behaviorMethod].apply(this.defaultBehavior, arguments);\n                        return this;\n                    };\n                }(method));\n            }\n        }\n\n        sinon.extend(stub, proto);\n        sinon.stub = stub;\n\n        return stub;\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        require(\"./behavior\");\n        require(\"./spy\");\n        require(\"./extend\");\n        module.exports = makeApi(sinon);\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n}(typeof sinon == \"object\" && sinon || null));\n","/**\n * @depend util/core.js\n * @depend sandbox.js\n */\n/**\n * Test function, sandboxes fakes\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2013 Christian Johansen\n */\n\"use strict\";\n\n(function (sinon) {\n    function makeApi(sinon) {\n        var slice = Array.prototype.slice;\n\n        function test(callback) {\n            var type = typeof callback;\n\n            if (type != \"function\") {\n                throw new TypeError(\"sinon.test needs to wrap a test function, got \" + type);\n            }\n\n            function sinonSandboxedTest() {\n                var config = sinon.getConfig(sinon.config);\n                config.injectInto = config.injectIntoThis && this || config.injectInto;\n                var sandbox = sinon.sandbox.create(config);\n                var args = slice.call(arguments);\n                var oldDone = args.length && args[args.length - 1];\n                var exception, result;\n\n                if (typeof oldDone == \"function\") {\n                    args[args.length - 1] = function sinonDone(result) {\n                        if (result) {\n                            sandbox.restore();\n                            throw exception;\n                        } else {\n                            sandbox.verifyAndRestore();\n                        }\n                        oldDone(result);\n                    };\n                }\n\n                try {\n                    result = callback.apply(this, args.concat(sandbox.args));\n                } catch (e) {\n                    exception = e;\n                }\n\n                if (typeof oldDone != \"function\") {\n                    if (typeof exception !== \"undefined\") {\n                        sandbox.restore();\n                        throw exception;\n                    } else {\n                        sandbox.verifyAndRestore();\n                    }\n                }\n\n                return result;\n            }\n\n            if (callback.length) {\n                return function sinonAsyncSandboxedTest(callback) {\n                    return sinonSandboxedTest.apply(this, arguments);\n                };\n            }\n\n            return sinonSandboxedTest;\n        }\n\n        test.config = {\n            injectIntoThis: true,\n            injectInto: null,\n            properties: [\"spy\", \"stub\", \"mock\", \"clock\", \"server\", \"requests\"],\n            useFakeTimers: true,\n            useFakeServer: true\n        };\n\n        sinon.test = test;\n        return test;\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        require(\"./sandbox\");\n        module.exports = makeApi(sinon);\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (sinon) {\n        makeApi(sinon);\n    }\n}(typeof sinon == \"object\" && sinon || null));\n","/**\n * @depend util/core.js\n * @depend test.js\n */\n/**\n * Test case, sandboxes all test functions\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2013 Christian Johansen\n */\n\"use strict\";\n\n(function (sinon) {\n    function createTest(property, setUp, tearDown) {\n        return function () {\n            if (setUp) {\n                setUp.apply(this, arguments);\n            }\n\n            var exception, result;\n\n            try {\n                result = property.apply(this, arguments);\n            } catch (e) {\n                exception = e;\n            }\n\n            if (tearDown) {\n                tearDown.apply(this, arguments);\n            }\n\n            if (exception) {\n                throw exception;\n            }\n\n            return result;\n        };\n    }\n\n    function makeApi(sinon) {\n        function testCase(tests, prefix) {\n            /*jsl:ignore*/\n            if (!tests || typeof tests != \"object\") {\n                throw new TypeError(\"sinon.testCase needs an object with test functions\");\n            }\n            /*jsl:end*/\n\n            prefix = prefix || \"test\";\n            var rPrefix = new RegExp(\"^\" + prefix);\n            var methods = {}, testName, property, method;\n            var setUp = tests.setUp;\n            var tearDown = tests.tearDown;\n\n            for (testName in tests) {\n                if (tests.hasOwnProperty(testName)) {\n                    property = tests[testName];\n\n                    if (/^(setUp|tearDown)$/.test(testName)) {\n                        continue;\n                    }\n\n                    if (typeof property == \"function\" && rPrefix.test(testName)) {\n                        method = property;\n\n                        if (setUp || tearDown) {\n                            method = createTest(property, setUp, tearDown);\n                        }\n\n                        methods[testName] = sinon.test(method);\n                    } else {\n                        methods[testName] = tests[testName];\n                    }\n                }\n            }\n\n            return methods;\n        }\n\n        sinon.testCase = testCase;\n        return testCase;\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        require(\"./test\");\n        module.exports = makeApi(sinon);\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n}(typeof sinon == \"object\" && sinon || null));\n","/**\n * @depend util/core.js\n */\n\"use strict\";\n\n(function (sinon) {\n    function makeApi(sinon) {\n\n        function timesInWords(count) {\n            switch (count) {\n                case 1:\n                    return \"once\";\n                case 2:\n                    return \"twice\";\n                case 3:\n                    return \"thrice\";\n                default:\n                    return (count || 0) + \" times\";\n            }\n        }\n\n        sinon.timesInWords = timesInWords;\n        return sinon.timesInWords;\n    }\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        module.exports = makeApi(sinon);\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n}(typeof sinon == \"object\" && sinon || null));\n","/**\n * @depend util/core.js\n */\n/**\n * Format functions\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2014 Christian Johansen\n */\n\"use strict\";\n\n(function (sinon, formatio) {\n    function makeApi(sinon) {\n        function typeOf(value) {\n            if (value === null) {\n                return \"null\";\n            } else if (value === undefined) {\n                return \"undefined\";\n            }\n            var string = Object.prototype.toString.call(value);\n            return string.substring(8, string.length - 1).toLowerCase();\n        };\n\n        sinon.typeOf = typeOf;\n        return sinon.typeOf;\n    }\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./util/core\");\n        module.exports = makeApi(sinon);\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n}(\n    (typeof sinon == \"object\" && sinon || null),\n    (typeof formatio == \"object\" && formatio)\n));\n","/**\n * @depend ../../sinon.js\n */\n/**\n * Sinon core utilities. For internal use only.\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2013 Christian Johansen\n */\n\"use strict\";\n\n(function (sinon) {\n    var div = typeof document != \"undefined\" && document.createElement(\"div\");\n    var hasOwn = Object.prototype.hasOwnProperty;\n\n    function isDOMNode(obj) {\n        var success = false;\n\n        try {\n            obj.appendChild(div);\n            success = div.parentNode == obj;\n        } catch (e) {\n            return false;\n        } finally {\n            try {\n                obj.removeChild(div);\n            } catch (e) {\n                // Remove failed, not much we can do about that\n            }\n        }\n\n        return success;\n    }\n\n    function isElement(obj) {\n        return div && obj && obj.nodeType === 1 && isDOMNode(obj);\n    }\n\n    function isFunction(obj) {\n        return typeof obj === \"function\" || !!(obj && obj.constructor && obj.call && obj.apply);\n    }\n\n    function isReallyNaN(val) {\n        return typeof val === \"number\" && isNaN(val);\n    }\n\n    function mirrorProperties(target, source) {\n        for (var prop in source) {\n            if (!hasOwn.call(target, prop)) {\n                target[prop] = source[prop];\n            }\n        }\n    }\n\n    function isRestorable(obj) {\n        return typeof obj === \"function\" && typeof obj.restore === \"function\" && obj.restore.sinon;\n    }\n\n    // Cheap way to detect if we have ES5 support.\n    var hasES5Support = \"keys\" in Object;\n\n    function makeApi(sinon) {\n        sinon.wrapMethod = function wrapMethod(object, property, method) {\n            if (!object) {\n                throw new TypeError(\"Should wrap property of object\");\n            }\n\n            if (typeof method != \"function\" && typeof method != \"object\") {\n                throw new TypeError(\"Method wrapper should be a function or a property descriptor\");\n            }\n\n            function checkWrappedMethod(wrappedMethod) {\n                if (!isFunction(wrappedMethod)) {\n                    error = new TypeError(\"Attempted to wrap \" + (typeof wrappedMethod) + \" property \" +\n                                        property + \" as function\");\n                } else if (wrappedMethod.restore && wrappedMethod.restore.sinon) {\n                    error = new TypeError(\"Attempted to wrap \" + property + \" which is already wrapped\");\n                } else if (wrappedMethod.calledBefore) {\n                    var verb = !!wrappedMethod.returns ? \"stubbed\" : \"spied on\";\n                    error = new TypeError(\"Attempted to wrap \" + property + \" which is already \" + verb);\n                }\n\n                if (error) {\n                    if (wrappedMethod && wrappedMethod.stackTrace) {\n                        error.stack += \"\\n--------------\\n\" + wrappedMethod.stackTrace;\n                    }\n                    throw error;\n                }\n            }\n\n            var error, wrappedMethod;\n\n            // IE 8 does not support hasOwnProperty on the window object and Firefox has a problem\n            // when using hasOwn.call on objects from other frames.\n            var owned = object.hasOwnProperty ? object.hasOwnProperty(property) : hasOwn.call(object, property);\n\n            if (hasES5Support) {\n                var methodDesc = (typeof method == \"function\") ? {value: method} : method,\n                    wrappedMethodDesc = sinon.getPropertyDescriptor(object, property),\n                    i;\n\n                if (!wrappedMethodDesc) {\n                    error = new TypeError(\"Attempted to wrap \" + (typeof wrappedMethod) + \" property \" +\n                                        property + \" as function\");\n                } else if (wrappedMethodDesc.restore && wrappedMethodDesc.restore.sinon) {\n                    error = new TypeError(\"Attempted to wrap \" + property + \" which is already wrapped\");\n                }\n                if (error) {\n                    if (wrappedMethodDesc && wrappedMethodDesc.stackTrace) {\n                        error.stack += \"\\n--------------\\n\" + wrappedMethodDesc.stackTrace;\n                    }\n                    throw error;\n                }\n\n                var types = sinon.objectKeys(methodDesc);\n                for (i = 0; i < types.length; i++) {\n                    wrappedMethod = wrappedMethodDesc[types[i]];\n                    checkWrappedMethod(wrappedMethod);\n                }\n\n                mirrorProperties(methodDesc, wrappedMethodDesc);\n                for (i = 0; i < types.length; i++) {\n                    mirrorProperties(methodDesc[types[i]], wrappedMethodDesc[types[i]]);\n                }\n                Object.defineProperty(object, property, methodDesc);\n            } else {\n                wrappedMethod = object[property];\n                checkWrappedMethod(wrappedMethod);\n                object[property] = method;\n                method.displayName = property;\n            }\n\n            method.displayName = property;\n\n            // Set up a stack trace which can be used later to find what line of\n            // code the original method was created on.\n            method.stackTrace = (new Error(\"Stack Trace for original\")).stack;\n\n            method.restore = function () {\n                // For prototype properties try to reset by delete first.\n                // If this fails (ex: localStorage on mobile safari) then force a reset\n                // via direct assignment.\n                if (!owned) {\n                    try {\n                        delete object[property];\n                    } catch (e) {}\n                    // For native code functions `delete` fails without throwing an error\n                    // on Chrome < 43, PhantomJS, etc.\n                    // Use strict equality comparison to check failures then force a reset\n                    // via direct assignment.\n                    if (object[property] === method) {\n                        object[property] = wrappedMethod;\n                    }\n                } else if (hasES5Support) {\n                    Object.defineProperty(object, property, wrappedMethodDesc);\n                }\n\n                if (!hasES5Support && object[property] === method) {\n                    object[property] = wrappedMethod;\n                }\n            };\n\n            method.restore.sinon = true;\n\n            if (!hasES5Support) {\n                mirrorProperties(method, wrappedMethod);\n            }\n\n            return method;\n        };\n\n        sinon.create = function create(proto) {\n            var F = function () {};\n            F.prototype = proto;\n            return new F();\n        };\n\n        sinon.deepEqual = function deepEqual(a, b) {\n            if (sinon.match && sinon.match.isMatcher(a)) {\n                return a.test(b);\n            }\n\n            if (typeof a != \"object\" || typeof b != \"object\") {\n                if (isReallyNaN(a) && isReallyNaN(b)) {\n                    return true;\n                } else {\n                    return a === b;\n                }\n            }\n\n            if (isElement(a) || isElement(b)) {\n                return a === b;\n            }\n\n            if (a === b) {\n                return true;\n            }\n\n            if ((a === null && b !== null) || (a !== null && b === null)) {\n                return false;\n            }\n\n            if (a instanceof RegExp && b instanceof RegExp) {\n                return (a.source === b.source) && (a.global === b.global) &&\n                    (a.ignoreCase === b.ignoreCase) && (a.multiline === b.multiline);\n            }\n\n            var aString = Object.prototype.toString.call(a);\n            if (aString != Object.prototype.toString.call(b)) {\n                return false;\n            }\n\n            if (aString == \"[object Date]\") {\n                return a.valueOf() === b.valueOf();\n            }\n\n            var prop, aLength = 0, bLength = 0;\n\n            if (aString == \"[object Array]\" && a.length !== b.length) {\n                return false;\n            }\n\n            for (prop in a) {\n                aLength += 1;\n\n                if (!(prop in b)) {\n                    return false;\n                }\n\n                if (!deepEqual(a[prop], b[prop])) {\n                    return false;\n                }\n            }\n\n            for (prop in b) {\n                bLength += 1;\n            }\n\n            return aLength == bLength;\n        };\n\n        sinon.functionName = function functionName(func) {\n            var name = func.displayName || func.name;\n\n            // Use function decomposition as a last resort to get function\n            // name. Does not rely on function decomposition to work - if it\n            // doesn't debugging will be slightly less informative\n            // (i.e. toString will say 'spy' rather than 'myFunc').\n            if (!name) {\n                var matches = func.toString().match(/function ([^\\s\\(]+)/);\n                name = matches && matches[1];\n            }\n\n            return name;\n        };\n\n        sinon.functionToString = function toString() {\n            if (this.getCall && this.callCount) {\n                var thisValue, prop, i = this.callCount;\n\n                while (i--) {\n                    thisValue = this.getCall(i).thisValue;\n\n                    for (prop in thisValue) {\n                        if (thisValue[prop] === this) {\n                            return prop;\n                        }\n                    }\n                }\n            }\n\n            return this.displayName || \"sinon fake\";\n        };\n\n        sinon.objectKeys = function objectKeys(obj) {\n            if (obj !== Object(obj)) {\n                throw new TypeError(\"sinon.objectKeys called on a non-object\");\n            }\n\n            var keys = [];\n            var key;\n            for (key in obj) {\n                if (hasOwn.call(obj, key)) {\n                    keys.push(key);\n                }\n            }\n\n            return keys;\n        };\n\n        sinon.getPropertyDescriptor = function getPropertyDescriptor(object, property) {\n            var proto = object, descriptor;\n            while (proto && !(descriptor = Object.getOwnPropertyDescriptor(proto, property))) {\n                proto = Object.getPrototypeOf(proto);\n            }\n            return descriptor;\n        }\n\n        sinon.getConfig = function (custom) {\n            var config = {};\n            custom = custom || {};\n            var defaults = sinon.defaultConfig;\n\n            for (var prop in defaults) {\n                if (defaults.hasOwnProperty(prop)) {\n                    config[prop] = custom.hasOwnProperty(prop) ? custom[prop] : defaults[prop];\n                }\n            }\n\n            return config;\n        };\n\n        sinon.defaultConfig = {\n            injectIntoThis: true,\n            injectInto: null,\n            properties: [\"spy\", \"stub\", \"mock\", \"clock\", \"server\", \"requests\"],\n            useFakeTimers: true,\n            useFakeServer: true\n        };\n\n        sinon.timesInWords = function timesInWords(count) {\n            return count == 1 && \"once\" ||\n                count == 2 && \"twice\" ||\n                count == 3 && \"thrice\" ||\n                (count || 0) + \" times\";\n        };\n\n        sinon.calledInOrder = function (spies) {\n            for (var i = 1, l = spies.length; i < l; i++) {\n                if (!spies[i - 1].calledBefore(spies[i]) || !spies[i].called) {\n                    return false;\n                }\n            }\n\n            return true;\n        };\n\n        sinon.orderByFirstCall = function (spies) {\n            return spies.sort(function (a, b) {\n                // uuid, won't ever be equal\n                var aCall = a.getCall(0);\n                var bCall = b.getCall(0);\n                var aId = aCall && aCall.callId || -1;\n                var bId = bCall && bCall.callId || -1;\n\n                return aId < bId ? -1 : 1;\n            });\n        };\n\n        sinon.createStubInstance = function (constructor) {\n            if (typeof constructor !== \"function\") {\n                throw new TypeError(\"The constructor should be a function.\");\n            }\n            return sinon.stub(sinon.create(constructor.prototype));\n        };\n\n        sinon.restore = function (object) {\n            if (object !== null && typeof object === \"object\") {\n                for (var prop in object) {\n                    if (isRestorable(object[prop])) {\n                        object[prop].restore();\n                    }\n                }\n            } else if (isRestorable(object)) {\n                object.restore();\n            }\n        };\n\n        return sinon;\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports) {\n        makeApi(exports);\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports);\n    } else if (!sinon) {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n}(typeof sinon == \"object\" && sinon || null));\n","/**\n * Minimal Event interface implementation\n *\n * Original implementation by Sven Fuchs: https://gist.github.com/995028\n * Modifications and tests by Christian Johansen.\n *\n * @author Sven Fuchs (svenfuchs@artweb-design.de)\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2011 Sven Fuchs, Christian Johansen\n */\n\"use strict\";\n\nif (typeof sinon == \"undefined\") {\n    this.sinon = {};\n}\n\n(function () {\n    var push = [].push;\n\n    function makeApi(sinon) {\n        sinon.Event = function Event(type, bubbles, cancelable, target) {\n            this.initEvent(type, bubbles, cancelable, target);\n        };\n\n        sinon.Event.prototype = {\n            initEvent: function (type, bubbles, cancelable, target) {\n                this.type = type;\n                this.bubbles = bubbles;\n                this.cancelable = cancelable;\n                this.target = target;\n            },\n\n            stopPropagation: function () {},\n\n            preventDefault: function () {\n                this.defaultPrevented = true;\n            }\n        };\n\n        sinon.ProgressEvent = function ProgressEvent(type, progressEventRaw, target) {\n            this.initEvent(type, false, false, target);\n            this.loaded = progressEventRaw.loaded || null;\n            this.total = progressEventRaw.total || null;\n            this.lengthComputable = !!progressEventRaw.total;\n        };\n\n        sinon.ProgressEvent.prototype = new sinon.Event();\n\n        sinon.ProgressEvent.prototype.constructor =  sinon.ProgressEvent;\n\n        sinon.CustomEvent = function CustomEvent(type, customData, target) {\n            this.initEvent(type, false, false, target);\n            this.detail = customData.detail || null;\n        };\n\n        sinon.CustomEvent.prototype = new sinon.Event();\n\n        sinon.CustomEvent.prototype.constructor =  sinon.CustomEvent;\n\n        sinon.EventTarget = {\n            addEventListener: function addEventListener(event, listener) {\n                this.eventListeners = this.eventListeners || {};\n                this.eventListeners[event] = this.eventListeners[event] || [];\n                push.call(this.eventListeners[event], listener);\n            },\n\n            removeEventListener: function removeEventListener(event, listener) {\n                var listeners = this.eventListeners && this.eventListeners[event] || [];\n\n                for (var i = 0, l = listeners.length; i < l; ++i) {\n                    if (listeners[i] == listener) {\n                        return listeners.splice(i, 1);\n                    }\n                }\n            },\n\n            dispatchEvent: function dispatchEvent(event) {\n                var type = event.type;\n                var listeners = this.eventListeners && this.eventListeners[type] || [];\n\n                for (var i = 0; i < listeners.length; i++) {\n                    if (typeof listeners[i] == \"function\") {\n                        listeners[i].call(this, event);\n                    } else {\n                        listeners[i].handleEvent(event);\n                    }\n                }\n\n                return !!event.defaultPrevented;\n            }\n        };\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require) {\n        var sinon = require(\"./core\");\n        makeApi(sinon);\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require);\n    } else {\n        makeApi(sinon);\n    }\n}());\n","/**\n * @depend fake_xdomain_request.js\n * @depend fake_xml_http_request.js\n * @depend ../format.js\n * @depend ../log_error.js\n */\n/**\n * The Sinon \"server\" mimics a web server that receives requests from\n * sinon.FakeXMLHttpRequest and provides an API to respond to those requests,\n * both synchronously and asynchronously. To respond synchronuously, canned\n * answers have to be provided upfront.\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2013 Christian Johansen\n */\n\"use strict\";\n\nif (typeof sinon == \"undefined\") {\n    var sinon = {};\n}\n\n(function () {\n    var push = [].push;\n    function F() {}\n\n    function create(proto) {\n        F.prototype = proto;\n        return new F();\n    }\n\n    function responseArray(handler) {\n        var response = handler;\n\n        if (Object.prototype.toString.call(handler) != \"[object Array]\") {\n            response = [200, {}, handler];\n        }\n\n        if (typeof response[2] != \"string\") {\n            throw new TypeError(\"Fake server response body should be string, but was \" +\n                                typeof response[2]);\n        }\n\n        return response;\n    }\n\n    var wloc = typeof window !== \"undefined\" ? window.location : {};\n    var rCurrLoc = new RegExp(\"^\" + wloc.protocol + \"//\" + wloc.host);\n\n    function matchOne(response, reqMethod, reqUrl) {\n        var rmeth = response.method;\n        var matchMethod = !rmeth || rmeth.toLowerCase() == reqMethod.toLowerCase();\n        var url = response.url;\n        var matchUrl = !url || url == reqUrl || (typeof url.test == \"function\" && url.test(reqUrl));\n\n        return matchMethod && matchUrl;\n    }\n\n    function match(response, request) {\n        var requestUrl = request.url;\n\n        if (!/^https?:\\/\\//.test(requestUrl) || rCurrLoc.test(requestUrl)) {\n            requestUrl = requestUrl.replace(rCurrLoc, \"\");\n        }\n\n        if (matchOne(response, this.getHTTPMethod(request), requestUrl)) {\n            if (typeof response.response == \"function\") {\n                var ru = response.url;\n                var args = [request].concat(ru && typeof ru.exec == \"function\" ? ru.exec(requestUrl).slice(1) : []);\n                return response.response.apply(response, args);\n            }\n\n            return true;\n        }\n\n        return false;\n    }\n\n    function makeApi(sinon) {\n        sinon.fakeServer = {\n            create: function () {\n                var server = create(this);\n                if (!sinon.xhr.supportsCORS) {\n                    this.xhr = sinon.useFakeXDomainRequest();\n                } else {\n                    this.xhr = sinon.useFakeXMLHttpRequest();\n                }\n                server.requests = [];\n\n                this.xhr.onCreate = function (xhrObj) {\n                    server.addRequest(xhrObj);\n                };\n\n                return server;\n            },\n\n            addRequest: function addRequest(xhrObj) {\n                var server = this;\n                push.call(this.requests, xhrObj);\n\n                xhrObj.onSend = function () {\n                    server.handleRequest(this);\n\n                    if (server.respondImmediately) {\n                        server.respond();\n                    } else if (server.autoRespond && !server.responding) {\n                        setTimeout(function () {\n                            server.responding = false;\n                            server.respond();\n                        }, server.autoRespondAfter || 10);\n\n                        server.responding = true;\n                    }\n                };\n            },\n\n            getHTTPMethod: function getHTTPMethod(request) {\n                if (this.fakeHTTPMethods && /post/i.test(request.method)) {\n                    var matches = (request.requestBody || \"\").match(/_method=([^\\b;]+)/);\n                    return !!matches ? matches[1] : request.method;\n                }\n\n                return request.method;\n            },\n\n            handleRequest: function handleRequest(xhr) {\n                if (xhr.async) {\n                    if (!this.queue) {\n                        this.queue = [];\n                    }\n\n                    push.call(this.queue, xhr);\n                } else {\n                    this.processRequest(xhr);\n                }\n            },\n\n            log: function log(response, request) {\n                var str;\n\n                str =  \"Request:\\n\"  + sinon.format(request)  + \"\\n\\n\";\n                str += \"Response:\\n\" + sinon.format(response) + \"\\n\\n\";\n\n                sinon.log(str);\n            },\n\n            respondWith: function respondWith(method, url, body) {\n                if (arguments.length == 1 && typeof method != \"function\") {\n                    this.response = responseArray(method);\n                    return;\n                }\n\n                if (!this.responses) { this.responses = []; }\n\n                if (arguments.length == 1) {\n                    body = method;\n                    url = method = null;\n                }\n\n                if (arguments.length == 2) {\n                    body = url;\n                    url = method;\n                    method = null;\n                }\n\n                push.call(this.responses, {\n                    method: method,\n                    url: url,\n                    response: typeof body == \"function\" ? body : responseArray(body)\n                });\n            },\n\n            respond: function respond() {\n                if (arguments.length > 0) {\n                    this.respondWith.apply(this, arguments);\n                }\n\n                var queue = this.queue || [];\n                var requests = queue.splice(0, queue.length);\n                var request;\n\n                while (request = requests.shift()) {\n                    this.processRequest(request);\n                }\n            },\n\n            processRequest: function processRequest(request) {\n                try {\n                    if (request.aborted) {\n                        return;\n                    }\n\n                    var response = this.response || [404, {}, \"\"];\n\n                    if (this.responses) {\n                        for (var l = this.responses.length, i = l - 1; i >= 0; i--) {\n                            if (match.call(this, this.responses[i], request)) {\n                                response = this.responses[i].response;\n                                break;\n                            }\n                        }\n                    }\n\n                    if (request.readyState != 4) {\n                        this.log(response, request);\n\n                        request.respond(response[0], response[1], response[2]);\n                    }\n                } catch (e) {\n                    sinon.logError(\"Fake server request processing\", e);\n                }\n            },\n\n            restore: function restore() {\n                return this.xhr.restore && this.xhr.restore.apply(this.xhr, arguments);\n            }\n        };\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./core\");\n        require(\"./fake_xdomain_request\");\n        require(\"./fake_xml_http_request\");\n        require(\"../format\");\n        makeApi(sinon);\n        module.exports = sinon;\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else {\n        makeApi(sinon);\n    }\n}());\n","/**\n * @depend fake_server.js\n * @depend fake_timers.js\n */\n/**\n * Add-on for sinon.fakeServer that automatically handles a fake timer along with\n * the FakeXMLHttpRequest. The direct inspiration for this add-on is jQuery\n * 1.3.x, which does not use xhr object's onreadystatehandler at all - instead,\n * it polls the object for completion with setInterval. Dispite the direct\n * motivation, there is nothing jQuery-specific in this file, so it can be used\n * in any environment where the ajax implementation depends on setInterval or\n * setTimeout.\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2013 Christian Johansen\n */\n\"use strict\";\n\n(function () {\n    function makeApi(sinon) {\n        function Server() {}\n        Server.prototype = sinon.fakeServer;\n\n        sinon.fakeServerWithClock = new Server();\n\n        sinon.fakeServerWithClock.addRequest = function addRequest(xhr) {\n            if (xhr.async) {\n                if (typeof setTimeout.clock == \"object\") {\n                    this.clock = setTimeout.clock;\n                } else {\n                    this.clock = sinon.useFakeTimers();\n                    this.resetClock = true;\n                }\n\n                if (!this.longestTimeout) {\n                    var clockSetTimeout = this.clock.setTimeout;\n                    var clockSetInterval = this.clock.setInterval;\n                    var server = this;\n\n                    this.clock.setTimeout = function (fn, timeout) {\n                        server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);\n\n                        return clockSetTimeout.apply(this, arguments);\n                    };\n\n                    this.clock.setInterval = function (fn, timeout) {\n                        server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);\n\n                        return clockSetInterval.apply(this, arguments);\n                    };\n                }\n            }\n\n            return sinon.fakeServer.addRequest.call(this, xhr);\n        };\n\n        sinon.fakeServerWithClock.respond = function respond() {\n            var returnVal = sinon.fakeServer.respond.apply(this, arguments);\n\n            if (this.clock) {\n                this.clock.tick(this.longestTimeout || 0);\n                this.longestTimeout = 0;\n\n                if (this.resetClock) {\n                    this.clock.restore();\n                    this.resetClock = false;\n                }\n            }\n\n            return returnVal;\n        };\n\n        sinon.fakeServerWithClock.restore = function restore() {\n            if (this.clock) {\n                this.clock.restore();\n            }\n\n            return sinon.fakeServer.restore.apply(this, arguments);\n        };\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require) {\n        var sinon = require(\"./core\");\n        require(\"./fake_server\");\n        require(\"./fake_timers\");\n        makeApi(sinon);\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require);\n    } else {\n        makeApi(sinon);\n    }\n}());\n","(function (global){\n/*global lolex */\n\n/**\n * Fake timer API\n * setTimeout\n * setInterval\n * clearTimeout\n * clearInterval\n * tick\n * reset\n * Date\n *\n * Inspired by jsUnitMockTimeOut from JsUnit\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2013 Christian Johansen\n */\n\"use strict\";\n\nif (typeof sinon == \"undefined\") {\n    var sinon = {};\n}\n\n(function (global) {\n    function makeApi(sinon, lol) {\n        var llx = typeof lolex !== \"undefined\" ? lolex : lol;\n\n        sinon.useFakeTimers = function () {\n            var now, methods = Array.prototype.slice.call(arguments);\n\n            if (typeof methods[0] === \"string\") {\n                now = 0;\n            } else {\n                now = methods.shift();\n            }\n\n            var clock = llx.install(now || 0, methods);\n            clock.restore = clock.uninstall;\n            return clock;\n        };\n\n        sinon.clock = {\n            create: function (now) {\n                return llx.createClock(now);\n            }\n        };\n\n        sinon.timers = {\n            setTimeout: setTimeout,\n            clearTimeout: clearTimeout,\n            setImmediate: (typeof setImmediate !== \"undefined\" ? setImmediate : undefined),\n            clearImmediate: (typeof clearImmediate !== \"undefined\" ? clearImmediate : undefined),\n            setInterval: setInterval,\n            clearInterval: clearInterval,\n            Date: Date\n        };\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, epxorts, module, lolex) {\n        var sinon = require(\"./core\");\n        makeApi(sinon, lolex);\n        module.exports = sinon;\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module, require(\"lolex\"));\n    } else {\n        makeApi(sinon);\n    }\n}(typeof global != \"undefined\" && typeof global !== \"function\" ? global : this));\n\n}).call(this,typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})","/**\n * @depend core.js\n * @depend ../extend.js\n * @depend event.js\n * @depend ../log_error.js\n */\n/**\n * Fake XDomainRequest object\n */\n\"use strict\";\n\nif (typeof sinon == \"undefined\") {\n    this.sinon = {};\n}\n\n// wrapper for global\n(function (global) {\n    var xdr = { XDomainRequest: global.XDomainRequest };\n    xdr.GlobalXDomainRequest = global.XDomainRequest;\n    xdr.supportsXDR = typeof xdr.GlobalXDomainRequest != \"undefined\";\n    xdr.workingXDR = xdr.supportsXDR ? xdr.GlobalXDomainRequest :  false;\n\n    function makeApi(sinon) {\n        sinon.xdr = xdr;\n\n        function FakeXDomainRequest() {\n            this.readyState = FakeXDomainRequest.UNSENT;\n            this.requestBody = null;\n            this.requestHeaders = {};\n            this.status = 0;\n            this.timeout = null;\n\n            if (typeof FakeXDomainRequest.onCreate == \"function\") {\n                FakeXDomainRequest.onCreate(this);\n            }\n        }\n\n        function verifyState(xdr) {\n            if (xdr.readyState !== FakeXDomainRequest.OPENED) {\n                throw new Error(\"INVALID_STATE_ERR\");\n            }\n\n            if (xdr.sendFlag) {\n                throw new Error(\"INVALID_STATE_ERR\");\n            }\n        }\n\n        function verifyRequestSent(xdr) {\n            if (xdr.readyState == FakeXDomainRequest.UNSENT) {\n                throw new Error(\"Request not sent\");\n            }\n            if (xdr.readyState == FakeXDomainRequest.DONE) {\n                throw new Error(\"Request done\");\n            }\n        }\n\n        function verifyResponseBodyType(body) {\n            if (typeof body != \"string\") {\n                var error = new Error(\"Attempted to respond to fake XDomainRequest with \" +\n                                    body + \", which is not a string.\");\n                error.name = \"InvalidBodyException\";\n                throw error;\n            }\n        }\n\n        sinon.extend(FakeXDomainRequest.prototype, sinon.EventTarget, {\n            open: function open(method, url) {\n                this.method = method;\n                this.url = url;\n\n                this.responseText = null;\n                this.sendFlag = false;\n\n                this.readyStateChange(FakeXDomainRequest.OPENED);\n            },\n\n            readyStateChange: function readyStateChange(state) {\n                this.readyState = state;\n                var eventName = \"\";\n                switch (this.readyState) {\n                case FakeXDomainRequest.UNSENT:\n                    break;\n                case FakeXDomainRequest.OPENED:\n                    break;\n                case FakeXDomainRequest.LOADING:\n                    if (this.sendFlag) {\n                        //raise the progress event\n                        eventName = \"onprogress\";\n                    }\n                    break;\n                case FakeXDomainRequest.DONE:\n                    if (this.isTimeout) {\n                        eventName = \"ontimeout\"\n                    } else if (this.errorFlag || (this.status < 200 || this.status > 299)) {\n                        eventName = \"onerror\";\n                    } else {\n                        eventName = \"onload\"\n                    }\n                    break;\n                }\n\n                // raising event (if defined)\n                if (eventName) {\n                    if (typeof this[eventName] == \"function\") {\n                        try {\n                            this[eventName]();\n                        } catch (e) {\n                            sinon.logError(\"Fake XHR \" + eventName + \" handler\", e);\n                        }\n                    }\n                }\n            },\n\n            send: function send(data) {\n                verifyState(this);\n\n                if (!/^(get|head)$/i.test(this.method)) {\n                    this.requestBody = data;\n                }\n                this.requestHeaders[\"Content-Type\"] = \"text/plain;charset=utf-8\";\n\n                this.errorFlag = false;\n                this.sendFlag = true;\n                this.readyStateChange(FakeXDomainRequest.OPENED);\n\n                if (typeof this.onSend == \"function\") {\n                    this.onSend(this);\n                }\n            },\n\n            abort: function abort() {\n                this.aborted = true;\n                this.responseText = null;\n                this.errorFlag = true;\n\n                if (this.readyState > sinon.FakeXDomainRequest.UNSENT && this.sendFlag) {\n                    this.readyStateChange(sinon.FakeXDomainRequest.DONE);\n                    this.sendFlag = false;\n                }\n            },\n\n            setResponseBody: function setResponseBody(body) {\n                verifyRequestSent(this);\n                verifyResponseBodyType(body);\n\n                var chunkSize = this.chunkSize || 10;\n                var index = 0;\n                this.responseText = \"\";\n\n                do {\n                    this.readyStateChange(FakeXDomainRequest.LOADING);\n                    this.responseText += body.substring(index, index + chunkSize);\n                    index += chunkSize;\n                } while (index < body.length);\n\n                this.readyStateChange(FakeXDomainRequest.DONE);\n            },\n\n            respond: function respond(status, contentType, body) {\n                // content-type ignored, since XDomainRequest does not carry this\n                // we keep the same syntax for respond(...) as for FakeXMLHttpRequest to ease\n                // test integration across browsers\n                this.status = typeof status == \"number\" ? status : 200;\n                this.setResponseBody(body || \"\");\n            },\n\n            simulatetimeout: function simulatetimeout() {\n                this.status = 0;\n                this.isTimeout = true;\n                // Access to this should actually throw an error\n                this.responseText = undefined;\n                this.readyStateChange(FakeXDomainRequest.DONE);\n            }\n        });\n\n        sinon.extend(FakeXDomainRequest, {\n            UNSENT: 0,\n            OPENED: 1,\n            LOADING: 3,\n            DONE: 4\n        });\n\n        sinon.useFakeXDomainRequest = function useFakeXDomainRequest() {\n            sinon.FakeXDomainRequest.restore = function restore(keepOnCreate) {\n                if (xdr.supportsXDR) {\n                    global.XDomainRequest = xdr.GlobalXDomainRequest;\n                }\n\n                delete sinon.FakeXDomainRequest.restore;\n\n                if (keepOnCreate !== true) {\n                    delete sinon.FakeXDomainRequest.onCreate;\n                }\n            };\n            if (xdr.supportsXDR) {\n                global.XDomainRequest = sinon.FakeXDomainRequest;\n            }\n            return sinon.FakeXDomainRequest;\n        };\n\n        sinon.FakeXDomainRequest = FakeXDomainRequest;\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./core\");\n        require(\"../extend\");\n        require(\"./event\");\n        require(\"../log_error\");\n        makeApi(sinon);\n        module.exports = sinon;\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else {\n        makeApi(sinon);\n    }\n})(this);\n","(function (global){\n/**\n * @depend core.js\n * @depend ../extend.js\n * @depend event.js\n * @depend ../log_error.js\n */\n/**\n * Fake XMLHttpRequest object\n *\n * @author Christian Johansen (christian@cjohansen.no)\n * @license BSD\n *\n * Copyright (c) 2010-2013 Christian Johansen\n */\n\"use strict\";\n\n(function (global) {\n\n    var supportsProgress = typeof ProgressEvent !== \"undefined\";\n    var supportsCustomEvent = typeof CustomEvent !== \"undefined\";\n    var sinonXhr = { XMLHttpRequest: global.XMLHttpRequest };\n    sinonXhr.GlobalXMLHttpRequest = global.XMLHttpRequest;\n    sinonXhr.GlobalActiveXObject = global.ActiveXObject;\n    sinonXhr.supportsActiveX = typeof sinonXhr.GlobalActiveXObject != \"undefined\";\n    sinonXhr.supportsXHR = typeof sinonXhr.GlobalXMLHttpRequest != \"undefined\";\n    sinonXhr.workingXHR = sinonXhr.supportsXHR ? sinonXhr.GlobalXMLHttpRequest : sinonXhr.supportsActiveX\n                                     ? function () { return new sinonXhr.GlobalActiveXObject(\"MSXML2.XMLHTTP.3.0\") } : false;\n    sinonXhr.supportsCORS = sinonXhr.supportsXHR && \"withCredentials\" in (new sinonXhr.GlobalXMLHttpRequest());\n\n    /*jsl:ignore*/\n    var unsafeHeaders = {\n        \"Accept-Charset\": true,\n        \"Accept-Encoding\": true,\n        Connection: true,\n        \"Content-Length\": true,\n        Cookie: true,\n        Cookie2: true,\n        \"Content-Transfer-Encoding\": true,\n        Date: true,\n        Expect: true,\n        Host: true,\n        \"Keep-Alive\": true,\n        Referer: true,\n        TE: true,\n        Trailer: true,\n        \"Transfer-Encoding\": true,\n        Upgrade: true,\n        \"User-Agent\": true,\n        Via: true\n    };\n    /*jsl:end*/\n\n    function FakeXMLHttpRequest() {\n        this.readyState = FakeXMLHttpRequest.UNSENT;\n        this.requestHeaders = {};\n        this.requestBody = null;\n        this.status = 0;\n        this.statusText = \"\";\n        this.upload = new UploadProgress();\n        if (sinonXhr.supportsCORS) {\n            this.withCredentials = false;\n        }\n\n        var xhr = this;\n        var events = [\"loadstart\", \"load\", \"abort\", \"loadend\"];\n\n        function addEventListener(eventName) {\n            xhr.addEventListener(eventName, function (event) {\n                var listener = xhr[\"on\" + eventName];\n\n                if (listener && typeof listener == \"function\") {\n                    listener.call(this, event);\n                }\n            });\n        }\n\n        for (var i = events.length - 1; i >= 0; i--) {\n            addEventListener(events[i]);\n        }\n\n        if (typeof FakeXMLHttpRequest.onCreate == \"function\") {\n            FakeXMLHttpRequest.onCreate(this);\n        }\n    }\n\n    // An upload object is created for each\n    // FakeXMLHttpRequest and allows upload\n    // events to be simulated using uploadProgress\n    // and uploadError.\n    function UploadProgress() {\n        this.eventListeners = {\n            progress: [],\n            load: [],\n            abort: [],\n            error: []\n        }\n    }\n\n    UploadProgress.prototype.addEventListener = function addEventListener(event, listener) {\n        this.eventListeners[event].push(listener);\n    };\n\n    UploadProgress.prototype.removeEventListener = function removeEventListener(event, listener) {\n        var listeners = this.eventListeners[event] || [];\n\n        for (var i = 0, l = listeners.length; i < l; ++i) {\n            if (listeners[i] == listener) {\n                return listeners.splice(i, 1);\n            }\n        }\n    };\n\n    UploadProgress.prototype.dispatchEvent = function dispatchEvent(event) {\n        var listeners = this.eventListeners[event.type] || [];\n\n        for (var i = 0, listener; (listener = listeners[i]) != null; i++) {\n            listener(event);\n        }\n    };\n\n    function verifyState(xhr) {\n        if (xhr.readyState !== FakeXMLHttpRequest.OPENED) {\n            throw new Error(\"INVALID_STATE_ERR\");\n        }\n\n        if (xhr.sendFlag) {\n            throw new Error(\"INVALID_STATE_ERR\");\n        }\n    }\n\n    function getHeader(headers, header) {\n        header = header.toLowerCase();\n\n        for (var h in headers) {\n            if (h.toLowerCase() == header) {\n                return h;\n            }\n        }\n\n        return null;\n    }\n\n    // filtering to enable a white-list version of Sinon FakeXhr,\n    // where whitelisted requests are passed through to real XHR\n    function each(collection, callback) {\n        if (!collection) {\n            return;\n        }\n\n        for (var i = 0, l = collection.length; i < l; i += 1) {\n            callback(collection[i]);\n        }\n    }\n    function some(collection, callback) {\n        for (var index = 0; index < collection.length; index++) {\n            if (callback(collection[index]) === true) {\n                return true;\n            }\n        }\n        return false;\n    }\n    // largest arity in XHR is 5 - XHR#open\n    var apply = function (obj, method, args) {\n        switch (args.length) {\n        case 0: return obj[method]();\n        case 1: return obj[method](args[0]);\n        case 2: return obj[method](args[0], args[1]);\n        case 3: return obj[method](args[0], args[1], args[2]);\n        case 4: return obj[method](args[0], args[1], args[2], args[3]);\n        case 5: return obj[method](args[0], args[1], args[2], args[3], args[4]);\n        }\n    };\n\n    FakeXMLHttpRequest.filters = [];\n    FakeXMLHttpRequest.addFilter = function addFilter(fn) {\n        this.filters.push(fn)\n    };\n    var IE6Re = /MSIE 6/;\n    FakeXMLHttpRequest.defake = function defake(fakeXhr, xhrArgs) {\n        var xhr = new sinonXhr.workingXHR();\n        each([\n            \"open\",\n            \"setRequestHeader\",\n            \"send\",\n            \"abort\",\n            \"getResponseHeader\",\n            \"getAllResponseHeaders\",\n            \"addEventListener\",\n            \"overrideMimeType\",\n            \"removeEventListener\"\n        ], function (method) {\n            fakeXhr[method] = function () {\n                return apply(xhr, method, arguments);\n            };\n        });\n\n        var copyAttrs = function (args) {\n            each(args, function (attr) {\n                try {\n                    fakeXhr[attr] = xhr[attr]\n                } catch (e) {\n                    if (!IE6Re.test(navigator.userAgent)) {\n                        throw e;\n                    }\n                }\n            });\n        };\n\n        var stateChange = function stateChange() {\n            fakeXhr.readyState = xhr.readyState;\n            if (xhr.readyState >= FakeXMLHttpRequest.HEADERS_RECEIVED) {\n                copyAttrs([\"status\", \"statusText\"]);\n            }\n            if (xhr.readyState >= FakeXMLHttpRequest.LOADING) {\n                copyAttrs([\"responseText\", \"response\"]);\n            }\n            if (xhr.readyState === FakeXMLHttpRequest.DONE) {\n                copyAttrs([\"responseXML\"]);\n            }\n            if (fakeXhr.onreadystatechange) {\n                fakeXhr.onreadystatechange.call(fakeXhr, { target: fakeXhr });\n            }\n        };\n\n        if (xhr.addEventListener) {\n            for (var event in fakeXhr.eventListeners) {\n                if (fakeXhr.eventListeners.hasOwnProperty(event)) {\n                    each(fakeXhr.eventListeners[event], function (handler) {\n                        xhr.addEventListener(event, handler);\n                    });\n                }\n            }\n            xhr.addEventListener(\"readystatechange\", stateChange);\n        } else {\n            xhr.onreadystatechange = stateChange;\n        }\n        apply(xhr, \"open\", xhrArgs);\n    };\n    FakeXMLHttpRequest.useFilters = false;\n\n    function verifyRequestOpened(xhr) {\n        if (xhr.readyState != FakeXMLHttpRequest.OPENED) {\n            throw new Error(\"INVALID_STATE_ERR - \" + xhr.readyState);\n        }\n    }\n\n    function verifyRequestSent(xhr) {\n        if (xhr.readyState == FakeXMLHttpRequest.DONE) {\n            throw new Error(\"Request done\");\n        }\n    }\n\n    function verifyHeadersReceived(xhr) {\n        if (xhr.async && xhr.readyState != FakeXMLHttpRequest.HEADERS_RECEIVED) {\n            throw new Error(\"No headers received\");\n        }\n    }\n\n    function verifyResponseBodyType(body) {\n        if (typeof body != \"string\") {\n            var error = new Error(\"Attempted to respond to fake XMLHttpRequest with \" +\n                                 body + \", which is not a string.\");\n            error.name = \"InvalidBodyException\";\n            throw error;\n        }\n    }\n\n    FakeXMLHttpRequest.parseXML = function parseXML(text) {\n        var xmlDoc;\n\n        if (typeof DOMParser != \"undefined\") {\n            var parser = new DOMParser();\n            xmlDoc = parser.parseFromString(text, \"text/xml\");\n        } else {\n            xmlDoc = new ActiveXObject(\"Microsoft.XMLDOM\");\n            xmlDoc.async = \"false\";\n            xmlDoc.loadXML(text);\n        }\n\n        return xmlDoc;\n    };\n\n    FakeXMLHttpRequest.statusCodes = {\n        100: \"Continue\",\n        101: \"Switching Protocols\",\n        200: \"OK\",\n        201: \"Created\",\n        202: \"Accepted\",\n        203: \"Non-Authoritative Information\",\n        204: \"No Content\",\n        205: \"Reset Content\",\n        206: \"Partial Content\",\n        207: \"Multi-Status\",\n        300: \"Multiple Choice\",\n        301: \"Moved Permanently\",\n        302: \"Found\",\n        303: \"See Other\",\n        304: \"Not Modified\",\n        305: \"Use Proxy\",\n        307: \"Temporary Redirect\",\n        400: \"Bad Request\",\n        401: \"Unauthorized\",\n        402: \"Payment Required\",\n        403: \"Forbidden\",\n        404: \"Not Found\",\n        405: \"Method Not Allowed\",\n        406: \"Not Acceptable\",\n        407: \"Proxy Authentication Required\",\n        408: \"Request Timeout\",\n        409: \"Conflict\",\n        410: \"Gone\",\n        411: \"Length Required\",\n        412: \"Precondition Failed\",\n        413: \"Request Entity Too Large\",\n        414: \"Request-URI Too Long\",\n        415: \"Unsupported Media Type\",\n        416: \"Requested Range Not Satisfiable\",\n        417: \"Expectation Failed\",\n        422: \"Unprocessable Entity\",\n        500: \"Internal Server Error\",\n        501: \"Not Implemented\",\n        502: \"Bad Gateway\",\n        503: \"Service Unavailable\",\n        504: \"Gateway Timeout\",\n        505: \"HTTP Version Not Supported\"\n    };\n\n    function makeApi(sinon) {\n        sinon.xhr = sinonXhr;\n\n        sinon.extend(FakeXMLHttpRequest.prototype, sinon.EventTarget, {\n            async: true,\n\n            open: function open(method, url, async, username, password) {\n                this.method = method;\n                this.url = url;\n                this.async = typeof async == \"boolean\" ? async : true;\n                this.username = username;\n                this.password = password;\n                this.responseText = null;\n                this.responseXML = null;\n                this.requestHeaders = {};\n                this.sendFlag = false;\n\n                if (FakeXMLHttpRequest.useFilters === true) {\n                    var xhrArgs = arguments;\n                    var defake = some(FakeXMLHttpRequest.filters, function (filter) {\n                        return filter.apply(this, xhrArgs)\n                    });\n                    if (defake) {\n                        return FakeXMLHttpRequest.defake(this, arguments);\n                    }\n                }\n                this.readyStateChange(FakeXMLHttpRequest.OPENED);\n            },\n\n            readyStateChange: function readyStateChange(state) {\n                this.readyState = state;\n\n                if (typeof this.onreadystatechange == \"function\") {\n                    try {\n                        this.onreadystatechange();\n                    } catch (e) {\n                        sinon.logError(\"Fake XHR onreadystatechange handler\", e);\n                    }\n                }\n\n                this.dispatchEvent(new sinon.Event(\"readystatechange\"));\n\n                switch (this.readyState) {\n                    case FakeXMLHttpRequest.DONE:\n                        this.dispatchEvent(new sinon.Event(\"load\", false, false, this));\n                        this.dispatchEvent(new sinon.Event(\"loadend\", false, false, this));\n                        this.upload.dispatchEvent(new sinon.Event(\"load\", false, false, this));\n                        if (supportsProgress) {\n                            this.upload.dispatchEvent(new sinon.ProgressEvent(\"progress\", {loaded: 100, total: 100}));\n                            this.dispatchEvent(new sinon.ProgressEvent(\"progress\", {loaded: 100, total: 100}));\n                        }\n                        break;\n                }\n            },\n\n            setRequestHeader: function setRequestHeader(header, value) {\n                verifyState(this);\n\n                if (unsafeHeaders[header] || /^(Sec-|Proxy-)/.test(header)) {\n                    throw new Error(\"Refused to set unsafe header \\\"\" + header + \"\\\"\");\n                }\n\n                if (this.requestHeaders[header]) {\n                    this.requestHeaders[header] += \",\" + value;\n                } else {\n                    this.requestHeaders[header] = value;\n                }\n            },\n\n            // Helps testing\n            setResponseHeaders: function setResponseHeaders(headers) {\n                verifyRequestOpened(this);\n                this.responseHeaders = {};\n\n                for (var header in headers) {\n                    if (headers.hasOwnProperty(header)) {\n                        this.responseHeaders[header] = headers[header];\n                    }\n                }\n\n                if (this.async) {\n                    this.readyStateChange(FakeXMLHttpRequest.HEADERS_RECEIVED);\n                } else {\n                    this.readyState = FakeXMLHttpRequest.HEADERS_RECEIVED;\n                }\n            },\n\n            // Currently treats ALL data as a DOMString (i.e. no Document)\n            send: function send(data) {\n                verifyState(this);\n\n                if (!/^(get|head)$/i.test(this.method)) {\n                    var contentType = getHeader(this.requestHeaders, \"Content-Type\");\n                    if (this.requestHeaders[contentType]) {\n                        var value = this.requestHeaders[contentType].split(\";\");\n                        this.requestHeaders[contentType] = value[0] + \";charset=utf-8\";\n                    } else if (!(data instanceof FormData)) {\n                        this.requestHeaders[\"Content-Type\"] = \"text/plain;charset=utf-8\";\n                    }\n\n                    this.requestBody = data;\n                }\n\n                this.errorFlag = false;\n                this.sendFlag = this.async;\n                this.readyStateChange(FakeXMLHttpRequest.OPENED);\n\n                if (typeof this.onSend == \"function\") {\n                    this.onSend(this);\n                }\n\n                this.dispatchEvent(new sinon.Event(\"loadstart\", false, false, this));\n            },\n\n            abort: function abort() {\n                this.aborted = true;\n                this.responseText = null;\n                this.errorFlag = true;\n                this.requestHeaders = {};\n\n                if (this.readyState > FakeXMLHttpRequest.UNSENT && this.sendFlag) {\n                    this.readyStateChange(FakeXMLHttpRequest.DONE);\n                    this.sendFlag = false;\n                }\n\n                this.readyState = FakeXMLHttpRequest.UNSENT;\n\n                this.dispatchEvent(new sinon.Event(\"abort\", false, false, this));\n\n                this.upload.dispatchEvent(new sinon.Event(\"abort\", false, false, this));\n\n                if (typeof this.onerror === \"function\") {\n                    this.onerror();\n                }\n            },\n\n            getResponseHeader: function getResponseHeader(header) {\n                if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {\n                    return null;\n                }\n\n                if (/^Set-Cookie2?$/i.test(header)) {\n                    return null;\n                }\n\n                header = getHeader(this.responseHeaders, header);\n\n                return this.responseHeaders[header] || null;\n            },\n\n            getAllResponseHeaders: function getAllResponseHeaders() {\n                if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {\n                    return \"\";\n                }\n\n                var headers = \"\";\n\n                for (var header in this.responseHeaders) {\n                    if (this.responseHeaders.hasOwnProperty(header) &&\n                        !/^Set-Cookie2?$/i.test(header)) {\n                        headers += header + \": \" + this.responseHeaders[header] + \"\\r\\n\";\n                    }\n                }\n\n                return headers;\n            },\n\n            setResponseBody: function setResponseBody(body) {\n                verifyRequestSent(this);\n                verifyHeadersReceived(this);\n                verifyResponseBodyType(body);\n\n                var chunkSize = this.chunkSize || 10;\n                var index = 0;\n                this.responseText = \"\";\n\n                do {\n                    if (this.async) {\n                        this.readyStateChange(FakeXMLHttpRequest.LOADING);\n                    }\n\n                    this.responseText += body.substring(index, index + chunkSize);\n                    index += chunkSize;\n                } while (index < body.length);\n\n                var type = this.getResponseHeader(\"Content-Type\");\n\n                if (this.responseText &&\n                    (!type || /(text\\/xml)|(application\\/xml)|(\\+xml)/.test(type))) {\n                    try {\n                        this.responseXML = FakeXMLHttpRequest.parseXML(this.responseText);\n                    } catch (e) {\n                        // Unable to parse XML - no biggie\n                    }\n                }\n\n                this.readyStateChange(FakeXMLHttpRequest.DONE);\n            },\n\n            respond: function respond(status, headers, body) {\n                this.status = typeof status == \"number\" ? status : 200;\n                this.statusText = FakeXMLHttpRequest.statusCodes[this.status];\n                this.setResponseHeaders(headers || {});\n                this.setResponseBody(body || \"\");\n            },\n\n            uploadProgress: function uploadProgress(progressEventRaw) {\n                if (supportsProgress) {\n                    this.upload.dispatchEvent(new sinon.ProgressEvent(\"progress\", progressEventRaw));\n                }\n            },\n\n            downloadProgress: function downloadProgress(progressEventRaw) {\n                if (supportsProgress) {\n                    this.dispatchEvent(new sinon.ProgressEvent(\"progress\", progressEventRaw));\n                }\n            },\n\n            uploadError: function uploadError(error) {\n                if (supportsCustomEvent) {\n                    this.upload.dispatchEvent(new sinon.CustomEvent(\"error\", {detail: error}));\n                }\n            }\n        });\n\n        sinon.extend(FakeXMLHttpRequest, {\n            UNSENT: 0,\n            OPENED: 1,\n            HEADERS_RECEIVED: 2,\n            LOADING: 3,\n            DONE: 4\n        });\n\n        sinon.useFakeXMLHttpRequest = function () {\n            FakeXMLHttpRequest.restore = function restore(keepOnCreate) {\n                if (sinonXhr.supportsXHR) {\n                    global.XMLHttpRequest = sinonXhr.GlobalXMLHttpRequest;\n                }\n\n                if (sinonXhr.supportsActiveX) {\n                    global.ActiveXObject = sinonXhr.GlobalActiveXObject;\n                }\n\n                delete FakeXMLHttpRequest.restore;\n\n                if (keepOnCreate !== true) {\n                    delete FakeXMLHttpRequest.onCreate;\n                }\n            };\n            if (sinonXhr.supportsXHR) {\n                global.XMLHttpRequest = FakeXMLHttpRequest;\n            }\n\n            if (sinonXhr.supportsActiveX) {\n                global.ActiveXObject = function ActiveXObject(objId) {\n                    if (objId == \"Microsoft.XMLHTTP\" || /^Msxml2\\.XMLHTTP/i.test(objId)) {\n\n                        return new FakeXMLHttpRequest();\n                    }\n\n                    return new sinonXhr.GlobalActiveXObject(objId);\n                };\n            }\n\n            return FakeXMLHttpRequest;\n        };\n\n        sinon.FakeXMLHttpRequest = FakeXMLHttpRequest;\n    }\n\n    var isNode = typeof module !== \"undefined\" && module.exports && typeof require == \"function\";\n    var isAMD = typeof define === \"function\" && typeof define.amd === \"object\" && define.amd;\n\n    function loadDependencies(require, exports, module) {\n        var sinon = require(\"./core\");\n        require(\"../extend\");\n        require(\"./event\");\n        require(\"../log_error\");\n        makeApi(sinon);\n        module.exports = sinon;\n    }\n\n    if (isAMD) {\n        define(loadDependencies);\n    } else if (isNode) {\n        loadDependencies(require, module.exports, module);\n    } else if (typeof sinon === \"undefined\") {\n        return;\n    } else {\n        makeApi(sinon);\n    }\n\n})(typeof global !== \"undefined\" ? global : this);\n\n}).call(this,typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})","(function (global){\n((typeof define === \"function\" && define.amd && function (m) {\n    define(\"formatio\", [\"samsam\"], m);\n}) || (typeof module === \"object\" && function (m) {\n    module.exports = m(require(\"samsam\"));\n}) || function (m) { this.formatio = m(this.samsam); }\n)(function (samsam) {\n    \"use strict\";\n\n    var formatio = {\n        excludeConstructors: [\"Object\", /^.$/],\n        quoteStrings: true,\n        limitChildrenCount: 0\n    };\n\n    var hasOwn = Object.prototype.hasOwnProperty;\n\n    var specialObjects = [];\n    if (typeof global !== \"undefined\") {\n        specialObjects.push({ object: global, value: \"[object global]\" });\n    }\n    if (typeof document !== \"undefined\") {\n        specialObjects.push({\n            object: document,\n            value: \"[object HTMLDocument]\"\n        });\n    }\n    if (typeof window !== \"undefined\") {\n        specialObjects.push({ object: window, value: \"[object Window]\" });\n    }\n\n    function functionName(func) {\n        if (!func) { return \"\"; }\n        if (func.displayName) { return func.displayName; }\n        if (func.name) { return func.name; }\n        var matches = func.toString().match(/function\\s+([^\\(]+)/m);\n        return (matches && matches[1]) || \"\";\n    }\n\n    function constructorName(f, object) {\n        var name = functionName(object && object.constructor);\n        var excludes = f.excludeConstructors ||\n                formatio.excludeConstructors || [];\n\n        var i, l;\n        for (i = 0, l = excludes.length; i < l; ++i) {\n            if (typeof excludes[i] === \"string\" && excludes[i] === name) {\n                return \"\";\n            } else if (excludes[i].test && excludes[i].test(name)) {\n                return \"\";\n            }\n        }\n\n        return name;\n    }\n\n    function isCircular(object, objects) {\n        if (typeof object !== \"object\") { return false; }\n        var i, l;\n        for (i = 0, l = objects.length; i < l; ++i) {\n            if (objects[i] === object) { return true; }\n        }\n        return false;\n    }\n\n    function ascii(f, object, processed, indent) {\n        if (typeof object === \"string\") {\n            var qs = f.quoteStrings;\n            var quote = typeof qs !== \"boolean\" || qs;\n            return processed || quote ? '\"' + object + '\"' : object;\n        }\n\n        if (typeof object === \"function\" && !(object instanceof RegExp)) {\n            return ascii.func(object);\n        }\n\n        processed = processed || [];\n\n        if (isCircular(object, processed)) { return \"[Circular]\"; }\n\n        if (Object.prototype.toString.call(object) === \"[object Array]\") {\n            return ascii.array.call(f, object, processed);\n        }\n\n        if (!object) { return String((1/object) === -Infinity ? \"-0\" : object); }\n        if (samsam.isElement(object)) { return ascii.element(object); }\n\n        if (typeof object.toString === \"function\" &&\n                object.toString !== Object.prototype.toString) {\n            return object.toString();\n        }\n\n        var i, l;\n        for (i = 0, l = specialObjects.length; i < l; i++) {\n            if (object === specialObjects[i].object) {\n                return specialObjects[i].value;\n            }\n        }\n\n        return ascii.object.call(f, object, processed, indent);\n    }\n\n    ascii.func = function (func) {\n        return \"function \" + functionName(func) + \"() {}\";\n    };\n\n    ascii.array = function (array, processed) {\n        processed = processed || [];\n        processed.push(array);\n        var pieces = [];\n        var i, l;\n        l = (this.limitChildrenCount > 0) ? \n            Math.min(this.limitChildrenCount, array.length) : array.length;\n\n        for (i = 0; i < l; ++i) {\n            pieces.push(ascii(this, array[i], processed));\n        }\n\n        if(l < array.length)\n            pieces.push(\"[... \" + (array.length - l) + \" more elements]\");\n\n        return \"[\" + pieces.join(\", \") + \"]\";\n    };\n\n    ascii.object = function (object, processed, indent) {\n        processed = processed || [];\n        processed.push(object);\n        indent = indent || 0;\n        var pieces = [], properties = samsam.keys(object).sort();\n        var length = 3;\n        var prop, str, obj, i, k, l;\n        l = (this.limitChildrenCount > 0) ? \n            Math.min(this.limitChildrenCount, properties.length) : properties.length;\n\n        for (i = 0; i < l; ++i) {\n            prop = properties[i];\n            obj = object[prop];\n\n            if (isCircular(obj, processed)) {\n                str = \"[Circular]\";\n            } else {\n                str = ascii(this, obj, processed, indent + 2);\n            }\n\n            str = (/\\s/.test(prop) ? '\"' + prop + '\"' : prop) + \": \" + str;\n            length += str.length;\n            pieces.push(str);\n        }\n\n        var cons = constructorName(this, object);\n        var prefix = cons ? \"[\" + cons + \"] \" : \"\";\n        var is = \"\";\n        for (i = 0, k = indent; i < k; ++i) { is += \" \"; }\n\n        if(l < properties.length)\n            pieces.push(\"[... \" + (properties.length - l) + \" more elements]\");\n\n        if (length + indent > 80) {\n            return prefix + \"{\\n  \" + is + pieces.join(\",\\n  \" + is) + \"\\n\" +\n                is + \"}\";\n        }\n        return prefix + \"{ \" + pieces.join(\", \") + \" }\";\n    };\n\n    ascii.element = function (element) {\n        var tagName = element.tagName.toLowerCase();\n        var attrs = element.attributes, attr, pairs = [], attrName, i, l, val;\n\n        for (i = 0, l = attrs.length; i < l; ++i) {\n            attr = attrs.item(i);\n            attrName = attr.nodeName.toLowerCase().replace(\"html:\", \"\");\n            val = attr.nodeValue;\n            if (attrName !== \"contenteditable\" || val !== \"inherit\") {\n                if (!!val) { pairs.push(attrName + \"=\\\"\" + val + \"\\\"\"); }\n            }\n        }\n\n        var formatted = \"<\" + tagName + (pairs.length > 0 ? \" \" : \"\");\n        var content = element.innerHTML;\n\n        if (content.length > 20) {\n            content = content.substr(0, 20) + \"[...]\";\n        }\n\n        var res = formatted + pairs.join(\" \") + \">\" + content +\n                \"</\" + tagName + \">\";\n\n        return res.replace(/ contentEditable=\"inherit\"/, \"\");\n    };\n\n    function Formatio(options) {\n        for (var opt in options) {\n            this[opt] = options[opt];\n        }\n    }\n\n    Formatio.prototype = {\n        functionName: functionName,\n\n        configure: function (options) {\n            return new Formatio(options);\n        },\n\n        constructorName: function (object) {\n            return constructorName(this, object);\n        },\n\n        ascii: function (object, processed, indent) {\n            return ascii(this, object, processed, indent);\n        }\n    };\n\n    return Formatio.prototype;\n});\n\n}).call(this,typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})","((typeof define === \"function\" && define.amd && function (m) { define(\"samsam\", m); }) ||\n (typeof module === \"object\" &&\n      function (m) { module.exports = m(); }) || // Node\n function (m) { this.samsam = m(); } // Browser globals\n)(function () {\n    var o = Object.prototype;\n    var div = typeof document !== \"undefined\" && document.createElement(\"div\");\n\n    function isNaN(value) {\n        // Unlike global isNaN, this avoids type coercion\n        // typeof check avoids IE host object issues, hat tip to\n        // lodash\n        var val = value; // JsLint thinks value !== value is \"weird\"\n        return typeof value === \"number\" && value !== val;\n    }\n\n    function getClass(value) {\n        // Returns the internal [[Class]] by calling Object.prototype.toString\n        // with the provided value as this. Return value is a string, naming the\n        // internal class, e.g. \"Array\"\n        return o.toString.call(value).split(/[ \\]]/)[1];\n    }\n\n    /**\n     * @name samsam.isArguments\n     * @param Object object\n     *\n     * Returns ``true`` if ``object`` is an ``arguments`` object,\n     * ``false`` otherwise.\n     */\n    function isArguments(object) {\n        if (getClass(object) === 'Arguments') { return true; }\n        if (typeof object !== \"object\" || typeof object.length !== \"number\" ||\n                getClass(object) === \"Array\") {\n            return false;\n        }\n        if (typeof object.callee == \"function\") { return true; }\n        try {\n            object[object.length] = 6;\n            delete object[object.length];\n        } catch (e) {\n            return true;\n        }\n        return false;\n    }\n\n    /**\n     * @name samsam.isElement\n     * @param Object object\n     *\n     * Returns ``true`` if ``object`` is a DOM element node. Unlike\n     * Underscore.js/lodash, this function will return ``false`` if ``object``\n     * is an *element-like* object, i.e. a regular object with a ``nodeType``\n     * property that holds the value ``1``.\n     */\n    function isElement(object) {\n        if (!object || object.nodeType !== 1 || !div) { return false; }\n        try {\n            object.appendChild(div);\n            object.removeChild(div);\n        } catch (e) {\n            return false;\n        }\n        return true;\n    }\n\n    /**\n     * @name samsam.keys\n     * @param Object object\n     *\n     * Return an array of own property names.\n     */\n    function keys(object) {\n        var ks = [], prop;\n        for (prop in object) {\n            if (o.hasOwnProperty.call(object, prop)) { ks.push(prop); }\n        }\n        return ks;\n    }\n\n    /**\n     * @name samsam.isDate\n     * @param Object value\n     *\n     * Returns true if the object is a ``Date``, or *date-like*. Duck typing\n     * of date objects work by checking that the object has a ``getTime``\n     * function whose return value equals the return value from the object's\n     * ``valueOf``.\n     */\n    function isDate(value) {\n        return typeof value.getTime == \"function\" &&\n            value.getTime() == value.valueOf();\n    }\n\n    /**\n     * @name samsam.isNegZero\n     * @param Object value\n     *\n     * Returns ``true`` if ``value`` is ``-0``.\n     */\n    function isNegZero(value) {\n        return value === 0 && 1 / value === -Infinity;\n    }\n\n    /**\n     * @name samsam.equal\n     * @param Object obj1\n     * @param Object obj2\n     *\n     * Returns ``true`` if two objects are strictly equal. Compared to\n     * ``===`` there are two exceptions:\n     *\n     *   - NaN is considered equal to NaN\n     *   - -0 and +0 are not considered equal\n     */\n    function identical(obj1, obj2) {\n        if (obj1 === obj2 || (isNaN(obj1) && isNaN(obj2))) {\n            return obj1 !== 0 || isNegZero(obj1) === isNegZero(obj2);\n        }\n    }\n\n\n    /**\n     * @name samsam.deepEqual\n     * @param Object obj1\n     * @param Object obj2\n     *\n     * Deep equal comparison. Two values are \"deep equal\" if:\n     *\n     *   - They are equal, according to samsam.identical\n     *   - They are both date objects representing the same time\n     *   - They are both arrays containing elements that are all deepEqual\n     *   - They are objects with the same set of properties, and each property\n     *     in ``obj1`` is deepEqual to the corresponding property in ``obj2``\n     *\n     * Supports cyclic objects.\n     */\n    function deepEqualCyclic(obj1, obj2) {\n\n        // used for cyclic comparison\n        // contain already visited objects\n        var objects1 = [],\n            objects2 = [],\n        // contain pathes (position in the object structure)\n        // of the already visited objects\n        // indexes same as in objects arrays\n            paths1 = [],\n            paths2 = [],\n        // contains combinations of already compared objects\n        // in the manner: { \"$1['ref']$2['ref']\": true }\n            compared = {};\n\n        /**\n         * used to check, if the value of a property is an object\n         * (cyclic logic is only needed for objects)\n         * only needed for cyclic logic\n         */\n        function isObject(value) {\n\n            if (typeof value === 'object' && value !== null &&\n                    !(value instanceof Boolean) &&\n                    !(value instanceof Date)    &&\n                    !(value instanceof Number)  &&\n                    !(value instanceof RegExp)  &&\n                    !(value instanceof String)) {\n\n                return true;\n            }\n\n            return false;\n        }\n\n        /**\n         * returns the index of the given object in the\n         * given objects array, -1 if not contained\n         * only needed for cyclic logic\n         */\n        function getIndex(objects, obj) {\n\n            var i;\n            for (i = 0; i < objects.length; i++) {\n                if (objects[i] === obj) {\n                    return i;\n                }\n            }\n\n            return -1;\n        }\n\n        // does the recursion for the deep equal check\n        return (function deepEqual(obj1, obj2, path1, path2) {\n            var type1 = typeof obj1;\n            var type2 = typeof obj2;\n\n            // == null also matches undefined\n            if (obj1 === obj2 ||\n                    isNaN(obj1) || isNaN(obj2) ||\n                    obj1 == null || obj2 == null ||\n                    type1 !== \"object\" || type2 !== \"object\") {\n\n                return identical(obj1, obj2);\n            }\n\n            // Elements are only equal if identical(expected, actual)\n            if (isElement(obj1) || isElement(obj2)) { return false; }\n\n            var isDate1 = isDate(obj1), isDate2 = isDate(obj2);\n            if (isDate1 || isDate2) {\n                if (!isDate1 || !isDate2 || obj1.getTime() !== obj2.getTime()) {\n                    return false;\n                }\n            }\n\n            if (obj1 instanceof RegExp && obj2 instanceof RegExp) {\n                if (obj1.toString() !== obj2.toString()) { return false; }\n            }\n\n            var class1 = getClass(obj1);\n            var class2 = getClass(obj2);\n            var keys1 = keys(obj1);\n            var keys2 = keys(obj2);\n\n            if (isArguments(obj1) || isArguments(obj2)) {\n                if (obj1.length !== obj2.length) { return false; }\n            } else {\n                if (type1 !== type2 || class1 !== class2 ||\n                        keys1.length !== keys2.length) {\n                    return false;\n                }\n            }\n\n            var key, i, l,\n                // following vars are used for the cyclic logic\n                value1, value2,\n                isObject1, isObject2,\n                index1, index2,\n                newPath1, newPath2;\n\n            for (i = 0, l = keys1.length; i < l; i++) {\n                key = keys1[i];\n                if (!o.hasOwnProperty.call(obj2, key)) {\n                    return false;\n                }\n\n                // Start of the cyclic logic\n\n                value1 = obj1[key];\n                value2 = obj2[key];\n\n                isObject1 = isObject(value1);\n                isObject2 = isObject(value2);\n\n                // determine, if the objects were already visited\n                // (it's faster to check for isObject first, than to\n                // get -1 from getIndex for non objects)\n                index1 = isObject1 ? getIndex(objects1, value1) : -1;\n                index2 = isObject2 ? getIndex(objects2, value2) : -1;\n\n                // determine the new pathes of the objects\n                // - for non cyclic objects the current path will be extended\n                //   by current property name\n                // - for cyclic objects the stored path is taken\n                newPath1 = index1 !== -1\n                    ? paths1[index1]\n                    : path1 + '[' + JSON.stringify(key) + ']';\n                newPath2 = index2 !== -1\n                    ? paths2[index2]\n                    : path2 + '[' + JSON.stringify(key) + ']';\n\n                // stop recursion if current objects are already compared\n                if (compared[newPath1 + newPath2]) {\n                    return true;\n                }\n\n                // remember the current objects and their pathes\n                if (index1 === -1 && isObject1) {\n                    objects1.push(value1);\n                    paths1.push(newPath1);\n                }\n                if (index2 === -1 && isObject2) {\n                    objects2.push(value2);\n                    paths2.push(newPath2);\n                }\n\n                // remember that the current objects are already compared\n                if (isObject1 && isObject2) {\n                    compared[newPath1 + newPath2] = true;\n                }\n\n                // End of cyclic logic\n\n                // neither value1 nor value2 is a cycle\n                // continue with next level\n                if (!deepEqual(value1, value2, newPath1, newPath2)) {\n                    return false;\n                }\n            }\n\n            return true;\n\n        }(obj1, obj2, '$1', '$2'));\n    }\n\n    var match;\n\n    function arrayContains(array, subset) {\n        if (subset.length === 0) { return true; }\n        var i, l, j, k;\n        for (i = 0, l = array.length; i < l; ++i) {\n            if (match(array[i], subset[0])) {\n                for (j = 0, k = subset.length; j < k; ++j) {\n                    if (!match(array[i + j], subset[j])) { return false; }\n                }\n                return true;\n            }\n        }\n        return false;\n    }\n\n    /**\n     * @name samsam.match\n     * @param Object object\n     * @param Object matcher\n     *\n     * Compare arbitrary value ``object`` with matcher.\n     */\n    match = function match(object, matcher) {\n        if (matcher && typeof matcher.test === \"function\") {\n            return matcher.test(object);\n        }\n\n        if (typeof matcher === \"function\") {\n            return matcher(object) === true;\n        }\n\n        if (typeof matcher === \"string\") {\n            matcher = matcher.toLowerCase();\n            var notNull = typeof object === \"string\" || !!object;\n            return notNull &&\n                (String(object)).toLowerCase().indexOf(matcher) >= 0;\n        }\n\n        if (typeof matcher === \"number\") {\n            return matcher === object;\n        }\n\n        if (typeof matcher === \"boolean\") {\n            return matcher === object;\n        }\n\n        if (typeof(matcher) === \"undefined\") {\n            return typeof(object) === \"undefined\";\n        }\n\n        if (matcher === null) {\n            return object === null;\n        }\n\n        if (getClass(object) === \"Array\" && getClass(matcher) === \"Array\") {\n            return arrayContains(object, matcher);\n        }\n\n        if (matcher && typeof matcher === \"object\") {\n            if (matcher === object) {\n                return true;\n            }\n            var prop;\n            for (prop in matcher) {\n                var value = object[prop];\n                if (typeof value === \"undefined\" &&\n                        typeof object.getAttribute === \"function\") {\n                    value = object.getAttribute(prop);\n                }\n                if (matcher[prop] === null || typeof matcher[prop] === 'undefined') {\n                    if (value !== matcher[prop]) {\n                        return false;\n                    }\n                } else if (typeof  value === \"undefined\" || !match(value, matcher[prop])) {\n                    return false;\n                }\n            }\n            return true;\n        }\n\n        throw new Error(\"Matcher was not a string, a number, a \" +\n                        \"function, a boolean or an object\");\n    };\n\n    return {\n        isArguments: isArguments,\n        isElement: isElement,\n        isDate: isDate,\n        isNegZero: isNegZero,\n        identical: identical,\n        deepEqual: deepEqualCyclic,\n        match: match,\n        keys: keys\n    };\n});\n","(function (global){\n/*jslint eqeqeq: false, plusplus: false, evil: true, onevar: false, browser: true, forin: false*/\n/*global global*/\n/**\n * @author Christian Johansen (christian@cjohansen.no) and contributors\n * @license BSD\n *\n * Copyright (c) 2010-2014 Christian Johansen\n */\n\"use strict\";\n\n// node expects setTimeout/setInterval to return a fn object w/ .ref()/.unref()\n// browsers, a number.\n// see https://github.com/cjohansen/Sinon.JS/pull/436\nvar timeoutResult = setTimeout(function() {}, 0);\nvar addTimerReturnsObject = typeof timeoutResult === \"object\";\nclearTimeout(timeoutResult);\n\nvar NativeDate = Date;\nvar id = 1;\n\n/**\n * Parse strings like \"01:10:00\" (meaning 1 hour, 10 minutes, 0 seconds) into\n * number of milliseconds. This is used to support human-readable strings passed\n * to clock.tick()\n */\nfunction parseTime(str) {\n    if (!str) {\n        return 0;\n    }\n\n    var strings = str.split(\":\");\n    var l = strings.length, i = l;\n    var ms = 0, parsed;\n\n    if (l > 3 || !/^(\\d\\d:){0,2}\\d\\d?$/.test(str)) {\n        throw new Error(\"tick only understands numbers and 'h:m:s'\");\n    }\n\n    while (i--) {\n        parsed = parseInt(strings[i], 10);\n\n        if (parsed >= 60) {\n            throw new Error(\"Invalid time \" + str);\n        }\n\n        ms += parsed * Math.pow(60, (l - i - 1));\n    }\n\n    return ms * 1000;\n}\n\n/**\n * Used to grok the `now` parameter to createClock.\n */\nfunction getEpoch(epoch) {\n    if (!epoch) { return 0; }\n    if (typeof epoch.getTime === \"function\") { return epoch.getTime(); }\n    if (typeof epoch === \"number\") { return epoch; }\n    throw new TypeError(\"now should be milliseconds since UNIX epoch\");\n}\n\nfunction inRange(from, to, timer) {\n    return timer && timer.callAt >= from && timer.callAt <= to;\n}\n\nfunction mirrorDateProperties(target, source) {\n    if (source.now) {\n        target.now = function now() {\n            return target.clock.now;\n        };\n    } else {\n        delete target.now;\n    }\n\n    if (source.toSource) {\n        target.toSource = function toSource() {\n            return source.toSource();\n        };\n    } else {\n        delete target.toSource;\n    }\n\n    target.toString = function toString() {\n        return source.toString();\n    };\n\n    target.prototype = source.prototype;\n    target.parse = source.parse;\n    target.UTC = source.UTC;\n    target.prototype.toUTCString = source.prototype.toUTCString;\n\n    for (var prop in source) {\n        if (source.hasOwnProperty(prop)) {\n            target[prop] = source[prop];\n        }\n    }\n\n    return target;\n}\n\nfunction createDate() {\n    function ClockDate(year, month, date, hour, minute, second, ms) {\n        // Defensive and verbose to avoid potential harm in passing\n        // explicit undefined when user does not pass argument\n        switch (arguments.length) {\n        case 0:\n            return new NativeDate(ClockDate.clock.now);\n        case 1:\n            return new NativeDate(year);\n        case 2:\n            return new NativeDate(year, month);\n        case 3:\n            return new NativeDate(year, month, date);\n        case 4:\n            return new NativeDate(year, month, date, hour);\n        case 5:\n            return new NativeDate(year, month, date, hour, minute);\n        case 6:\n            return new NativeDate(year, month, date, hour, minute, second);\n        default:\n            return new NativeDate(year, month, date, hour, minute, second, ms);\n        }\n    }\n\n    return mirrorDateProperties(ClockDate, NativeDate);\n}\n\nfunction addTimer(clock, timer) {\n    if (typeof timer.func === \"undefined\") {\n        throw new Error(\"Callback must be provided to timer calls\");\n    }\n\n    if (!clock.timers) {\n        clock.timers = {};\n    }\n\n    timer.id = id++;\n    timer.createdAt = clock.now;\n    timer.callAt = clock.now + (timer.delay || 0);\n\n    clock.timers[timer.id] = timer;\n\n    if (addTimerReturnsObject) {\n        return {\n            id: timer.id,\n            ref: function() {},\n            unref: function() {}\n        };\n    }\n    else {\n        return timer.id;\n    }\n}\n\nfunction firstTimerInRange(clock, from, to) {\n    var timers = clock.timers, timer = null;\n\n    for (var id in timers) {\n        if (!inRange(from, to, timers[id])) {\n            continue;\n        }\n\n        if (!timer || ~compareTimers(timer, timers[id])) {\n            timer = timers[id];\n        }\n    }\n\n    return timer;\n}\n\nfunction compareTimers(a, b) {\n    // Sort first by absolute timing\n    if (a.callAt < b.callAt) {\n        return -1;\n    }\n    if (a.callAt > b.callAt) {\n        return 1;\n    }\n\n    // Sort next by immediate, immediate timers take precedence\n    if (a.immediate && !b.immediate) {\n        return -1;\n    }\n    if (!a.immediate && b.immediate) {\n        return 1;\n    }\n\n    // Sort next by creation time, earlier-created timers take precedence\n    if (a.createdAt < b.createdAt) {\n        return -1;\n    }\n    if (a.createdAt > b.createdAt) {\n        return 1;\n    }\n\n    // Sort next by id, lower-id timers take precedence\n    if (a.id < b.id) {\n        return -1;\n    }\n    if (a.id > b.id) {\n        return 1;\n    }\n\n    // As timer ids are unique, no fallback `0` is necessary\n}\n\nfunction callTimer(clock, timer) {\n    if (typeof timer.interval == \"number\") {\n        clock.timers[timer.id].callAt += timer.interval;\n    } else {\n        delete clock.timers[timer.id];\n    }\n\n    try {\n        if (typeof timer.func == \"function\") {\n            timer.func.apply(null, timer.args);\n        } else {\n            eval(timer.func);\n        }\n    } catch (e) {\n        var exception = e;\n    }\n\n    if (!clock.timers[timer.id]) {\n        if (exception) {\n            throw exception;\n        }\n        return;\n    }\n\n    if (exception) {\n        throw exception;\n    }\n}\n\nfunction uninstall(clock, target) {\n    var method;\n\n    for (var i = 0, l = clock.methods.length; i < l; i++) {\n        method = clock.methods[i];\n\n        if (target[method].hadOwnProperty) {\n            target[method] = clock[\"_\" + method];\n        } else {\n            try {\n                delete target[method];\n            } catch (e) {}\n        }\n    }\n\n    // Prevent multiple executions which will completely remove these props\n    clock.methods = [];\n}\n\nfunction hijackMethod(target, method, clock) {\n    clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(target, method);\n    clock[\"_\" + method] = target[method];\n\n    if (method == \"Date\") {\n        var date = mirrorDateProperties(clock[method], target[method]);\n        target[method] = date;\n    } else {\n        target[method] = function () {\n            return clock[method].apply(clock, arguments);\n        };\n\n        for (var prop in clock[method]) {\n            if (clock[method].hasOwnProperty(prop)) {\n                target[method][prop] = clock[method][prop];\n            }\n        }\n    }\n\n    target[method].clock = clock;\n}\n\nvar timers = {\n    setTimeout: setTimeout,\n    clearTimeout: clearTimeout,\n    setImmediate: (typeof setImmediate !== \"undefined\" ? setImmediate : undefined),\n    clearImmediate: (typeof clearImmediate !== \"undefined\" ? clearImmediate: undefined),\n    setInterval: setInterval,\n    clearInterval: clearInterval,\n    Date: Date\n};\n\nvar keys = Object.keys || function (obj) {\n    var ks = [];\n    for (var key in obj) {\n        ks.push(key);\n    }\n    return ks;\n};\n\nexports.timers = timers;\n\nvar createClock = exports.createClock = function (now) {\n    var clock = {\n        now: getEpoch(now),\n        timeouts: {},\n        Date: createDate()\n    };\n\n    clock.Date.clock = clock;\n\n    clock.setTimeout = function setTimeout(func, timeout) {\n        return addTimer(clock, {\n            func: func,\n            args: Array.prototype.slice.call(arguments, 2),\n            delay: timeout\n        });\n    };\n\n    clock.clearTimeout = function clearTimeout(timerId) {\n        if (!timerId) {\n            // null appears to be allowed in most browsers, and appears to be\n            // relied upon by some libraries, like Bootstrap carousel\n            return;\n        }\n        if (!clock.timers) {\n            clock.timers = [];\n        }\n        // in Node, timerId is an object with .ref()/.unref(), and\n        // its .id field is the actual timer id.\n        if (typeof timerId === \"object\") {\n            timerId = timerId.id\n        }\n        if (timerId in clock.timers) {\n            delete clock.timers[timerId];\n        }\n    };\n\n    clock.setInterval = function setInterval(func, timeout) {\n        return addTimer(clock, {\n            func: func,\n            args: Array.prototype.slice.call(arguments, 2),\n            delay: timeout,\n            interval: timeout\n        });\n    };\n\n    clock.clearInterval = function clearInterval(timerId) {\n        clock.clearTimeout(timerId);\n    };\n\n    clock.setImmediate = function setImmediate(func) {\n        return addTimer(clock, {\n            func: func,\n            args: Array.prototype.slice.call(arguments, 1),\n            immediate: true\n        });\n    };\n\n    clock.clearImmediate = function clearImmediate(timerId) {\n        clock.clearTimeout(timerId);\n    };\n\n    clock.tick = function tick(ms) {\n        ms = typeof ms == \"number\" ? ms : parseTime(ms);\n        var tickFrom = clock.now, tickTo = clock.now + ms, previous = clock.now;\n        var timer = firstTimerInRange(clock, tickFrom, tickTo);\n\n        var firstException;\n        while (timer && tickFrom <= tickTo) {\n            if (clock.timers[timer.id]) {\n                tickFrom = clock.now = timer.callAt;\n                try {\n                    callTimer(clock, timer);\n                } catch (e) {\n                    firstException = firstException || e;\n                }\n            }\n\n            timer = firstTimerInRange(clock, previous, tickTo);\n            previous = tickFrom;\n        }\n\n        clock.now = tickTo;\n\n        if (firstException) {\n            throw firstException;\n        }\n\n        return clock.now;\n    };\n\n    clock.reset = function reset() {\n        clock.timers = {};\n    };\n\n    return clock;\n};\n\nexports.install = function install(target, now, toFake) {\n    if (typeof target === \"number\") {\n        toFake = now;\n        now = target;\n        target = null;\n    }\n\n    if (!target) {\n        target = global;\n    }\n\n    var clock = createClock(now);\n\n    clock.uninstall = function () {\n        uninstall(clock, target);\n    };\n\n    clock.methods = toFake || [];\n\n    if (clock.methods.length === 0) {\n        clock.methods = keys(timers);\n    }\n\n    for (var i = 0, l = clock.methods.length; i < l; i++) {\n        hijackMethod(target, clock.methods[i], clock);\n    }\n\n    return clock;\n};\n\n}).call(this,typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})","//     Underscore.js 1.8.3\n//     http://underscorejs.org\n//     (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n//     Underscore may be freely distributed under the MIT license.\n\n(function() {\n\n  // Baseline setup\n  // --------------\n\n  // Establish the root object, `window` in the browser, or `exports` on the server.\n  var root = this;\n\n  // Save the previous value of the `_` variable.\n  var previousUnderscore = root._;\n\n  // Save bytes in the minified (but not gzipped) version:\n  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;\n\n  // Create quick reference variables for speed access to core prototypes.\n  var\n    push             = ArrayProto.push,\n    slice            = ArrayProto.slice,\n    toString         = ObjProto.toString,\n    hasOwnProperty   = ObjProto.hasOwnProperty;\n\n  // All **ECMAScript 5** native function implementations that we hope to use\n  // are declared here.\n  var\n    nativeIsArray      = Array.isArray,\n    nativeKeys         = Object.keys,\n    nativeBind         = FuncProto.bind,\n    nativeCreate       = Object.create;\n\n  // Naked function reference for surrogate-prototype-swapping.\n  var Ctor = function(){};\n\n  // Create a safe reference to the Underscore object for use below.\n  var _ = function(obj) {\n    if (obj instanceof _) return obj;\n    if (!(this instanceof _)) return new _(obj);\n    this._wrapped = obj;\n  };\n\n  // Export the Underscore object for **Node.js**, with\n  // backwards-compatibility for the old `require()` API. If we're in\n  // the browser, add `_` as a global object.\n  if (typeof exports !== 'undefined') {\n    if (typeof module !== 'undefined' && module.exports) {\n      exports = module.exports = _;\n    }\n    exports._ = _;\n  } else {\n    root._ = _;\n  }\n\n  // Current version.\n  _.VERSION = '1.8.3';\n\n  // Internal function that returns an efficient (for current engines) version\n  // of the passed-in callback, to be repeatedly applied in other Underscore\n  // functions.\n  var optimizeCb = function(func, context, argCount) {\n    if (context === void 0) return func;\n    switch (argCount == null ? 3 : argCount) {\n      case 1: return function(value) {\n        return func.call(context, value);\n      };\n      case 2: return function(value, other) {\n        return func.call(context, value, other);\n      };\n      case 3: return function(value, index, collection) {\n        return func.call(context, value, index, collection);\n      };\n      case 4: return function(accumulator, value, index, collection) {\n        return func.call(context, accumulator, value, index, collection);\n      };\n    }\n    return function() {\n      return func.apply(context, arguments);\n    };\n  };\n\n  // A mostly-internal function to generate callbacks that can be applied\n  // to each element in a collection, returning the desired result — either\n  // identity, an arbitrary callback, a property matcher, or a property accessor.\n  var cb = function(value, context, argCount) {\n    if (value == null) return _.identity;\n    if (_.isFunction(value)) return optimizeCb(value, context, argCount);\n    if (_.isObject(value)) return _.matcher(value);\n    return _.property(value);\n  };\n  _.iteratee = function(value, context) {\n    return cb(value, context, Infinity);\n  };\n\n  // An internal function for creating assigner functions.\n  var createAssigner = function(keysFunc, undefinedOnly) {\n    return function(obj) {\n      var length = arguments.length;\n      if (length < 2 || obj == null) return obj;\n      for (var index = 1; index < length; index++) {\n        var source = arguments[index],\n            keys = keysFunc(source),\n            l = keys.length;\n        for (var i = 0; i < l; i++) {\n          var key = keys[i];\n          if (!undefinedOnly || obj[key] === void 0) obj[key] = source[key];\n        }\n      }\n      return obj;\n    };\n  };\n\n  // An internal function for creating a new object that inherits from another.\n  var baseCreate = function(prototype) {\n    if (!_.isObject(prototype)) return {};\n    if (nativeCreate) return nativeCreate(prototype);\n    Ctor.prototype = prototype;\n    var result = new Ctor;\n    Ctor.prototype = null;\n    return result;\n  };\n\n  var property = function(key) {\n    return function(obj) {\n      return obj == null ? void 0 : obj[key];\n    };\n  };\n\n  // Helper for collection methods to determine whether a collection\n  // should be iterated as an array or as an object\n  // Related: http://people.mozilla.org/~jorendorff/es6-draft.html#sec-tolength\n  // Avoids a very nasty iOS 8 JIT bug on ARM-64. #2094\n  var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;\n  var getLength = property('length');\n  var isArrayLike = function(collection) {\n    var length = getLength(collection);\n    return typeof length == 'number' && length >= 0 && length <= MAX_ARRAY_INDEX;\n  };\n\n  // Collection Functions\n  // --------------------\n\n  // The cornerstone, an `each` implementation, aka `forEach`.\n  // Handles raw objects in addition to array-likes. Treats all\n  // sparse array-likes as if they were dense.\n  _.each = _.forEach = function(obj, iteratee, context) {\n    iteratee = optimizeCb(iteratee, context);\n    var i, length;\n    if (isArrayLike(obj)) {\n      for (i = 0, length = obj.length; i < length; i++) {\n        iteratee(obj[i], i, obj);\n      }\n    } else {\n      var keys = _.keys(obj);\n      for (i = 0, length = keys.length; i < length; i++) {\n        iteratee(obj[keys[i]], keys[i], obj);\n      }\n    }\n    return obj;\n  };\n\n  // Return the results of applying the iteratee to each element.\n  _.map = _.collect = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length,\n        results = Array(length);\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      results[index] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  };\n\n  // Create a reducing function iterating left or right.\n  function createReduce(dir) {\n    // Optimized iterator function as using arguments.length\n    // in the main function will deoptimize the, see #1991.\n    function iterator(obj, iteratee, memo, keys, index, length) {\n      for (; index >= 0 && index < length; index += dir) {\n        var currentKey = keys ? keys[index] : index;\n        memo = iteratee(memo, obj[currentKey], currentKey, obj);\n      }\n      return memo;\n    }\n\n    return function(obj, iteratee, memo, context) {\n      iteratee = optimizeCb(iteratee, context, 4);\n      var keys = !isArrayLike(obj) && _.keys(obj),\n          length = (keys || obj).length,\n          index = dir > 0 ? 0 : length - 1;\n      // Determine the initial value if none is provided.\n      if (arguments.length < 3) {\n        memo = obj[keys ? keys[index] : index];\n        index += dir;\n      }\n      return iterator(obj, iteratee, memo, keys, index, length);\n    };\n  }\n\n  // **Reduce** builds up a single result from a list of values, aka `inject`,\n  // or `foldl`.\n  _.reduce = _.foldl = _.inject = createReduce(1);\n\n  // The right-associative version of reduce, also known as `foldr`.\n  _.reduceRight = _.foldr = createReduce(-1);\n\n  // Return the first value which passes a truth test. Aliased as `detect`.\n  _.find = _.detect = function(obj, predicate, context) {\n    var key;\n    if (isArrayLike(obj)) {\n      key = _.findIndex(obj, predicate, context);\n    } else {\n      key = _.findKey(obj, predicate, context);\n    }\n    if (key !== void 0 && key !== -1) return obj[key];\n  };\n\n  // Return all the elements that pass a truth test.\n  // Aliased as `select`.\n  _.filter = _.select = function(obj, predicate, context) {\n    var results = [];\n    predicate = cb(predicate, context);\n    _.each(obj, function(value, index, list) {\n      if (predicate(value, index, list)) results.push(value);\n    });\n    return results;\n  };\n\n  // Return all the elements for which a truth test fails.\n  _.reject = function(obj, predicate, context) {\n    return _.filter(obj, _.negate(cb(predicate)), context);\n  };\n\n  // Determine whether all of the elements match a truth test.\n  // Aliased as `all`.\n  _.every = _.all = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (!predicate(obj[currentKey], currentKey, obj)) return false;\n    }\n    return true;\n  };\n\n  // Determine if at least one element in the object matches a truth test.\n  // Aliased as `any`.\n  _.some = _.any = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = !isArrayLike(obj) && _.keys(obj),\n        length = (keys || obj).length;\n    for (var index = 0; index < length; index++) {\n      var currentKey = keys ? keys[index] : index;\n      if (predicate(obj[currentKey], currentKey, obj)) return true;\n    }\n    return false;\n  };\n\n  // Determine if the array or object contains a given item (using `===`).\n  // Aliased as `includes` and `include`.\n  _.contains = _.includes = _.include = function(obj, item, fromIndex, guard) {\n    if (!isArrayLike(obj)) obj = _.values(obj);\n    if (typeof fromIndex != 'number' || guard) fromIndex = 0;\n    return _.indexOf(obj, item, fromIndex) >= 0;\n  };\n\n  // Invoke a method (with arguments) on every item in a collection.\n  _.invoke = function(obj, method) {\n    var args = slice.call(arguments, 2);\n    var isFunc = _.isFunction(method);\n    return _.map(obj, function(value) {\n      var func = isFunc ? method : value[method];\n      return func == null ? func : func.apply(value, args);\n    });\n  };\n\n  // Convenience version of a common use case of `map`: fetching a property.\n  _.pluck = function(obj, key) {\n    return _.map(obj, _.property(key));\n  };\n\n  // Convenience version of a common use case of `filter`: selecting only objects\n  // containing specific `key:value` pairs.\n  _.where = function(obj, attrs) {\n    return _.filter(obj, _.matcher(attrs));\n  };\n\n  // Convenience version of a common use case of `find`: getting the first object\n  // containing specific `key:value` pairs.\n  _.findWhere = function(obj, attrs) {\n    return _.find(obj, _.matcher(attrs));\n  };\n\n  // Return the maximum element (or element-based computation).\n  _.max = function(obj, iteratee, context) {\n    var result = -Infinity, lastComputed = -Infinity,\n        value, computed;\n    if (iteratee == null && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value > result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index, list) {\n        computed = iteratee(value, index, list);\n        if (computed > lastComputed || computed === -Infinity && result === -Infinity) {\n          result = value;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Return the minimum element (or element-based computation).\n  _.min = function(obj, iteratee, context) {\n    var result = Infinity, lastComputed = Infinity,\n        value, computed;\n    if (iteratee == null && obj != null) {\n      obj = isArrayLike(obj) ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value < result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index, list) {\n        computed = iteratee(value, index, list);\n        if (computed < lastComputed || computed === Infinity && result === Infinity) {\n          result = value;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Shuffle a collection, using the modern version of the\n  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n  _.shuffle = function(obj) {\n    var set = isArrayLike(obj) ? obj : _.values(obj);\n    var length = set.length;\n    var shuffled = Array(length);\n    for (var index = 0, rand; index < length; index++) {\n      rand = _.random(0, index);\n      if (rand !== index) shuffled[index] = shuffled[rand];\n      shuffled[rand] = set[index];\n    }\n    return shuffled;\n  };\n\n  // Sample **n** random values from a collection.\n  // If **n** is not specified, returns a single random element.\n  // The internal `guard` argument allows it to work with `map`.\n  _.sample = function(obj, n, guard) {\n    if (n == null || guard) {\n      if (!isArrayLike(obj)) obj = _.values(obj);\n      return obj[_.random(obj.length - 1)];\n    }\n    return _.shuffle(obj).slice(0, Math.max(0, n));\n  };\n\n  // Sort the object's values by a criterion produced by an iteratee.\n  _.sortBy = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    return _.pluck(_.map(obj, function(value, index, list) {\n      return {\n        value: value,\n        index: index,\n        criteria: iteratee(value, index, list)\n      };\n    }).sort(function(left, right) {\n      var a = left.criteria;\n      var b = right.criteria;\n      if (a !== b) {\n        if (a > b || a === void 0) return 1;\n        if (a < b || b === void 0) return -1;\n      }\n      return left.index - right.index;\n    }), 'value');\n  };\n\n  // An internal function used for aggregate \"group by\" operations.\n  var group = function(behavior) {\n    return function(obj, iteratee, context) {\n      var result = {};\n      iteratee = cb(iteratee, context);\n      _.each(obj, function(value, index) {\n        var key = iteratee(value, index, obj);\n        behavior(result, value, key);\n      });\n      return result;\n    };\n  };\n\n  // Groups the object's values by a criterion. Pass either a string attribute\n  // to group by, or a function that returns the criterion.\n  _.groupBy = group(function(result, value, key) {\n    if (_.has(result, key)) result[key].push(value); else result[key] = [value];\n  });\n\n  // Indexes the object's values by a criterion, similar to `groupBy`, but for\n  // when you know that your index values will be unique.\n  _.indexBy = group(function(result, value, key) {\n    result[key] = value;\n  });\n\n  // Counts instances of an object that group by a certain criterion. Pass\n  // either a string attribute to count by, or a function that returns the\n  // criterion.\n  _.countBy = group(function(result, value, key) {\n    if (_.has(result, key)) result[key]++; else result[key] = 1;\n  });\n\n  // Safely create a real, live array from anything iterable.\n  _.toArray = function(obj) {\n    if (!obj) return [];\n    if (_.isArray(obj)) return slice.call(obj);\n    if (isArrayLike(obj)) return _.map(obj, _.identity);\n    return _.values(obj);\n  };\n\n  // Return the number of elements in an object.\n  _.size = function(obj) {\n    if (obj == null) return 0;\n    return isArrayLike(obj) ? obj.length : _.keys(obj).length;\n  };\n\n  // Split a collection into two arrays: one whose elements all satisfy the given\n  // predicate, and one whose elements all do not satisfy the predicate.\n  _.partition = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var pass = [], fail = [];\n    _.each(obj, function(value, key, obj) {\n      (predicate(value, key, obj) ? pass : fail).push(value);\n    });\n    return [pass, fail];\n  };\n\n  // Array Functions\n  // ---------------\n\n  // Get the first element of an array. Passing **n** will return the first N\n  // values in the array. Aliased as `head` and `take`. The **guard** check\n  // allows it to work with `_.map`.\n  _.first = _.head = _.take = function(array, n, guard) {\n    if (array == null) return void 0;\n    if (n == null || guard) return array[0];\n    return _.initial(array, array.length - n);\n  };\n\n  // Returns everything but the last entry of the array. Especially useful on\n  // the arguments object. Passing **n** will return all the values in\n  // the array, excluding the last N.\n  _.initial = function(array, n, guard) {\n    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n  };\n\n  // Get the last element of an array. Passing **n** will return the last N\n  // values in the array.\n  _.last = function(array, n, guard) {\n    if (array == null) return void 0;\n    if (n == null || guard) return array[array.length - 1];\n    return _.rest(array, Math.max(0, array.length - n));\n  };\n\n  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.\n  // Especially useful on the arguments object. Passing an **n** will return\n  // the rest N values in the array.\n  _.rest = _.tail = _.drop = function(array, n, guard) {\n    return slice.call(array, n == null || guard ? 1 : n);\n  };\n\n  // Trim out all falsy values from an array.\n  _.compact = function(array) {\n    return _.filter(array, _.identity);\n  };\n\n  // Internal implementation of a recursive `flatten` function.\n  var flatten = function(input, shallow, strict, startIndex) {\n    var output = [], idx = 0;\n    for (var i = startIndex || 0, length = getLength(input); i < length; i++) {\n      var value = input[i];\n      if (isArrayLike(value) && (_.isArray(value) || _.isArguments(value))) {\n        //flatten current level of array or arguments object\n        if (!shallow) value = flatten(value, shallow, strict);\n        var j = 0, len = value.length;\n        output.length += len;\n        while (j < len) {\n          output[idx++] = value[j++];\n        }\n      } else if (!strict) {\n        output[idx++] = value;\n      }\n    }\n    return output;\n  };\n\n  // Flatten out an array, either recursively (by default), or just one level.\n  _.flatten = function(array, shallow) {\n    return flatten(array, shallow, false);\n  };\n\n  // Return a version of the array that does not contain the specified value(s).\n  _.without = function(array) {\n    return _.difference(array, slice.call(arguments, 1));\n  };\n\n  // Produce a duplicate-free version of the array. If the array has already\n  // been sorted, you have the option of using a faster algorithm.\n  // Aliased as `unique`.\n  _.uniq = _.unique = function(array, isSorted, iteratee, context) {\n    if (!_.isBoolean(isSorted)) {\n      context = iteratee;\n      iteratee = isSorted;\n      isSorted = false;\n    }\n    if (iteratee != null) iteratee = cb(iteratee, context);\n    var result = [];\n    var seen = [];\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var value = array[i],\n          computed = iteratee ? iteratee(value, i, array) : value;\n      if (isSorted) {\n        if (!i || seen !== computed) result.push(value);\n        seen = computed;\n      } else if (iteratee) {\n        if (!_.contains(seen, computed)) {\n          seen.push(computed);\n          result.push(value);\n        }\n      } else if (!_.contains(result, value)) {\n        result.push(value);\n      }\n    }\n    return result;\n  };\n\n  // Produce an array that contains the union: each distinct element from all of\n  // the passed-in arrays.\n  _.union = function() {\n    return _.uniq(flatten(arguments, true, true));\n  };\n\n  // Produce an array that contains every item shared between all the\n  // passed-in arrays.\n  _.intersection = function(array) {\n    var result = [];\n    var argsLength = arguments.length;\n    for (var i = 0, length = getLength(array); i < length; i++) {\n      var item = array[i];\n      if (_.contains(result, item)) continue;\n      for (var j = 1; j < argsLength; j++) {\n        if (!_.contains(arguments[j], item)) break;\n      }\n      if (j === argsLength) result.push(item);\n    }\n    return result;\n  };\n\n  // Take the difference between one array and a number of other arrays.\n  // Only the elements present in just the first array will remain.\n  _.difference = function(array) {\n    var rest = flatten(arguments, true, true, 1);\n    return _.filter(array, function(value){\n      return !_.contains(rest, value);\n    });\n  };\n\n  // Zip together multiple lists into a single array -- elements that share\n  // an index go together.\n  _.zip = function() {\n    return _.unzip(arguments);\n  };\n\n  // Complement of _.zip. Unzip accepts an array of arrays and groups\n  // each array's elements on shared indices\n  _.unzip = function(array) {\n    var length = array && _.max(array, getLength).length || 0;\n    var result = Array(length);\n\n    for (var index = 0; index < length; index++) {\n      result[index] = _.pluck(array, index);\n    }\n    return result;\n  };\n\n  // Converts lists into objects. Pass either a single array of `[key, value]`\n  // pairs, or two parallel arrays of the same length -- one of keys, and one of\n  // the corresponding values.\n  _.object = function(list, values) {\n    var result = {};\n    for (var i = 0, length = getLength(list); i < length; i++) {\n      if (values) {\n        result[list[i]] = values[i];\n      } else {\n        result[list[i][0]] = list[i][1];\n      }\n    }\n    return result;\n  };\n\n  // Generator function to create the findIndex and findLastIndex functions\n  function createPredicateIndexFinder(dir) {\n    return function(array, predicate, context) {\n      predicate = cb(predicate, context);\n      var length = getLength(array);\n      var index = dir > 0 ? 0 : length - 1;\n      for (; index >= 0 && index < length; index += dir) {\n        if (predicate(array[index], index, array)) return index;\n      }\n      return -1;\n    };\n  }\n\n  // Returns the first index on an array-like that passes a predicate test\n  _.findIndex = createPredicateIndexFinder(1);\n  _.findLastIndex = createPredicateIndexFinder(-1);\n\n  // Use a comparator function to figure out the smallest index at which\n  // an object should be inserted so as to maintain order. Uses binary search.\n  _.sortedIndex = function(array, obj, iteratee, context) {\n    iteratee = cb(iteratee, context, 1);\n    var value = iteratee(obj);\n    var low = 0, high = getLength(array);\n    while (low < high) {\n      var mid = Math.floor((low + high) / 2);\n      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n    }\n    return low;\n  };\n\n  // Generator function to create the indexOf and lastIndexOf functions\n  function createIndexFinder(dir, predicateFind, sortedIndex) {\n    return function(array, item, idx) {\n      var i = 0, length = getLength(array);\n      if (typeof idx == 'number') {\n        if (dir > 0) {\n            i = idx >= 0 ? idx : Math.max(idx + length, i);\n        } else {\n            length = idx >= 0 ? Math.min(idx + 1, length) : idx + length + 1;\n        }\n      } else if (sortedIndex && idx && length) {\n        idx = sortedIndex(array, item);\n        return array[idx] === item ? idx : -1;\n      }\n      if (item !== item) {\n        idx = predicateFind(slice.call(array, i, length), _.isNaN);\n        return idx >= 0 ? idx + i : -1;\n      }\n      for (idx = dir > 0 ? i : length - 1; idx >= 0 && idx < length; idx += dir) {\n        if (array[idx] === item) return idx;\n      }\n      return -1;\n    };\n  }\n\n  // Return the position of the first occurrence of an item in an array,\n  // or -1 if the item is not included in the array.\n  // If the array is large and already in sort order, pass `true`\n  // for **isSorted** to use binary search.\n  _.indexOf = createIndexFinder(1, _.findIndex, _.sortedIndex);\n  _.lastIndexOf = createIndexFinder(-1, _.findLastIndex);\n\n  // Generate an integer Array containing an arithmetic progression. A port of\n  // the native Python `range()` function. See\n  // [the Python documentation](http://docs.python.org/library/functions.html#range).\n  _.range = function(start, stop, step) {\n    if (stop == null) {\n      stop = start || 0;\n      start = 0;\n    }\n    step = step || 1;\n\n    var length = Math.max(Math.ceil((stop - start) / step), 0);\n    var range = Array(length);\n\n    for (var idx = 0; idx < length; idx++, start += step) {\n      range[idx] = start;\n    }\n\n    return range;\n  };\n\n  // Function (ahem) Functions\n  // ------------------\n\n  // Determines whether to execute a function as a constructor\n  // or a normal function with the provided arguments\n  var executeBound = function(sourceFunc, boundFunc, context, callingContext, args) {\n    if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);\n    var self = baseCreate(sourceFunc.prototype);\n    var result = sourceFunc.apply(self, args);\n    if (_.isObject(result)) return result;\n    return self;\n  };\n\n  // Create a function bound to a given object (assigning `this`, and arguments,\n  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if\n  // available.\n  _.bind = function(func, context) {\n    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));\n    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');\n    var args = slice.call(arguments, 2);\n    var bound = function() {\n      return executeBound(func, bound, context, this, args.concat(slice.call(arguments)));\n    };\n    return bound;\n  };\n\n  // Partially apply a function by creating a version that has had some of its\n  // arguments pre-filled, without changing its dynamic `this` context. _ acts\n  // as a placeholder, allowing any combination of arguments to be pre-filled.\n  _.partial = function(func) {\n    var boundArgs = slice.call(arguments, 1);\n    var bound = function() {\n      var position = 0, length = boundArgs.length;\n      var args = Array(length);\n      for (var i = 0; i < length; i++) {\n        args[i] = boundArgs[i] === _ ? arguments[position++] : boundArgs[i];\n      }\n      while (position < arguments.length) args.push(arguments[position++]);\n      return executeBound(func, bound, this, this, args);\n    };\n    return bound;\n  };\n\n  // Bind a number of an object's methods to that object. Remaining arguments\n  // are the method names to be bound. Useful for ensuring that all callbacks\n  // defined on an object belong to it.\n  _.bindAll = function(obj) {\n    var i, length = arguments.length, key;\n    if (length <= 1) throw new Error('bindAll must be passed function names');\n    for (i = 1; i < length; i++) {\n      key = arguments[i];\n      obj[key] = _.bind(obj[key], obj);\n    }\n    return obj;\n  };\n\n  // Memoize an expensive function by storing its results.\n  _.memoize = function(func, hasher) {\n    var memoize = function(key) {\n      var cache = memoize.cache;\n      var address = '' + (hasher ? hasher.apply(this, arguments) : key);\n      if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);\n      return cache[address];\n    };\n    memoize.cache = {};\n    return memoize;\n  };\n\n  // Delays a function for the given number of milliseconds, and then calls\n  // it with the arguments supplied.\n  _.delay = function(func, wait) {\n    var args = slice.call(arguments, 2);\n    return setTimeout(function(){\n      return func.apply(null, args);\n    }, wait);\n  };\n\n  // Defers a function, scheduling it to run after the current call stack has\n  // cleared.\n  _.defer = _.partial(_.delay, _, 1);\n\n  // Returns a function, that, when invoked, will only be triggered at most once\n  // during a given window of time. Normally, the throttled function will run\n  // as much as it can, without ever going more than once per `wait` duration;\n  // but if you'd like to disable the execution on the leading edge, pass\n  // `{leading: false}`. To disable execution on the trailing edge, ditto.\n  _.throttle = function(func, wait, options) {\n    var context, args, result;\n    var timeout = null;\n    var previous = 0;\n    if (!options) options = {};\n    var later = function() {\n      previous = options.leading === false ? 0 : _.now();\n      timeout = null;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    };\n    return function() {\n      var now = _.now();\n      if (!previous && options.leading === false) previous = now;\n      var remaining = wait - (now - previous);\n      context = this;\n      args = arguments;\n      if (remaining <= 0 || remaining > wait) {\n        if (timeout) {\n          clearTimeout(timeout);\n          timeout = null;\n        }\n        previous = now;\n        result = func.apply(context, args);\n        if (!timeout) context = args = null;\n      } else if (!timeout && options.trailing !== false) {\n        timeout = setTimeout(later, remaining);\n      }\n      return result;\n    };\n  };\n\n  // Returns a function, that, as long as it continues to be invoked, will not\n  // be triggered. The function will be called after it stops being called for\n  // N milliseconds. If `immediate` is passed, trigger the function on the\n  // leading edge, instead of the trailing.\n  _.debounce = function(func, wait, immediate) {\n    var timeout, args, context, timestamp, result;\n\n    var later = function() {\n      var last = _.now() - timestamp;\n\n      if (last < wait && last >= 0) {\n        timeout = setTimeout(later, wait - last);\n      } else {\n        timeout = null;\n        if (!immediate) {\n          result = func.apply(context, args);\n          if (!timeout) context = args = null;\n        }\n      }\n    };\n\n    return function() {\n      context = this;\n      args = arguments;\n      timestamp = _.now();\n      var callNow = immediate && !timeout;\n      if (!timeout) timeout = setTimeout(later, wait);\n      if (callNow) {\n        result = func.apply(context, args);\n        context = args = null;\n      }\n\n      return result;\n    };\n  };\n\n  // Returns the first function passed as an argument to the second,\n  // allowing you to adjust arguments, run code before and after, and\n  // conditionally execute the original function.\n  _.wrap = function(func, wrapper) {\n    return _.partial(wrapper, func);\n  };\n\n  // Returns a negated version of the passed-in predicate.\n  _.negate = function(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    };\n  };\n\n  // Returns a function that is the composition of a list of functions, each\n  // consuming the return value of the function that follows.\n  _.compose = function() {\n    var args = arguments;\n    var start = args.length - 1;\n    return function() {\n      var i = start;\n      var result = args[start].apply(this, arguments);\n      while (i--) result = args[i].call(this, result);\n      return result;\n    };\n  };\n\n  // Returns a function that will only be executed on and after the Nth call.\n  _.after = function(times, func) {\n    return function() {\n      if (--times < 1) {\n        return func.apply(this, arguments);\n      }\n    };\n  };\n\n  // Returns a function that will only be executed up to (but not including) the Nth call.\n  _.before = function(times, func) {\n    var memo;\n    return function() {\n      if (--times > 0) {\n        memo = func.apply(this, arguments);\n      }\n      if (times <= 1) func = null;\n      return memo;\n    };\n  };\n\n  // Returns a function that will be executed at most one time, no matter how\n  // often you call it. Useful for lazy initialization.\n  _.once = _.partial(_.before, 2);\n\n  // Object Functions\n  // ----------------\n\n  // Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.\n  var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');\n  var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',\n                      'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];\n\n  function collectNonEnumProps(obj, keys) {\n    var nonEnumIdx = nonEnumerableProps.length;\n    var constructor = obj.constructor;\n    var proto = (_.isFunction(constructor) && constructor.prototype) || ObjProto;\n\n    // Constructor is a special case.\n    var prop = 'constructor';\n    if (_.has(obj, prop) && !_.contains(keys, prop)) keys.push(prop);\n\n    while (nonEnumIdx--) {\n      prop = nonEnumerableProps[nonEnumIdx];\n      if (prop in obj && obj[prop] !== proto[prop] && !_.contains(keys, prop)) {\n        keys.push(prop);\n      }\n    }\n  }\n\n  // Retrieve the names of an object's own properties.\n  // Delegates to **ECMAScript 5**'s native `Object.keys`\n  _.keys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    if (nativeKeys) return nativeKeys(obj);\n    var keys = [];\n    for (var key in obj) if (_.has(obj, key)) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve all the property names of an object.\n  _.allKeys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    var keys = [];\n    for (var key in obj) keys.push(key);\n    // Ahem, IE < 9.\n    if (hasEnumBug) collectNonEnumProps(obj, keys);\n    return keys;\n  };\n\n  // Retrieve the values of an object's properties.\n  _.values = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var values = Array(length);\n    for (var i = 0; i < length; i++) {\n      values[i] = obj[keys[i]];\n    }\n    return values;\n  };\n\n  // Returns the results of applying the iteratee to each element of the object\n  // In contrast to _.map it returns an object\n  _.mapObject = function(obj, iteratee, context) {\n    iteratee = cb(iteratee, context);\n    var keys =  _.keys(obj),\n          length = keys.length,\n          results = {},\n          currentKey;\n      for (var index = 0; index < length; index++) {\n        currentKey = keys[index];\n        results[currentKey] = iteratee(obj[currentKey], currentKey, obj);\n      }\n      return results;\n  };\n\n  // Convert an object into a list of `[key, value]` pairs.\n  _.pairs = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var pairs = Array(length);\n    for (var i = 0; i < length; i++) {\n      pairs[i] = [keys[i], obj[keys[i]]];\n    }\n    return pairs;\n  };\n\n  // Invert the keys and values of an object. The values must be serializable.\n  _.invert = function(obj) {\n    var result = {};\n    var keys = _.keys(obj);\n    for (var i = 0, length = keys.length; i < length; i++) {\n      result[obj[keys[i]]] = keys[i];\n    }\n    return result;\n  };\n\n  // Return a sorted list of the function names available on the object.\n  // Aliased as `methods`\n  _.functions = _.methods = function(obj) {\n    var names = [];\n    for (var key in obj) {\n      if (_.isFunction(obj[key])) names.push(key);\n    }\n    return names.sort();\n  };\n\n  // Extend a given object with all the properties in passed-in object(s).\n  _.extend = createAssigner(_.allKeys);\n\n  // Assigns a given object with all the own properties in the passed-in object(s)\n  // (https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object/assign)\n  _.extendOwn = _.assign = createAssigner(_.keys);\n\n  // Returns the first key on an object that passes a predicate test\n  _.findKey = function(obj, predicate, context) {\n    predicate = cb(predicate, context);\n    var keys = _.keys(obj), key;\n    for (var i = 0, length = keys.length; i < length; i++) {\n      key = keys[i];\n      if (predicate(obj[key], key, obj)) return key;\n    }\n  };\n\n  // Return a copy of the object only containing the whitelisted properties.\n  _.pick = function(object, oiteratee, context) {\n    var result = {}, obj = object, iteratee, keys;\n    if (obj == null) return result;\n    if (_.isFunction(oiteratee)) {\n      keys = _.allKeys(obj);\n      iteratee = optimizeCb(oiteratee, context);\n    } else {\n      keys = flatten(arguments, false, false, 1);\n      iteratee = function(value, key, obj) { return key in obj; };\n      obj = Object(obj);\n    }\n    for (var i = 0, length = keys.length; i < length; i++) {\n      var key = keys[i];\n      var value = obj[key];\n      if (iteratee(value, key, obj)) result[key] = value;\n    }\n    return result;\n  };\n\n   // Return a copy of the object without the blacklisted properties.\n  _.omit = function(obj, iteratee, context) {\n    if (_.isFunction(iteratee)) {\n      iteratee = _.negate(iteratee);\n    } else {\n      var keys = _.map(flatten(arguments, false, false, 1), String);\n      iteratee = function(value, key) {\n        return !_.contains(keys, key);\n      };\n    }\n    return _.pick(obj, iteratee, context);\n  };\n\n  // Fill in a given object with default properties.\n  _.defaults = createAssigner(_.allKeys, true);\n\n  // Creates an object that inherits from the given prototype object.\n  // If additional properties are provided then they will be added to the\n  // created object.\n  _.create = function(prototype, props) {\n    var result = baseCreate(prototype);\n    if (props) _.extendOwn(result, props);\n    return result;\n  };\n\n  // Create a (shallow-cloned) duplicate of an object.\n  _.clone = function(obj) {\n    if (!_.isObject(obj)) return obj;\n    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\n  };\n\n  // Invokes interceptor with the obj, and then returns obj.\n  // The primary purpose of this method is to \"tap into\" a method chain, in\n  // order to perform operations on intermediate results within the chain.\n  _.tap = function(obj, interceptor) {\n    interceptor(obj);\n    return obj;\n  };\n\n  // Returns whether an object has a given set of `key:value` pairs.\n  _.isMatch = function(object, attrs) {\n    var keys = _.keys(attrs), length = keys.length;\n    if (object == null) return !length;\n    var obj = Object(object);\n    for (var i = 0; i < length; i++) {\n      var key = keys[i];\n      if (attrs[key] !== obj[key] || !(key in obj)) return false;\n    }\n    return true;\n  };\n\n\n  // Internal recursive comparison function for `isEqual`.\n  var eq = function(a, b, aStack, bStack) {\n    // Identical objects are equal. `0 === -0`, but they aren't identical.\n    // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\n    if (a === b) return a !== 0 || 1 / a === 1 / b;\n    // A strict comparison is necessary because `null == undefined`.\n    if (a == null || b == null) return a === b;\n    // Unwrap any wrapped objects.\n    if (a instanceof _) a = a._wrapped;\n    if (b instanceof _) b = b._wrapped;\n    // Compare `[[Class]]` names.\n    var className = toString.call(a);\n    if (className !== toString.call(b)) return false;\n    switch (className) {\n      // Strings, numbers, regular expressions, dates, and booleans are compared by value.\n      case '[object RegExp]':\n      // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n      case '[object String]':\n        // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n        // equivalent to `new String(\"5\")`.\n        return '' + a === '' + b;\n      case '[object Number]':\n        // `NaN`s are equivalent, but non-reflexive.\n        // Object(NaN) is equivalent to NaN\n        if (+a !== +a) return +b !== +b;\n        // An `egal` comparison is performed for other numeric values.\n        return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n      case '[object Date]':\n      case '[object Boolean]':\n        // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n        // millisecond representations. Note that invalid dates with millisecond representations\n        // of `NaN` are not equivalent.\n        return +a === +b;\n    }\n\n    var areArrays = className === '[object Array]';\n    if (!areArrays) {\n      if (typeof a != 'object' || typeof b != 'object') return false;\n\n      // Objects with different constructors are not equivalent, but `Object`s or `Array`s\n      // from different frames are.\n      var aCtor = a.constructor, bCtor = b.constructor;\n      if (aCtor !== bCtor && !(_.isFunction(aCtor) && aCtor instanceof aCtor &&\n                               _.isFunction(bCtor) && bCtor instanceof bCtor)\n                          && ('constructor' in a && 'constructor' in b)) {\n        return false;\n      }\n    }\n    // Assume equality for cyclic structures. The algorithm for detecting cyclic\n    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n\n    // Initializing stack of traversed objects.\n    // It's done here since we only need them for objects and arrays comparison.\n    aStack = aStack || [];\n    bStack = bStack || [];\n    var length = aStack.length;\n    while (length--) {\n      // Linear search. Performance is inversely proportional to the number of\n      // unique nested structures.\n      if (aStack[length] === a) return bStack[length] === b;\n    }\n\n    // Add the first object to the stack of traversed objects.\n    aStack.push(a);\n    bStack.push(b);\n\n    // Recursively compare objects and arrays.\n    if (areArrays) {\n      // Compare array lengths to determine if a deep comparison is necessary.\n      length = a.length;\n      if (length !== b.length) return false;\n      // Deep compare the contents, ignoring non-numeric properties.\n      while (length--) {\n        if (!eq(a[length], b[length], aStack, bStack)) return false;\n      }\n    } else {\n      // Deep compare objects.\n      var keys = _.keys(a), key;\n      length = keys.length;\n      // Ensure that both objects contain the same number of properties before comparing deep equality.\n      if (_.keys(b).length !== length) return false;\n      while (length--) {\n        // Deep compare each member\n        key = keys[length];\n        if (!(_.has(b, key) && eq(a[key], b[key], aStack, bStack))) return false;\n      }\n    }\n    // Remove the first object from the stack of traversed objects.\n    aStack.pop();\n    bStack.pop();\n    return true;\n  };\n\n  // Perform a deep comparison to check if two objects are equal.\n  _.isEqual = function(a, b) {\n    return eq(a, b);\n  };\n\n  // Is a given array, string, or object empty?\n  // An \"empty\" object has no enumerable own-properties.\n  _.isEmpty = function(obj) {\n    if (obj == null) return true;\n    if (isArrayLike(obj) && (_.isArray(obj) || _.isString(obj) || _.isArguments(obj))) return obj.length === 0;\n    return _.keys(obj).length === 0;\n  };\n\n  // Is a given value a DOM element?\n  _.isElement = function(obj) {\n    return !!(obj && obj.nodeType === 1);\n  };\n\n  // Is a given value an array?\n  // Delegates to ECMA5's native Array.isArray\n  _.isArray = nativeIsArray || function(obj) {\n    return toString.call(obj) === '[object Array]';\n  };\n\n  // Is a given variable an object?\n  _.isObject = function(obj) {\n    var type = typeof obj;\n    return type === 'function' || type === 'object' && !!obj;\n  };\n\n  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp, isError.\n  _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp', 'Error'], function(name) {\n    _['is' + name] = function(obj) {\n      return toString.call(obj) === '[object ' + name + ']';\n    };\n  });\n\n  // Define a fallback version of the method in browsers (ahem, IE < 9), where\n  // there isn't any inspectable \"Arguments\" type.\n  if (!_.isArguments(arguments)) {\n    _.isArguments = function(obj) {\n      return _.has(obj, 'callee');\n    };\n  }\n\n  // Optimize `isFunction` if appropriate. Work around some typeof bugs in old v8,\n  // IE 11 (#1621), and in Safari 8 (#1929).\n  if (typeof /./ != 'function' && typeof Int8Array != 'object') {\n    _.isFunction = function(obj) {\n      return typeof obj == 'function' || false;\n    };\n  }\n\n  // Is a given object a finite number?\n  _.isFinite = function(obj) {\n    return isFinite(obj) && !isNaN(parseFloat(obj));\n  };\n\n  // Is the given value `NaN`? (NaN is the only number which does not equal itself).\n  _.isNaN = function(obj) {\n    return _.isNumber(obj) && obj !== +obj;\n  };\n\n  // Is a given value a boolean?\n  _.isBoolean = function(obj) {\n    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n  };\n\n  // Is a given value equal to null?\n  _.isNull = function(obj) {\n    return obj === null;\n  };\n\n  // Is a given variable undefined?\n  _.isUndefined = function(obj) {\n    return obj === void 0;\n  };\n\n  // Shortcut function for checking if an object has a given property directly\n  // on itself (in other words, not on a prototype).\n  _.has = function(obj, key) {\n    return obj != null && hasOwnProperty.call(obj, key);\n  };\n\n  // Utility Functions\n  // -----------------\n\n  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\n  // previous owner. Returns a reference to the Underscore object.\n  _.noConflict = function() {\n    root._ = previousUnderscore;\n    return this;\n  };\n\n  // Keep the identity function around for default iteratees.\n  _.identity = function(value) {\n    return value;\n  };\n\n  // Predicate-generating functions. Often useful outside of Underscore.\n  _.constant = function(value) {\n    return function() {\n      return value;\n    };\n  };\n\n  _.noop = function(){};\n\n  _.property = property;\n\n  // Generates a function for a given object that returns a given property.\n  _.propertyOf = function(obj) {\n    return obj == null ? function(){} : function(key) {\n      return obj[key];\n    };\n  };\n\n  // Returns a predicate for checking whether an object has a given set of\n  // `key:value` pairs.\n  _.matcher = _.matches = function(attrs) {\n    attrs = _.extendOwn({}, attrs);\n    return function(obj) {\n      return _.isMatch(obj, attrs);\n    };\n  };\n\n  // Run a function **n** times.\n  _.times = function(n, iteratee, context) {\n    var accum = Array(Math.max(0, n));\n    iteratee = optimizeCb(iteratee, context, 1);\n    for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n    return accum;\n  };\n\n  // Return a random integer between min and max (inclusive).\n  _.random = function(min, max) {\n    if (max == null) {\n      max = min;\n      min = 0;\n    }\n    return min + Math.floor(Math.random() * (max - min + 1));\n  };\n\n  // A (possibly faster) way to get the current timestamp as an integer.\n  _.now = Date.now || function() {\n    return new Date().getTime();\n  };\n\n   // List of HTML entities for escaping.\n  var escapeMap = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#x27;',\n    '`': '&#x60;'\n  };\n  var unescapeMap = _.invert(escapeMap);\n\n  // Functions for escaping and unescaping strings to/from HTML interpolation.\n  var createEscaper = function(map) {\n    var escaper = function(match) {\n      return map[match];\n    };\n    // Regexes for identifying a key that needs to be escaped\n    var source = '(?:' + _.keys(map).join('|') + ')';\n    var testRegexp = RegExp(source);\n    var replaceRegexp = RegExp(source, 'g');\n    return function(string) {\n      string = string == null ? '' : '' + string;\n      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n    };\n  };\n  _.escape = createEscaper(escapeMap);\n  _.unescape = createEscaper(unescapeMap);\n\n  // If the value of the named `property` is a function then invoke it with the\n  // `object` as context; otherwise, return it.\n  _.result = function(object, property, fallback) {\n    var value = object == null ? void 0 : object[property];\n    if (value === void 0) {\n      value = fallback;\n    }\n    return _.isFunction(value) ? value.call(object) : value;\n  };\n\n  // Generate a unique integer id (unique within the entire client session).\n  // Useful for temporary DOM ids.\n  var idCounter = 0;\n  _.uniqueId = function(prefix) {\n    var id = ++idCounter + '';\n    return prefix ? prefix + id : id;\n  };\n\n  // By default, Underscore uses ERB-style template delimiters, change the\n  // following template settings to use alternative delimiters.\n  _.templateSettings = {\n    evaluate    : /<%([\\s\\S]+?)%>/g,\n    interpolate : /<%=([\\s\\S]+?)%>/g,\n    escape      : /<%-([\\s\\S]+?)%>/g\n  };\n\n  // When customizing `templateSettings`, if you don't want to define an\n  // interpolation, evaluation or escaping regex, we need one that is\n  // guaranteed not to match.\n  var noMatch = /(.)^/;\n\n  // Certain characters need to be escaped so that they can be put into a\n  // string literal.\n  var escapes = {\n    \"'\":      \"'\",\n    '\\\\':     '\\\\',\n    '\\r':     'r',\n    '\\n':     'n',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  var escaper = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\n  var escapeChar = function(match) {\n    return '\\\\' + escapes[match];\n  };\n\n  // JavaScript micro-templating, similar to John Resig's implementation.\n  // Underscore templating handles arbitrary delimiters, preserves whitespace,\n  // and correctly escapes quotes within interpolated code.\n  // NB: `oldSettings` only exists for backwards compatibility.\n  _.template = function(text, settings, oldSettings) {\n    if (!settings && oldSettings) settings = oldSettings;\n    settings = _.defaults({}, settings, _.templateSettings);\n\n    // Combine delimiters into one regular expression via alternation.\n    var matcher = RegExp([\n      (settings.escape || noMatch).source,\n      (settings.interpolate || noMatch).source,\n      (settings.evaluate || noMatch).source\n    ].join('|') + '|$', 'g');\n\n    // Compile the template source, escaping string literals appropriately.\n    var index = 0;\n    var source = \"__p+='\";\n    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n      source += text.slice(index, offset).replace(escaper, escapeChar);\n      index = offset + match.length;\n\n      if (escape) {\n        source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n      } else if (interpolate) {\n        source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n      } else if (evaluate) {\n        source += \"';\\n\" + evaluate + \"\\n__p+='\";\n      }\n\n      // Adobe VMs need the match returned to produce the correct offest.\n      return match;\n    });\n    source += \"';\\n\";\n\n    // If a variable is not specified, place data values in local scope.\n    if (!settings.variable) source = 'with(obj||{}){\\n' + source + '}\\n';\n\n    source = \"var __t,__p='',__j=Array.prototype.join,\" +\n      \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n      source + 'return __p;\\n';\n\n    try {\n      var render = new Function(settings.variable || 'obj', '_', source);\n    } catch (e) {\n      e.source = source;\n      throw e;\n    }\n\n    var template = function(data) {\n      return render.call(this, data, _);\n    };\n\n    // Provide the compiled source as a convenience for precompilation.\n    var argument = settings.variable || 'obj';\n    template.source = 'function(' + argument + '){\\n' + source + '}';\n\n    return template;\n  };\n\n  // Add a \"chain\" function. Start chaining a wrapped Underscore object.\n  _.chain = function(obj) {\n    var instance = _(obj);\n    instance._chain = true;\n    return instance;\n  };\n\n  // OOP\n  // ---------------\n  // If Underscore is called as a function, it returns a wrapped object that\n  // can be used OO-style. This wrapper holds altered versions of all the\n  // underscore functions. Wrapped objects may be chained.\n\n  // Helper function to continue chaining intermediate results.\n  var result = function(instance, obj) {\n    return instance._chain ? _(obj).chain() : obj;\n  };\n\n  // Add your own custom functions to the Underscore object.\n  _.mixin = function(obj) {\n    _.each(_.functions(obj), function(name) {\n      var func = _[name] = obj[name];\n      _.prototype[name] = function() {\n        var args = [this._wrapped];\n        push.apply(args, arguments);\n        return result(this, func.apply(_, args));\n      };\n    });\n  };\n\n  // Add all of the Underscore functions to the wrapper object.\n  _.mixin(_);\n\n  // Add all mutator Array functions to the wrapper.\n  _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      var obj = this._wrapped;\n      method.apply(obj, arguments);\n      if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];\n      return result(this, obj);\n    };\n  });\n\n  // Add all accessor Array functions to the wrapper.\n  _.each(['concat', 'join', 'slice'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      return result(this, method.apply(this._wrapped, arguments));\n    };\n  });\n\n  // Extracts the result from a wrapped and chained object.\n  _.prototype.value = function() {\n    return this._wrapped;\n  };\n\n  // Provide unwrapping proxy for some methods used in engine operations\n  // such as arithmetic and JSON stringification.\n  _.prototype.valueOf = _.prototype.toJSON = _.prototype.value;\n\n  _.prototype.toString = function() {\n    return '' + this._wrapped;\n  };\n\n  // AMD registration happens at the end for compatibility with AMD loaders\n  // that may not enforce next-turn semantics on modules. Even though general\n  // practice for AMD registration is to be anonymous, underscore registers\n  // as a named module because, like jQuery, it is a base library that is\n  // popular enough to be bundled in a third party lib, but not be part of\n  // an AMD load request. Those cases could generate an error when an\n  // anonymous define() is called outside of a loader request.\n  if (typeof define === 'function' && define.amd) {\n    define('underscore', [], function() {\n      return _;\n    });\n  }\n}.call(this));\n","chai      = require('chai')\nexpect    = chai.expect\nshould    = chai.should()\nsinon     = require('sinon')\nsinonChai = require('sinon-chai')\n_         = require(\"underscore\")\n\nchai.use(sinonChai)\nY = require \"../../yjs/lib/y\"\nY.List = require \"../../y-list/lib/y-list.coffee\"\nY.Selections = require \"../lib/y-selections\"\n\nConnector = require \"../../y-test/lib/y-test.coffee\"\n\nTestSuite = require \"../../yjs/test/TestSuite\"\n\nclass SelectionsTest extends TestSuite\n\n  constructor: (suffix)->\n    super suffix, Y\n\n  type: \"SelectionsTest\"\n\n  makeNewUser: (userId)->\n    conn = new Connector userId\n    new Y conn\n\n  initUsers: (u)->\n    u.val(\"selections\",new Y.Selections())\n    u.val(\"list\", new Y.List([1,2,3,4,5,6,7,8,9,10]))\n\n  getRandomRoot: (user_num)->\n    @users[user_num].val(\"TextTest\")\n\n  getContent: (user_num)->\n    @users[user_num].val(\"TextTest\").val()\n\ndescribe \"Selections Test\", ->\n  @timeout 500000\n\n  beforeEach (done)->\n    @yTest = new SelectionsTest()\n    done()\n\n  it \"selected two elements, checked for pointers\", ->\n    l = @yTest.users[0].val(\"list\")\n    l_left = l.ref(1)\n    l_right = l.ref(2)\n    sel = @yTest.users[0].val(\"selections\")\n    sel.select(l_left, l_right, {\"my_attr\":\"black\"})\n    expect(l.ref(1).selection.from).to.equal(l.ref(1))\n    expect(l.ref(1).selection.to).to.equal(l.ref(2))\n    expect(l.ref(2).selection.from).to.equal(l.ref(1))\n    expect(l.ref(2).selection.to).to.equal(l.ref(2))\n\n  it \"selected two elements, checked for pointers (foreign user)\", ->\n    l = @yTest.users[0].val(\"list\")\n    l_left = l.ref(1)\n    l_right = l.ref(2)\n    sel = @yTest.users[0].val(\"selections\")\n    sel.select(l_left, l_right, {\"c\": \"blue\"})\n    @yTest.flushAll()\n    l = @yTest.users[1].val(\"list\")\n    expect(l.ref(1).selection.from).to.equal(l.ref(1))\n    expect(l.ref(1).selection.to).to.equal(l.ref(2))\n    expect(l.ref(2).selection.from).to.equal(l.ref(1))\n    expect(l.ref(2).selection.to).to.equal(l.ref(2))\n\n  it \"selected two elements, checked for pointers (foreign user, new Selections instance)\", ->\n    l = @yTest.users[0].val(\"list\")\n    l_left = l.ref(1)\n    l_right = l.ref(2)\n    @yTest.users[0].val(\"selections\", new Y.Selections())\n    sel = @yTest.users[0].val(\"selections\")\n    sel.select(l_left, l_right, {\"c\": \"blue\"})\n    @yTest.flushAll()\n    l = @yTest.users[1].val(\"list\")\n    expect(l.ref(1).selection.from).to.equal(l.ref(1))\n    expect(l.ref(1).selection.to).to.equal(l.ref(2))\n    expect(l.ref(2).selection.from).to.equal(l.ref(1))\n    expect(l.ref(2).selection.to).to.equal(l.ref(2))\n\n  it \"selected two times two elements, checked for pointers (foreign user, new Selections instance)\", ->\n    l = @yTest.users[0].val(\"list\")\n    l_left = l.ref(1)\n    l_right = l.ref(2)\n    @yTest.users[0].val(\"selections\", new Y.Selections())\n    sel = @yTest.users[0].val(\"selections\")\n    sel.select(l_left, l_right, {\"c\": \"blue\"})\n    l_left = l.ref(3)\n    l_right = l.ref(4)\n    sel.select(l_left, l_right, {\"c\": \"blue\"})\n    @yTest.flushAll()\n    l = @yTest.users[1].val(\"list\")\n    expect(l.ref(1).selection.from).to.equal(l.ref(1))\n    expect(l.ref(1).selection.to).to.equal(l.ref(4))\n    expect(l.ref(2).selection?).to.be.false\n    expect(l.ref(3).selection?).to.be.false\n\n\n  describe \"Intersection of selections:\", ->\n    it \"intersected two elements, checked for pointers and attrs (strict inner overwrite)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(4)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(3)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      @yTest.flushAll()\n      # inner selection is the same\n      expect(l.ref(2).selection).to.equal(l.ref(3).selection)\n\n      expect(l.ref(2).selection.from).to.equal(l.ref(2))\n      expect(l.ref(2).selection.to).to.equal(l.ref(3))\n      expect(l.ref(2).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(1))\n      expect(l.ref(4).selection.from).to.equal(l.ref(4))\n      expect(l.ref(4).selection.to).to.equal(l.ref(4))\n      expect(l.ref(2).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(3).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n      expect(l.ref(4).selection.attrs.c).to.equal(\"black\")\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:1,attrs:{\"c\":\"black\"}},\n        {from:2,to:3,attrs:{\"c\":\"blue\"}},\n        {from:4,to:4,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements (minimal), checked for pointers and attrs (strict inner overwrite)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      @yTest.flushAll()\n      expect(l.ref(2).selection.from).to.equal(l.ref(2))\n      expect(l.ref(2).selection.to).to.equal(l.ref(2))\n      expect(l.ref(2).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(2).selection.from).to.equal(l.ref(2))\n      expect(l.ref(2).selection.to).to.equal(l.ref(2))\n      expect(l.ref(2).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(3).selection.attrs.c).to.equal(\"black\")\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:1,attrs:{\"c\":\"black\"}},\n        {from:2,to:2,attrs:{\"c\":\"blue\"}},\n        {from:3,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements, checked for pointers and attrs (inner overwrite, left non-strict, right strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(2))\n      expect(l.ref(1).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(2).selection.from).to.equal(l.ref(1))\n      expect(l.ref(2).selection.to).to.equal(l.ref(2))\n      expect(l.ref(2).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(3).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:2,attrs:{\"c\":\"blue\"}},\n        {from:3,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements (minimal), checked for pointers and attrs (inner overwrite, left non-strict, right strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(1)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(1))\n      expect(l.ref(1).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(2).selection.from).to.equal(l.ref(2))\n      expect(l.ref(2).selection.to).to.equal(l.ref(3))\n      expect(l.ref(1).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(2).selection.attrs.c).to.equal(\"black\")\n      expect(l.ref(3).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:1,attrs:{\"c\":\"blue\"}},\n        {from:2,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements, checked for pointers and attrs (inner overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(2))\n      expect(l.ref(1).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(2).selection.from).to.equal(l.ref(1))\n      expect(l.ref(2).selection.to).to.equal(l.ref(2))\n      expect(l.ref(2).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(0).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:0,attrs:{\"c\":\"black\"}},\n        {from:1,to:2,attrs:{\"c\":\"blue\"}}\n        ])\n\n    it \"intersected two elements (minimal), checked for pointers and attrs (inner overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection).to.equal(l.ref(0).selection)\n\n      expect(l.ref(2).selection.to).to.equal(l.ref(2))\n      expect(l.ref(2).selection.from).to.equal(l.ref(2))\n      expect(l.ref(0).selection.to).to.equal(l.ref(1))\n      expect(l.ref(1).selection.from).to.equal(l.ref(0))\n\n      expect(l.ref(2).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(0).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:1,attrs:{\"c\":\"black\"}},\n        {from:2,to:2,attrs:{\"c\":\"blue\"}}\n        ])\n\n    it \"intersected two elements, checked for pointers and attrs (strict outer overwrite)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(3)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(4)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      @yTest.flushAll()\n\n      expect(l.ref(1).selection).to.equal(l.ref(4).selection)\n\n      expect(l.ref(1).selection.to).to.equal(l.ref(4))\n      expect(l.ref(4).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:4,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements (minimal), checked for pointers and attrs (strict outer overwrite)\", ->\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(3))\n      expect(l.ref(3).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements, checked for pointers and attrs (outer overwrite, left non-strict, right strict)\", ->\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection).to.equal(l.ref(3).selection)\n\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(3))\n\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements (minimal), checked for pointers and attrs (outer overwrite, left non-strict, right strict)\", ->\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(1)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection).to.equal(l.ref(3).selection)\n\n      expect(l.ref(1).selection.to).to.equal(l.ref(3))\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements, checked for pointers and attrs (outer overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      @yTest.flushAll()\n      expect(l.ref(0).selection).to.equal(l.ref(2).selection)\n\n      expect(l.ref(0).selection.from).to.equal(l.ref(0))\n      expect(l.ref(0).selection.to).to.equal(l.ref(2))\n\n      expect(l.ref(0).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:2,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements (minimal), checked for pointers and attrs (outer overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      @yTest.flushAll()\n\n      expect(l.ref(0).selection).to.equal(l.ref(2).selection)\n\n      expect(l.ref(0).selection.to).to.equal(l.ref(2))\n      expect(l.ref(2).selection.from).to.equal(l.ref(0))\n\n      expect(l.ref(0).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:2,attrs:{\"c\":\"black\"}}\n        ])\n\n  describe \"Unselections\", ()->\n    it \"intersected a selection, checked for pointers and attrs (strict inner overwrite)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(4)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(3)\n      @yTest.users[0].val(\"selections\").unselect(l_left, l_right, [\"c\"])\n\n      @yTest.flushAll()\n      # inner selection is the same\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(3).selection).to.be.undefined\n\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(1))\n      expect(l.ref(4).selection.from).to.equal(l.ref(4))\n      expect(l.ref(4).selection.to).to.equal(l.ref(4))\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n      expect(l.ref(4).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:1,attrs:{\"c\":\"black\"}},\n        {from:4,to:4,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected a selection (minimal), checked for pointers and attrs (strict inner overwrite)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(1))\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(3).selection.attrs.c).to.equal(\"black\")\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:1,attrs:{\"c\":\"black\"}},\n        {from:3,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected a selection, checked for pointers and attrs (inner overwrite, left non-strict, right strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection).to.be.undefined\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(3).selection.attrs.c).to.equal(\"black\")\n      expect(l.ref(3).selection.from).to.equal(l.ref(3))\n      expect(l.ref(3).selection.to).to.equal(l.ref(3))\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:3,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected a selection (minimal), checked for pointers and attrs (inner overwrite, left non-strict, right strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(1)\n      @yTest.users[0].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection).to.be.undefined\n      expect(l.ref(2).selection).to.equal(l.ref(3).selection)\n      expect(l.ref(2).selection.from).to.equal(l.ref(2))\n      expect(l.ref(2).selection.to).to.equal(l.ref(3))\n      expect(l.ref(1).selection).to.be.undefined\n      expect(l.ref(2).selection.attrs.c).to.equal(\"black\")\n      expect(l.ref(3).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:2,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected a selection, checked for pointers and attrs (inner overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n      expect(l.ref(0).selection).to.equal(l.ref(0).selection)\n      expect(l.ref(0).selection.from).to.equal(l.ref(0))\n      expect(l.ref(0).selection.to).to.equal(l.ref(0))\n      expect(l.ref(1).selection).to.be.undefined\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(0).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:0,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected a selection (minimal), checked for pointers and attrs (inner overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection).to.equal(l.ref(0).selection)\n\n      expect(l.ref(0).selection.to).to.equal(l.ref(1))\n      expect(l.ref(1).selection.from).to.equal(l.ref(0))\n\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(0).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:1,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected a selection, checked for pointers and attrs (strict outer overwrite)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(3)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(4)\n      sel = @yTest.users[0].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(3).selection).to.be.undefined\n      expect(l.ref(1).selection).to.be.undefined\n      expect(l.ref(4).selection).to.be.undefined\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([])\n\n    it \"intersected a selection (minimal), checked for pointers and attrs (strict outer overwrite)\", ->\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(1).selection).to.be.undefined\n      expect(l.ref(3).selection).to.be.undefined\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([])\n\n    it \"intersected a selection, checked for pointers and attrs (outer overwrite, left non-strict, right strict)\", ->\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n\n      @yTest.flushAll()\n\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(3).selection).to.be.undefined\n      expect(l.ref(1).selection).to.be.undefined\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([])\n\n    it \"intersected a selection (minimal), checked for pointers and attrs (outer overwrite, left non-strict, right strict)\", ->\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(1)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n\n      @yTest.flushAll()\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(3).selection).to.be.undefined\n      expect(l.ref(1).selection).to.be.undefined\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([])\n\n    it \"intersected a selection, checked for pointers and attrs (outer overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[0].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(1).selection).to.be.undefined\n      expect(l.ref(0).selection).to.be.undefined\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([])\n\n    it \"intersected a selection (minimal), checked for pointers and attrs (outer overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[0].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(1).selection).to.be.undefined\n      expect(l.ref(0).selection).to.be.undefined\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([])\n\n  describe \"Concurrent intersection of selections:\", ->\n    it \"intersected two elements, checked for pointers and attrs (strict inner overwrite)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(4)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(3)\n      @yTest.users[1].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      @yTest.flushAll()\n      # inner selection is the same\n      expect(l.ref(2).selection).to.equal(l.ref(3).selection)\n\n      expect(l.ref(2).selection.from).to.equal(l.ref(2))\n      expect(l.ref(2).selection.to).to.equal(l.ref(3))\n      expect(l.ref(2).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(1))\n      expect(l.ref(4).selection.from).to.equal(l.ref(4))\n      expect(l.ref(4).selection.to).to.equal(l.ref(4))\n      expect(l.ref(2).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(3).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n      expect(l.ref(4).selection.attrs.c).to.equal(\"black\")\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:1,attrs:{\"c\":\"black\"}},\n        {from:2,to:3,attrs:{\"c\":\"blue\"}},\n        {from:4,to:4,attrs:{\"c\":\"black\"}}\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:1,attrs:{\"c\":\"black\"}},\n        {from:2,to:3,attrs:{\"c\":\"blue\"}},\n        {from:4,to:4,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements (minimal), checked for pointers and attrs (strict inner overwrite)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[1].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      @yTest.flushAll()\n      expect(l.ref(2).selection.from).to.equal(l.ref(2))\n      expect(l.ref(2).selection.to).to.equal(l.ref(2))\n      expect(l.ref(2).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(2).selection.from).to.equal(l.ref(2))\n      expect(l.ref(2).selection.to).to.equal(l.ref(2))\n      expect(l.ref(2).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(3).selection.attrs.c).to.equal(\"black\")\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:1,attrs:{\"c\":\"black\"}},\n        {from:2,to:2,attrs:{\"c\":\"blue\"}},\n        {from:3,to:3,attrs:{\"c\":\"black\"}}\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:1,attrs:{\"c\":\"black\"}},\n        {from:2,to:2,attrs:{\"c\":\"blue\"}},\n        {from:3,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements, checked for pointers and attrs (inner overwrite, left non-strict, right strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[1].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(2))\n      expect(l.ref(1).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(2).selection.from).to.equal(l.ref(1))\n      expect(l.ref(2).selection.to).to.equal(l.ref(2))\n      expect(l.ref(2).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(3).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:2,attrs:{\"c\":\"blue\"}},\n        {from:3,to:3,attrs:{\"c\":\"black\"}}\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:2,attrs:{\"c\":\"blue\"}},\n        {from:3,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements (minimal), checked for pointers and attrs (inner overwrite, left non-strict, right strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(1)\n      @yTest.users[1].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(1))\n      expect(l.ref(1).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(2).selection.from).to.equal(l.ref(2))\n      expect(l.ref(2).selection.to).to.equal(l.ref(3))\n      expect(l.ref(1).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(2).selection.attrs.c).to.equal(\"black\")\n      expect(l.ref(3).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:1,attrs:{\"c\":\"blue\"}},\n        {from:2,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:1,attrs:{\"c\":\"blue\"}},\n        {from:2,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements, checked for pointers and attrs (inner overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[1].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(2))\n      expect(l.ref(1).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(2).selection.from).to.equal(l.ref(1))\n      expect(l.ref(2).selection.to).to.equal(l.ref(2))\n      expect(l.ref(2).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(0).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:0,attrs:{\"c\":\"black\"}},\n        {from:1,to:2,attrs:{\"c\":\"blue\"}}\n        ])\n\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:0,attrs:{\"c\":\"black\"}},\n        {from:1,to:2,attrs:{\"c\":\"blue\"}}\n        ])\n\n    it \"intersected two elements (minimal), checked for pointers and attrs (inner overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[1].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection).to.equal(l.ref(0).selection)\n\n      expect(l.ref(2).selection.to).to.equal(l.ref(2))\n      expect(l.ref(2).selection.from).to.equal(l.ref(2))\n      expect(l.ref(0).selection.to).to.equal(l.ref(1))\n      expect(l.ref(1).selection.from).to.equal(l.ref(0))\n\n      expect(l.ref(2).selection.attrs.c).to.equal(\"blue\")\n      expect(l.ref(0).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:1,attrs:{\"c\":\"black\"}},\n        {from:2,to:2,attrs:{\"c\":\"blue\"}}\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:1,attrs:{\"c\":\"black\"}},\n        {from:2,to:2,attrs:{\"c\":\"blue\"}}\n        ])\n\n    it \"intersected two elements, checked for pointers and attrs (strict outer overwrite)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(3)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(4)\n      sel = @yTest.users[1].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      @yTest.flushAll()\n\n      expect(l.ref(1).selection).to.equal(l.ref(4).selection)\n\n      expect(l.ref(1).selection.to).to.equal(l.ref(4))\n      expect(l.ref(4).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:4,attrs:{\"c\":\"black\"}}\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:4,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements (minimal), checked for pointers and attrs (strict outer overwrite)\", ->\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[1].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection).to.equal(l.ref(3).selection)\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(3))\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:3,attrs:{\"c\":\"black\"}}\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements, checked for pointers and attrs (outer overwrite, left non-strict, right strict)\", ->\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[1].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection).to.equal(l.ref(3).selection)\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(3))\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:3,attrs:{\"c\":\"black\"}}\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements (minimal), checked for pointers and attrs (outer overwrite, left non-strict, right strict)\", ->\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(1)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[1].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection).to.equal(l.ref(3).selection)\n\n\n      expect(l.ref(1).selection.to).to.equal(l.ref(3))\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:3,attrs:{\"c\":\"black\"}}\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements, checked for pointers and attrs (outer overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[1].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      @yTest.flushAll()\n      expect(l.ref(0).selection).to.equal(l.ref(2).selection)\n\n      expect(l.ref(0).selection.from).to.equal(l.ref(0))\n      expect(l.ref(0).selection.to).to.equal(l.ref(2))\n      expect(l.ref(0).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:2,attrs:{\"c\":\"black\"}}\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:2,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected two elements (minimal), checked for pointers and attrs (outer overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[1].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      @yTest.flushAll()\n\n      expect(l.ref(0).selection).to.equal(l.ref(2).selection)\n\n      expect(l.ref(0).selection.to).to.equal(l.ref(2))\n      expect(l.ref(2).selection.from).to.equal(l.ref(0))\n\n      expect(l.ref(0).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:2,attrs:{\"c\":\"black\"}}\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:2,attrs:{\"c\":\"black\"}}\n        ])\n\n  describe \"Concurrent Unselections\", ()->\n    it \"intersected a selection, checked for pointers and attrs (strict inner overwrite)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(4)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(3)\n      @yTest.users[1].val(\"selections\").unselect(l_left, l_right, [\"c\"])\n\n      @yTest.flushAll()\n      # inner selection is the same\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(1))\n      expect(l.ref(4).selection.from).to.equal(l.ref(4))\n      expect(l.ref(4).selection.to).to.equal(l.ref(4))\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(3).selection).to.be.undefined\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n      expect(l.ref(4).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:1,attrs:{\"c\":\"black\"}},\n        {from:4,to:4,attrs:{\"c\":\"black\"}}\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:1,attrs:{\"c\":\"black\"}},\n        {from:4,to:4,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected a selection (minimal), checked for pointers and attrs (strict inner overwrite)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[1].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection.from).to.equal(l.ref(1))\n      expect(l.ref(1).selection.to).to.equal(l.ref(1))\n\n      expect(l.ref(3).selection.from).to.equal(l.ref(3))\n      expect(l.ref(3).selection.to).to.equal(l.ref(3))\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(3).selection.attrs.c).to.equal(\"black\")\n      expect(l.ref(1).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:1,attrs:{\"c\":\"black\"}},\n        {from:3,to:3,attrs:{\"c\":\"black\"}}\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:1,to:1,attrs:{\"c\":\"black\"}},\n        {from:3,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected a selection, checked for pointers and attrs (inner overwrite, left non-strict, right strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[1].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n      expect(l.ref(3).selection.from).to.equal(l.ref(3))\n      expect(l.ref(3).selection.to).to.equal(l.ref(3))\n      expect(l.ref(1).selection).to.be.undefined\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(3).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:3,to:3,attrs:{\"c\":\"black\"}},\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:3,to:3,attrs:{\"c\":\"black\"}},\n        ])\n\n    it \"intersected a selection (minimal), checked for pointers and attrs (inner overwrite, left non-strict, right strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(1)\n      @yTest.users[1].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n      expect(l.ref(2).selection.from).to.equal(l.ref(2))\n      expect(l.ref(2).selection.to).to.equal(l.ref(3))\n      expect(l.ref(1).selection).to.be.undefined\n      expect(l.ref(2).selection.attrs.c).to.equal(\"black\")\n      expect(l.ref(3).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:2,to:3,attrs:{\"c\":\"black\"}}\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:2,to:3,attrs:{\"c\":\"black\"}}\n        ])\n\n\n    it \"intersected a selection, checked for pointers and attrs (inner overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[1].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n      expect(l.ref(0).selection.from).to.equal(l.ref(0))\n      expect(l.ref(0).selection.to).to.equal(l.ref(0))\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(1).selection).to.be.undefined\n      expect(l.ref(0).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:0,attrs:{\"c\":\"black\"}},\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:0,attrs:{\"c\":\"black\"}},\n        ])\n\n    it \"intersected a selection (minimal), checked for pointers and attrs (inner overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"black\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[1].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n      expect(l.ref(1).selection).to.equal(l.ref(0).selection)\n\n      expect(l.ref(0).selection.to).to.equal(l.ref(1))\n      expect(l.ref(1).selection.from).to.equal(l.ref(0))\n\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(0).selection.attrs.c).to.equal(\"black\")\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:1,attrs:{\"c\":\"black\"}}\n        ])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([\n        {from:0,to:1,attrs:{\"c\":\"black\"}}\n        ])\n\n    it \"intersected a selection, checked for pointers and attrs (strict outer overwrite)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(3)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(4)\n      sel = @yTest.users[1].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(3).selection).to.be.undefined\n      expect(l.ref(1).selection).to.be.undefined\n      expect(l.ref(4).selection).to.be.undefined\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([])\n\n    it \"intersected a selection (minimal), checked for pointers and attrs (strict outer overwrite)\", ->\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[1].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(1).selection).to.be.undefined\n      expect(l.ref(3).selection).to.be.undefined\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([])\n\n    it \"intersected a selection, checked for pointers and attrs (outer overwrite, left non-strict, right strict)\", ->\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[1].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n\n      @yTest.flushAll()\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(3).selection).to.be.undefined\n      expect(l.ref(1).selection).to.be.undefined\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([])\n\n\n    it \"intersected a selection (minimal), checked for pointers and attrs (outer overwrite, left non-strict, right strict)\", ->\n\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(1)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(3)\n      sel = @yTest.users[1].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n\n      @yTest.flushAll()\n\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(3).selection).to.be.undefined\n      expect(l.ref(1).selection).to.be.undefined\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([])\n\n    it \"intersected a selection, checked for pointers and attrs (outer overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(1)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[1].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(1).selection).to.be.undefined\n      expect(l.ref(0).selection).to.be.undefined\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([])\n\n    it \"intersected a selection (minimal), checked for pointers and attrs (outer overwrite, right non-strict, left strict)\", ->\n      l = @yTest.users[0].val(\"list\")\n      l_left = l.ref(2)\n      l_right = l.ref(2)\n      @yTest.users[0].val(\"selections\").select(l_left, l_right, {\"c\": \"blue\"})\n\n      l = @yTest.users[1].val(\"list\")\n      l_left = l.ref(0)\n      l_right = l.ref(2)\n      sel = @yTest.users[1].val(\"selections\").unselect(l_left, l_right, \"c\")\n\n      @yTest.flushAll()\n\n      expect(l.ref(2).selection).to.be.undefined\n      expect(l.ref(1).selection).to.be.undefined\n      expect(l.ref(0).selection).to.be.undefined\n\n      s = @yTest.users[0].val(\"selections\").getSelections(@yTest.users[0].val(\"list\"))\n      expect(s).to.deep.equal([])\n      s = @yTest.users[1].val(\"selections\").getSelections(@yTest.users[1].val(\"list\"))\n      expect(s).to.deep.equal([])\n\nmodule.exports = SelectionsTest\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nmodule.exports = SelectionsTest\n","\n#\n# A trivial Connector that simulates network delay.\n#\nclass TestConnector\n\n  #\n  # @param id {String} Some unique id\n  #\n  constructor: (@id)->\n    options =\n      syncMethod: \"syncAll\"\n      role: \"slave\"\n      user_id: @id # TODO: for now, we save the user_id under @id AND @user_id, but change this later..\n      perform_send_again: false\n\n    @on_bound_to_y = ()=>\n      @init options\n\n      # If you think of operations, this will mirror the\n      # execiton order of operations (when a message is send, or received it is put into this)\n      @execution_order = []\n      # The messages are buffered under the name of teh sending user.\n      @receive_buffer = {}\n\n      @receive_handlers.push (user, message)=>\n        @execution_order.push message\n\n  # join another user connector\n  join: (conn)->\n    if not @connections[conn.id]?\n      @connections[conn.id] = {conn : conn}\n      @userJoined conn.id, \"slave\"\n      conn.join @\n      @flushAll()\n      conn.flushAll()\n      @flushAll()\n      conn.flushAll()\n      for cid,c of conn.connections\n        if not @connections[cid]?\n          @join c.conn\n\n\n\n  #\n  # Get the ops in the execution order.\n  #\n  getOpsInExecutionOrder: ()->\n    @execution_order\n\n  #\n  # Send a message to another peer\n  # @param {Operation} o The operation that was executed.\n  #\n  send: (uid, message)->\n    if message.sync_step? and false # TODO: false\n      @receiveMessage uid, message\n    else\n      rb = @connections[uid].conn.receive_buffer\n      rb[@id] ?= []\n      rb[@id].push message\n\n  broadcast: (message)->\n    for name, c of @connections\n      @send name, message\n\n  #\n  # Flush one operation from the line of a specific user.\n  #\n  flushOne: (uid)->\n    if @receive_buffer[uid]?.length > 0\n      message = @receive_buffer[uid].shift()\n      @receiveMessage(uid, message)\n\n\n  #\n  # Flush one operation on a random line.\n  #\n  flushOneRandom: ()->\n    connlist = for cid,c of @receive_buffer\n      cid\n    i = Math.ceil(Math.random()*connlist.length-0.5)\n    @flushOne connlist[i]\n\n  #\n  # Flush all operations on every line.\n  #\n  flushAll: ()->\n    for n,messages of @receive_buffer\n      for message in messages\n        @receiveMessage(n, message)\n\n    @receive_buffer = {}\n\n\nif window?\n  if not Y?\n    throw new Error \"You must import Y first!\"\n  else\n    window.Y.TestConnector = TestConnector\n\nif module?\n  module.exports = TestConnector\n","\nConnectorClass = require \"./ConnectorClass\"\n#\n# @param {Engine} engine The transformation engine\n# @param {HistoryBuffer} HB\n# @param {Array<Function>} execution_listener You must ensure that whenever an operation is executed, every function in this Array is called.\n#\nadaptConnector = (connector, engine, HB, execution_listener)->\n\n  for name, f of ConnectorClass\n    connector[name] = f\n\n  connector.setIsBoundToY()\n\n  send_ = (o)->\n    if (o.uid.creator is HB.getUserId()) and\n        (typeof o.uid.op_number isnt \"string\") and # TODO: i don't think that we need this anymore..\n        (HB.getUserId() isnt \"_temp\")\n      connector.broadcast o\n\n  if connector.invokeSync?\n    HB.setInvokeSyncHandler connector.invokeSync\n\n  execution_listener.push send_\n  # For the XMPPConnector: lets send it as an array\n  # therefore, we have to restructure it later\n  encode_state_vector = (v)->\n    for name,value of v\n      user: name\n      state: value\n  parse_state_vector = (v)->\n    state_vector = {}\n    for s in v\n      state_vector[s.user] = s.state\n    state_vector\n\n  getStateVector = ()->\n    encode_state_vector HB.getOperationCounter()\n\n  getHB = (v)->\n    state_vector = parse_state_vector v\n    hb = HB._encode state_vector\n    json =\n      hb: hb\n      state_vector: encode_state_vector HB.getOperationCounter()\n    json\n\n  applyHB = (hb, fromHB)->\n    engine.applyOp hb, fromHB\n\n  connector.getStateVector = getStateVector\n  connector.getHB = getHB\n  connector.applyHB = applyHB\n\n  connector.receive_handlers ?= []\n  connector.receive_handlers.push (sender, op)->\n    if op.uid.creator isnt HB.getUserId()\n      engine.applyOp op\n\n\nmodule.exports = adaptConnector\n","\nmodule.exports =\n  #\n  # @params new Connector(options)\n  #   @param options.syncMethod {String}  is either \"syncAll\" or \"master-slave\".\n  #   @param options.role {String} The role of this client\n  #            (slave or master (only used when syncMethod is master-slave))\n  #   @param options.perform_send_again {Boolean} Whetehr to whether to resend the HB after some time period. This reduces sync errors, but has some overhead (optional)\n  #\n  init: (options)->\n    req = (name, choices)=>\n      if options[name]?\n        if (not choices?) or choices.some((c)->c is options[name])\n          @[name] = options[name]\n        else\n          throw new Error \"You can set the '\"+name+\"' option to one of the following choices: \"+JSON.encode(choices)\n      else\n        throw new Error \"You must specify \"+name+\", when initializing the Connector!\"\n\n    req \"syncMethod\", [\"syncAll\", \"master-slave\"]\n    req \"role\", [\"master\", \"slave\"]\n    req \"user_id\"\n    @on_user_id_set?(@user_id)\n\n    # whether to resend the HB after some time period. This reduces sync errors.\n    # But this is not necessary in the test-connector\n    if options.perform_send_again?\n      @perform_send_again = options.perform_send_again\n    else\n      @perform_send_again = true\n\n    # A Master should sync with everyone! TODO: really? - for now its safer this way!\n    if @role is \"master\"\n      @syncMethod = \"syncAll\"\n\n    # is set to true when this is synced with all other connections\n    @is_synced = false\n    # Peerjs Connections: key: conn-id, value: object\n    @connections = {}\n    # List of functions that shall process incoming data\n    @receive_handlers ?= []\n\n    # whether this instance is bound to any y instance\n    @connections = {}\n    @current_sync_target = null\n    @sent_hb_to_all_users = false\n    @is_initialized = true\n\n  onUserEvent: (f)->\n    @connections_listeners ?= []\n    @connections_listeners.push f\n\n  isRoleMaster: ->\n    @role is \"master\"\n\n  isRoleSlave: ->\n    @role is \"slave\"\n\n  findNewSyncTarget: ()->\n    @current_sync_target = null\n    if @syncMethod is \"syncAll\"\n      for user, c of @connections\n        if not c.is_synced\n          @performSync user\n          break\n    if not @current_sync_target?\n      @setStateSynced()\n    null\n\n  userLeft: (user)->\n    delete @connections[user]\n    @findNewSyncTarget()\n    if @connections_listeners?\n      for f in @connections_listeners\n        f {\n          action: \"userLeft\"\n          user: user\n        }\n\n\n  userJoined: (user, role)->\n    if not role?\n      throw new Error \"Internal: You must specify the role of the joined user! E.g. userJoined('uid:3939','slave')\"\n    # a user joined the room\n    @connections[user] ?= {}\n    @connections[user].is_synced = false\n\n    if (not @is_synced) or @syncMethod is \"syncAll\"\n      if @syncMethod is \"syncAll\"\n        @performSync user\n      else if role is \"master\"\n        # TODO: What if there are two masters? Prevent sending everything two times!\n        @performSyncWithMaster user\n\n    if @connections_listeners?\n      for f in @connections_listeners\n        f {\n          action: \"userJoined\"\n          user: user\n          role: role\n        }\n\n  #\n  # Execute a function _when_ we are connected. If not connected, wait until connected.\n  # @param f {Function} Will be executed on the Connector context.\n  #\n  whenSynced: (args)->\n    if args.constructor is Function\n      args = [args]\n    if @is_synced\n      args[0].apply this, args[1..]\n    else\n      @compute_when_synced ?= []\n      @compute_when_synced.push args\n\n  #\n  # Execute an function when a message is received.\n  # @param f {Function} Will be executed on the PeerJs-Connector context. f will be called with (sender_id, broadcast {true|false}, message).\n  #\n  onReceive: (f)->\n    @receive_handlers.push f\n\n  ###\n  # Broadcast a message to all connected peers.\n  # @param message {Object} The message to broadcast.\n  #\n  broadcast: (message)->\n    throw new Error \"You must implement broadcast!\"\n\n  #\n  # Send a message to a peer, or set of peers\n  #\n  send: (peer_s, message)->\n    throw new Error \"You must implement send!\"\n  ###\n\n  #\n  # perform a sync with a specific user.\n  #\n  performSync: (user)->\n    if not @current_sync_target?\n      @current_sync_target = user\n      @send user,\n        sync_step: \"getHB\"\n        send_again: \"true\"\n        data: @getStateVector()\n      if not @sent_hb_to_all_users\n        @sent_hb_to_all_users = true\n\n        hb = @getHB([]).hb\n        _hb = []\n        for o in hb\n          _hb.push o\n          if _hb.length > 10\n            @broadcast\n              sync_step: \"applyHB_\"\n              data: _hb\n            _hb = []\n        @broadcast\n          sync_step: \"applyHB\"\n          data: _hb\n\n\n\n  #\n  # When a master node joined the room, perform this sync with him. It will ask the master for the HB,\n  # and will broadcast his own HB\n  #\n  performSyncWithMaster: (user)->\n    @current_sync_target = user\n    @send user,\n      sync_step: \"getHB\"\n      send_again: \"true\"\n      data: @getStateVector()\n    hb = @getHB([]).hb\n    _hb = []\n    for o in hb\n      _hb.push o\n      if _hb.length > 10\n        @broadcast\n          sync_step: \"applyHB_\"\n          data: _hb\n        _hb = []\n    @broadcast\n      sync_step: \"applyHB\"\n      data: _hb\n\n  #\n  # You are sure that all clients are synced, call this function.\n  #\n  setStateSynced: ()->\n    if not @is_synced\n      @is_synced = true\n      if @compute_when_synced?\n        for el in @compute_when_synced\n          f = el[0]\n          args = el[1..]\n          f.apply(args)\n        delete @compute_when_synced\n      null\n\n  # executed when the a state_vector is received. listener will be called only once!\n  whenReceivedStateVector: (f)->\n    @when_received_state_vector_listeners ?= []\n    @when_received_state_vector_listeners.push f\n\n\n  #\n  # You received a raw message, and you know that it is intended for to Yjs. Then call this function.\n  #\n  receiveMessage: (sender, res)->\n    if not res.sync_step?\n      for f in @receive_handlers\n        f sender, res\n    else\n      if sender is @user_id\n        return\n      if res.sync_step is \"getHB\"\n        # call listeners\n        if @when_received_state_vector_listeners?\n          for f in @when_received_state_vector_listeners\n            f.call this, res.data\n        delete @when_received_state_vector_listeners\n\n        data = @getHB(res.data)\n        hb = data.hb\n        _hb = []\n        # always broadcast, when not synced.\n        # This reduces errors, when the clients goes offline prematurely.\n        # When this client only syncs to one other clients, but looses connectors,\n        # before syncing to the other clients, the online clients have different states.\n        # Since we do not want to perform regular syncs, this is a good alternative\n        if @is_synced\n          sendApplyHB = (m)=>\n            @send sender, m\n        else\n          sendApplyHB = (m)=>\n            @broadcast m\n\n        for o in hb\n          _hb.push o\n          if _hb.length > 10\n            sendApplyHB\n              sync_step: \"applyHB_\"\n              data: _hb\n            _hb = []\n\n        sendApplyHB\n          sync_step : \"applyHB\"\n          data: _hb\n\n        if res.send_again? and @perform_send_again\n          send_again = do (sv = data.state_vector)=>\n            ()=>\n              hb = @getHB(sv).hb\n              for o in hb\n                _hb.push o\n                if _hb.length > 10\n                  @send sender,\n                    sync_step: \"applyHB_\"\n                    data: _hb\n                  _hb = []\n              @send sender,\n                sync_step: \"applyHB\",\n                data: _hb\n                sent_again: \"true\"\n          setTimeout send_again, 3000\n      else if res.sync_step is \"applyHB\"\n        @applyHB(res.data, sender is @current_sync_target)\n\n        if (@syncMethod is \"syncAll\" or res.sent_again?) and (not @is_synced) and ((@current_sync_target is sender) or (not @current_sync_target?))\n          @connections[sender].is_synced = true\n          @findNewSyncTarget()\n\n      else if res.sync_step is \"applyHB_\"\n        @applyHB(res.data, sender is @current_sync_target)\n\n\n  # Currently, the HB encodes operations as JSON. For the moment I want to keep it\n  # that way. Maybe we support encoding in the HB as XML in the future, but for now I don't want\n  # too much overhead. Y is very likely to get changed a lot in the future\n  #\n  # Because we don't want to encode JSON as string (with character escaping, wich makes it pretty much unreadable)\n  # we encode the JSON as XML.\n  #\n  # When the HB support encoding as XML, the format should look pretty much like this.\n\n  # does not support primitive values as array elements\n  # expects an ltx (less than xml) object\n  parseMessageFromXml: (m)->\n    parse_array = (node)->\n      for n in node.children\n        if n.getAttribute(\"isArray\") is \"true\"\n          parse_array n\n        else\n          parse_object n\n\n    parse_object = (node)->\n      json = {}\n      for name, value  of node.attrs\n        int = parseInt(value)\n        if isNaN(int) or (\"\"+int) isnt value\n          json[name] = value\n        else\n          json[name] = int\n      for n in node.children\n        name = n.name\n        if n.getAttribute(\"isArray\") is \"true\"\n          json[name] = parse_array n\n        else\n          json[name] = parse_object n\n      json\n    parse_object m\n\n  # encode message in xml\n  # we use string because Strophe only accepts an \"xml-string\"..\n  # So {a:4,b:{c:5}} will look like\n  # <y a=\"4\">\n  #   <b c=\"5\"></b>\n  # </y>\n  # m - ltx element\n  # json - guess it ;)\n  #\n  encodeMessageToXml: (m, json)->\n    # attributes is optional\n    encode_object = (m, json)->\n      for name,value of json\n        if not value?\n          # nop\n        else if value.constructor is Object\n          encode_object m.c(name), value\n        else if value.constructor is Array\n          encode_array m.c(name), value\n        else\n          m.setAttribute(name,value)\n      m\n    encode_array = (m, array)->\n      m.setAttribute(\"isArray\",\"true\")\n      for e in array\n        if e.constructor is Object\n          encode_object m.c(\"array-element\"), e\n        else\n          encode_array m.c(\"array-element\"), e\n      m\n    if json.constructor is Object\n      encode_object m.c(\"y\",{xmlns:\"http://y.ninja/connector-stanza\"}), json\n    else if json.constructor is Array\n      encode_array m.c(\"y\",{xmlns:\"http://y.ninja/connector-stanza\"}), json\n    else\n      throw new Error \"I can't encode this json!\"\n\n  setIsBoundToY: ()->\n    @on_bound_to_y?()\n    delete @when_bound_to_y\n    @is_bound_to_y = true\n","\nwindow?.unprocessed_counter = 0 # del this\nwindow?.unprocessed_exec_counter = 0 # TODO\nwindow?.unprocessed_types = []\n\n#\n# @nodoc\n# The Engine handles how and in which order to execute operations and add operations to the HistoryBuffer.\n#\nclass Engine\n\n  #\n  # @param {HistoryBuffer} HB\n  # @param {Object} types list of available types\n  #\n  constructor: (@HB, @types)->\n    @unprocessed_ops = []\n\n  #\n  # Parses an operatio from the json format. It uses the specified parser in your OperationType module.\n  #\n  parseOperation: (json)->\n    type = @types[json.type]\n    if type?.parse?\n      type.parse json\n    else\n      throw new Error \"You forgot to specify a parser for type #{json.type}. The message is #{JSON.stringify json}.\"\n\n\n  #\n  # Apply a set of operations. E.g. the operations you received from another users HB._encode().\n  # @note You must not use this method when you already have ops in your HB!\n  ###\n  applyOpsBundle: (ops_json)->\n    ops = []\n    for o in ops_json\n      ops.push @parseOperation o\n    for o in ops\n      if not o.execute()\n        @unprocessed_ops.push o\n    @tryUnprocessed()\n  ###\n\n  #\n  # Same as applyOps but operations that are already in the HB are not applied.\n  # @see Engine.applyOps\n  #\n  applyOpsCheckDouble: (ops_json)->\n    for o in ops_json\n      if not @HB.getOperation(o.uid)?\n        @applyOp o\n\n  #\n  # Apply a set of operations. (Helper for using applyOp on Arrays)\n  # @see Engine.applyOp\n  applyOps: (ops_json)->\n    @applyOp ops_json\n\n  #\n  # Apply an operation that you received from another peer.\n  # TODO: make this more efficient!!\n  # - operations may only executed in order by creator, order them in object of arrays (key by creator)\n  # - you can probably make something like dependencies (creator1 waits for creator2)\n  applyOp: (op_json_array, fromHB = false)->\n    if op_json_array.constructor isnt Array\n      op_json_array = [op_json_array]\n    for op_json in op_json_array\n      if fromHB\n        op_json.fromHB = \"true\" # execute immediately, if\n      # $parse_and_execute will return false if $o_json was parsed and executed, otherwise the parsed operadion\n      o = @parseOperation op_json\n      o.parsed_from_json = op_json\n      if op_json.fromHB?\n        o.fromHB = op_json.fromHB\n      # @HB.addOperation o\n      if @HB.getOperation(o)?\n        # nop\n      else if ((not @HB.isExpectedOperation(o)) and (not o.fromHB?)) or (not o.execute())\n        @unprocessed_ops.push o\n        window?.unprocessed_types.push o.type # TODO: delete this\n    @tryUnprocessed()\n\n  #\n  # Call this method when you applied a new operation.\n  # It checks if operations that were previously not executable are now executable.\n  #\n  tryUnprocessed: ()->\n    while true\n      old_length = @unprocessed_ops.length\n      unprocessed = []\n      for op in @unprocessed_ops\n        if @HB.getOperation(op)?\n          # nop\n        else if (not @HB.isExpectedOperation(op) and (not op.fromHB?)) or (not op.execute())\n          unprocessed.push op\n      @unprocessed_ops = unprocessed\n      if @unprocessed_ops.length is old_length\n        break\n    if @unprocessed_ops.length isnt 0\n      @HB.invokeSync()\n\n\nmodule.exports = Engine\n\n\n\n\n\n\n\n\n\n\n\n\n","\n#\n# @nodoc\n# An object that holds all applied operations.\n#\n# @note The HistoryBuffer is commonly abbreviated to HB.\n#\nclass HistoryBuffer\n\n  #\n  # Creates an empty HB.\n  # @param {Object} user_id Creator of the HB.\n  #\n  constructor: (@user_id)->\n    @operation_counter = {}\n    @buffer = {}\n    @change_listeners = []\n    @garbage = [] # Will be cleaned on next call of garbageCollector\n    @trash = [] # Is deleted. Wait until it is not used anymore.\n    @performGarbageCollection = true\n    @garbageCollectTimeout = 30000\n    @reserved_identifier_counter = 0\n    setTimeout @emptyGarbage, @garbageCollectTimeout\n\n  # At the beginning (when the user id was not assigned yet),\n  # the operations are added to buffer._temp. When you finally get your user id,\n  # the operations are copies from buffer._temp to buffer[id]. Furthermore, when buffer[id] does already contain operations\n  # (because of a previous session), the uid.op_numbers of the operations have to be reassigned.\n  # This is what this function does. It adds them to buffer[id],\n  # and assigns them the correct uid.op_number and uid.creator\n  setUserId: (@user_id, state_vector)->\n    @buffer[@user_id] ?= []\n    buff = @buffer[@user_id]\n\n    # we assumed that we started with counter = 0.\n    # when we receive tha state_vector, and actually have\n    # counter = 10. Then we have to add 10 to every op_counter\n    counter_diff = state_vector[@user_id] or 0\n\n    if @buffer._temp?\n      for o_name,o of @buffer._temp\n        o.uid.creator = @user_id\n        o.uid.op_number += counter_diff\n        buff[o.uid.op_number] = o\n\n    @operation_counter[@user_id] = (@operation_counter._temp or 0) + counter_diff\n\n    delete @operation_counter._temp\n    delete @buffer._temp\n\n\n  emptyGarbage: ()=>\n    for o in @garbage\n      #if @getOperationCounter(o.uid.creator) > o.uid.op_number\n      o.cleanup?()\n\n    @garbage = @trash\n    @trash = []\n    if @garbageCollectTimeout isnt -1\n      @garbageCollectTimeoutId = setTimeout @emptyGarbage, @garbageCollectTimeout\n    undefined\n\n  #\n  # Get the user id with wich the History Buffer was initialized.\n  #\n  getUserId: ()->\n    @user_id\n\n  addToGarbageCollector: ()->\n    if @performGarbageCollection\n      for o in arguments\n        if o?\n          @garbage.push o\n\n  stopGarbageCollection: ()->\n    @performGarbageCollection = false\n    @setManualGarbageCollect()\n    @garbage = []\n    @trash = []\n\n  setManualGarbageCollect: ()->\n    @garbageCollectTimeout = -1\n    clearTimeout @garbageCollectTimeoutId\n    @garbageCollectTimeoutId = undefined\n\n  setGarbageCollectTimeout: (@garbageCollectTimeout)->\n\n  #\n  # I propose to use it in your Framework, to create something like a root element.\n  # An operation with this identifier is not propagated to other clients.\n  # This is why everybode must create the same operation with this uid.\n  #\n  getReservedUniqueIdentifier: ()->\n    {\n      creator : '_'\n      op_number : \"_#{@reserved_identifier_counter++}\"\n    }\n\n  #\n  # Get the operation counter that describes the current state of the document.\n  #\n  getOperationCounter: (user_id)->\n    if not user_id?\n      res = {}\n      for user,ctn of @operation_counter\n        res[user] = ctn\n      res\n    else\n      @operation_counter[user_id]\n\n  isExpectedOperation: (o)->\n    @operation_counter[o.uid.creator] ?= 0\n    o.uid.op_number <= @operation_counter[o.uid.creator]\n    true #TODO: !! this could break stuff. But I dunno why\n\n  #\n  # Encode this operation in such a way that it can be parsed by remote peers.\n  # TODO: Make this more efficient!\n  _encode: (state_vector={})->\n    json = []\n    unknown = (user, o_number)->\n      if (not user?) or (not o_number?)\n        throw new Error \"dah!\"\n      not state_vector[user]? or state_vector[user] <= o_number\n\n    for u_name,user of @buffer\n      # TODO next, if @state_vector[user] <= state_vector[user]\n      if u_name is \"_\"\n        continue\n      for o_number,o of user\n        if (not o.uid.noOperation?) and unknown(u_name, o_number)\n          # its necessary to send it, and not known in state_vector\n          o_json = o._encode()\n          if o.next_cl? # applies for all ops but the most right delimiter!\n            # search for the next _known_ operation. (When state_vector is {} then this is the Delimiter)\n            o_next = o.next_cl\n            while o_next.next_cl? and unknown(o_next.uid.creator, o_next.uid.op_number)\n              o_next = o_next.next_cl\n            o_json.next = o_next.getUid()\n          else if o.prev_cl? # most right delimiter only!\n            # same as the above with prev.\n            o_prev = o.prev_cl\n            while o_prev.prev_cl? and unknown(o_prev.uid.creator, o_prev.uid.op_number)\n              o_prev = o_prev.prev_cl\n            o_json.prev = o_prev.getUid()\n          json.push o_json\n\n    json\n\n  #\n  # Get the number of operations that were created by a user.\n  # Accordingly you will get the next operation number that is expected from that user.\n  # This will increment the operation counter.\n  #\n  getNextOperationIdentifier: (user_id)->\n    if not user_id?\n      user_id = @user_id\n    if not @operation_counter[user_id]?\n      @operation_counter[user_id] = 0\n    uid =\n      'creator' : user_id\n      'op_number' : @operation_counter[user_id]\n    @operation_counter[user_id]++\n    uid\n\n  #\n  # Retrieve an operation from a unique id.\n  #\n  # when uid has a \"sub\" property, the value of it will be applied\n  # on the operations retrieveSub method (which must! be defined)\n  #\n  getOperation: (uid)->\n    if uid.uid?\n      uid = uid.uid\n    o = @buffer[uid.creator]?[uid.op_number]\n    if uid.sub? and o?\n      o.retrieveSub uid.sub\n    else\n      o\n\n  #\n  # Add an operation to the HB. Note that this will not link it against\n  # other operations (it wont executed)\n  #\n  addOperation: (o)->\n    if not @buffer[o.uid.creator]?\n      @buffer[o.uid.creator] = {}\n    if @buffer[o.uid.creator][o.uid.op_number]?\n      throw new Error \"You must not overwrite operations!\"\n    if (o.uid.op_number.constructor isnt String) and (not @isExpectedOperation(o)) and (not o.fromHB?) # you already do this in the engine, so delete it here!\n      throw new Error \"this operation was not expected!\"\n    @addToCounter(o)\n    @buffer[o.uid.creator][o.uid.op_number] = o\n    o\n\n  removeOperation: (o)->\n    delete @buffer[o.uid.creator]?[o.uid.op_number]\n\n  # When the HB determines inconsistencies, then the invokeSync\n  # handler wil be called, which should somehow invoke the sync with another collaborator.\n  # The parameter of the sync handler is the user_id with wich an inconsistency was determined\n  setInvokeSyncHandler: (f)->\n    @invokeSync = f\n\n  # empty per default # TODO: do i need this?\n  invokeSync: ()->\n\n  # after you received the HB of another user (in the sync process),\n  # you renew your own state_vector to the state_vector of the other user\n  renewStateVector: (state_vector)->\n    for user,state of state_vector\n      if ((not @operation_counter[user]?) or (@operation_counter[user] < state_vector[user])) and state_vector[user]?\n        @operation_counter[user] = state_vector[user]\n\n  #\n  # Increment the operation_counter that defines the current state of the Engine.\n  #\n  addToCounter: (o)->\n    @operation_counter[o.uid.creator] ?= 0\n    # TODO: check if operations are send in order\n    if o.uid.op_number is @operation_counter[o.uid.creator]\n      @operation_counter[o.uid.creator]++\n    while @buffer[o.uid.creator][@operation_counter[o.uid.creator]]?\n      @operation_counter[o.uid.creator]++\n    undefined\n\nmodule.exports = HistoryBuffer\n","\nclass YObject\n\n  constructor: (@_object = {})->\n    if @_object.constructor is Object\n      for name, val of @_object\n        if val.constructor is Object\n          @_object[name] = new YObject(val)\n    else\n      throw new Error \"Y.Object accepts Json Objects only\"\n\n  _name: \"Object\"\n\n  _getModel: (types, ops)->\n    if not @_model?\n      @_model = new ops.MapManager(@).execute()\n      for n,o of @_object\n        @_model.val n, o\n    delete @_object\n    @_model\n\n  _setModel: (@_model)->\n    delete @_object\n\n  observe: (f)->\n    @_model.observe f\n    @\n\n  unobserve: (f)->\n    @_model.unobserve f\n    @\n\n  #\n  # @overload val()\n  #   Get this as a Json object.\n  #   @return [Json]\n  #\n  # @overload val(name)\n  #   Get value of a property.\n  #   @param {String} name Name of the object property.\n  #   @return [*] Depends on the value of the property.\n  #\n  # @overload val(name, content)\n  #   Set a new property.\n  #   @param {String} name Name of the object property.\n  #   @param {Object|String} content Content of the object property.\n  #   @return [Object Type] This object. (supports chaining)\n  #\n  val: (name, content)->\n    if @_model?\n      @_model.val.apply @_model, arguments\n    else\n      if content?\n        @_object[name] = content\n      else if name?\n        @_object[name]\n      else\n        res = {}\n        for n,v of @_object\n          res[n] = v\n        res\n\n  delete: (name)->\n    @_model.delete(name)\n    @\n\nif window?\n  if window.Y?\n    window.Y.Object = YObject\n  else\n    throw new Error \"You must first import Y!\"\n\nif module?\n  module.exports = YObject\n","module.exports = ()->\n  # @see Engine.parse\n  ops = {}\n  execution_listener = []\n\n  #\n  # @private\n  # @abstract\n  # @nodoc\n  # A generic interface to ops.\n  #\n  # An operation has the following methods:\n  # * _encode: encodes an operation (needed only if instance of this operation is sent).\n  # * execute: execute the effects of this operations. Good examples are Insert-type and AddName-type\n  # * val: in the case that the operation holds a value\n  #\n  # Furthermore an encodable operation has a parser. We extend the parser object in order to parse encoded operations.\n  #\n  class ops.Operation\n\n    #\n    # @param {Object} uid A unique identifier.\n    # If uid is undefined, a new uid will be created before at the end of the execution sequence\n    #\n    constructor: (custom_type, uid, content, content_operations)->\n      if custom_type?\n        @custom_type = custom_type\n      @is_deleted = false\n      @garbage_collected = false\n      @event_listeners = [] # TODO: rename to observers or sth like that\n      if uid?\n        @uid = uid\n\n      # see encode to see, why we are doing it this way\n      if content is undefined\n        # nop\n      else if content? and content.creator?\n        @saveOperation 'content', content\n      else\n        @content = content\n      if content_operations?\n        @content_operations = {}\n        for name, op of content_operations\n          @saveOperation name, op, 'content_operations'\n\n    type: \"Operation\"\n\n    getContent: (name)->\n      if @content?\n        if @content.getCustomType?\n          @content.getCustomType()\n        else if @content.constructor is Object\n          if name?\n            if @content[name]?\n              @content[name]\n            else\n              @content_operations[name].getCustomType()\n          else\n            content = {}\n            for n,v of @content\n              content[n] = v\n            if @content_operations?\n              for n,v of @content_operations\n                v = v.getCustomType()\n                content[n] = v\n            content\n        else\n          @content\n      else\n        @content\n\n    retrieveSub: ()->\n      throw new Error \"sub properties are not enable on this operation type!\"\n\n    #\n    # Add an event listener. It depends on the operation which events are supported.\n    # @param {Function} f f is executed in case the event fires.\n    #\n    observe: (f)->\n      @event_listeners.push f\n\n    #\n    # Deletes function from the observer list\n    # @see Operation.observe\n    #\n    # @overload unobserve(event, f)\n    #   @param f     {Function} The function that you want to delete\n    unobserve: (f)->\n      @event_listeners = @event_listeners.filter (g)->\n        f isnt g\n\n    #\n    # Deletes all subscribed event listeners.\n    # This should be called, e.g. after this has been replaced.\n    # (Then only one replace event should fire. )\n    # This is also called in the cleanup method.\n    deleteAllObservers: ()->\n      @event_listeners = []\n\n    delete: ()->\n      (new ops.Delete undefined, @).execute()\n      null\n\n    #\n    # Fire an event.\n    # TODO: Do something with timeouts. You don't want this to fire for every operation (e.g. insert).\n    # TODO: do you need callEvent+forwardEvent? Only one suffices probably\n    callEvent: ()->\n      if @custom_type?\n        callon = @getCustomType()\n      else\n        callon = @\n      @forwardEvent callon, arguments...\n\n    #\n    # Fire an event and specify in which context the listener is called (set 'this').\n    # TODO: do you need this ?\n    forwardEvent: (op, args...)->\n      for f in @event_listeners\n        f.call op, args...\n\n    isDeleted: ()->\n      @is_deleted\n\n    applyDelete: (garbagecollect = true)->\n      if not @garbage_collected\n        #console.log \"applyDelete: #{@type}\"\n        @is_deleted = true\n        if garbagecollect\n          @garbage_collected = true\n          @HB.addToGarbageCollector @\n\n    cleanup: ()->\n      #console.log \"cleanup: #{@type}\"\n      @HB.removeOperation @\n      @deleteAllObservers()\n\n    #\n    # Set the parent of this operation.\n    #\n    setParent: (@parent)->\n\n    #\n    # Get the parent of this operation.\n    #\n    getParent: ()->\n      @parent\n\n    #\n    # Computes a unique identifier (uid) that identifies this operation.\n    #\n    getUid: ()->\n      if not @uid.noOperation?\n        @uid\n      else\n        if @uid.alt? # could be (safely) undefined\n          map_uid = @uid.alt.cloneUid()\n          map_uid.sub = @uid.sub\n          map_uid\n        else\n          undefined\n\n    cloneUid: ()->\n      uid = {}\n      for n,v of @getUid()\n        uid[n] = v\n      uid\n\n    #\n    # @private\n    # If not already done, set the uid\n    # Add this to the HB\n    # Notify the all the listeners.\n    #\n    execute: ()->\n      if @validateSavedOperations()\n        @is_executed = true\n        if not @uid?\n          # When this operation was created without a uid, then set it here.\n          # There is only one other place, where this can be done - before an Insertion\n          # is executed (because we need the creator_id)\n          @uid = @HB.getNextOperationIdentifier()\n        if not @uid.noOperation?\n          @HB.addOperation @\n          for l in execution_listener\n            l @_encode()\n        @\n      else\n        false\n\n    #\n    # @private\n    # Operations may depend on other operations (linked lists, etc.).\n    # The saveOperation and validateSavedOperations methods provide\n    # an easy way to refer to these operations via an uid or object reference.\n    #\n    # For example: We can create a new Delete operation that deletes the operation $o like this\n    #     - var d = new Delete(uid, $o);   or\n    #     - var d = new Delete(uid, $o.getUid());\n    # Either way we want to access $o via d.deletes. In the second case validateSavedOperations must be called first.\n    #\n    # @overload saveOperation(name, op_uid)\n    #   @param {String} name The name of the operation. After validating (with validateSavedOperations) the instantiated operation will be accessible via this[name].\n    #   @param {Object} op_uid A uid that refers to an operation\n    # @overload saveOperation(name, op)\n    #   @param {String} name The name of the operation. After calling this function op is accessible via this[name].\n    #   @param {Operation} op An Operation object\n    #\n    saveOperation: (name, op, base = \"this\")->\n      if op? and op._getModel?\n        op = op._getModel(@custom_types, @operations)\n      #\n      # Every instance of $Operation must have an $execute function.\n      # We use duck-typing to check if op is instantiated since there\n      # could exist multiple classes of $Operation\n      #\n      if not op?\n        # nop\n      else if op.execute? or not (op.op_number? and op.creator?)\n        # is instantiated, or op is string. Currently \"Delimiter\" is saved as string\n        # (in combination with @parent you can retrieve the delimiter..)\n        if base is \"this\"\n          @[name] = op\n        else\n          dest = @[base]\n          paths = name.split(\"/\")\n          last_path = paths.pop()\n          for path in paths\n            dest = dest[path]\n          dest[last_path] = op\n      else\n        # not initialized. Do it when calling $validateSavedOperations()\n        @unchecked ?= {}\n        @unchecked[base] ?= {}\n        @unchecked[base][name] = op\n\n    #\n    # @private\n    # After calling this function all not instantiated operations will be accessible.\n    # @see Operation.saveOperation\n    #\n    # @return [Boolean] Whether it was possible to instantiate all operations.\n    #\n    validateSavedOperations: ()->\n      uninstantiated = {}\n      success = true\n      for base_name, base of @unchecked\n        for name, op_uid of base\n          op = @HB.getOperation op_uid\n          if op\n            if base_name is \"this\"\n              @[name] = op\n            else\n              dest = @[base_name]\n              paths = name.split(\"/\")\n              last_path = paths.pop()\n              for path in paths\n                dest = dest[path]\n              dest[last_path] = op\n          else\n            uninstantiated[base_name] ?= {}\n            uninstantiated[base_name][name] = op_uid\n            success = false\n      if not success\n        @unchecked = uninstantiated\n        return false\n      else\n        delete @unchecked\n        return @\n\n    getCustomType: ()->\n      if not @custom_type?\n        # throw new Error \"This operation was not initialized with a custom type\"\n        @\n      else\n        if @custom_type.constructor is String\n          # has not been initialized yet (only the name is specified)\n          Type = @custom_types\n          for t in @custom_type.split(\".\")\n            Type = Type[t]\n          @custom_type = new Type()\n          @custom_type._setModel @\n        @custom_type\n\n    #\n    # @private\n    # Encode this operation in such a way that it can be parsed by remote peers.\n    #\n    _encode: (json = {})->\n      json.type = @type\n      json.uid = @getUid()\n      if @custom_type?\n        if @custom_type.constructor is String\n          json.custom_type = @custom_type\n        else\n          json.custom_type = @custom_type._name\n\n      if @content?.getUid?\n        json.content = @content.getUid()\n      else\n        json.content = @content\n      if @content_operations?\n        operations = {}\n        for n,o of @content_operations\n          if o._getModel?\n            o = o._getModel(@custom_types, @operations)\n          operations[n] = o.getUid()\n        json.content_operations = operations\n      json\n\n  #\n  # @nodoc\n  # A simple Delete-type operation that deletes an operation.\n  #\n  class ops.Delete extends ops.Operation\n\n    #\n    # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n    # @param {Object} deletes UID or reference of the operation that this to be deleted.\n    #\n    constructor: (custom_type, uid, deletes)->\n      @saveOperation 'deletes', deletes\n      super custom_type, uid\n\n    type: \"Delete\"\n\n    #\n    # @private\n    # Convert all relevant information of this operation to the json-format.\n    # This result can be sent to other clients.\n    #\n    _encode: ()->\n      {\n        'type': \"Delete\"\n        'uid': @getUid()\n        'deletes': @deletes.getUid()\n      }\n\n    #\n    # @private\n    # Apply the deletion.\n    #\n    execute: ()->\n      if @validateSavedOperations()\n        res = super\n        if res\n          @deletes.applyDelete @\n        res\n      else\n        false\n\n  #\n  # Define how to parse Delete operations.\n  #\n  ops.Delete.parse = (o)->\n    {\n      'uid' : uid\n      'deletes': deletes_uid\n    } = o\n    new this(null, uid, deletes_uid)\n\n  #\n  # @nodoc\n  # A simple insert-type operation.\n  #\n  # An insert operation is always positioned between two other insert operations.\n  # Internally this is realized as associative lists, whereby each insert operation has a predecessor and a successor.\n  # For the sake of efficiency we maintain two lists:\n  #   - The short-list (abbrev. sl) maintains only the operations that are not deleted (unimplemented, good idea?)\n  #   - The complete-list (abbrev. cl) maintains all operations\n  #\n  class ops.Insert extends ops.Operation\n\n    #\n    # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n    # @param {Operation} prev_cl The predecessor of this operation in the complete-list (cl)\n    # @param {Operation} next_cl The successor of this operation in the complete-list (cl)\n    #\n    constructor: (custom_type, content, content_operations, parent, uid, prev_cl, next_cl, origin)->\n      @saveOperation 'parent', parent\n      @saveOperation 'prev_cl', prev_cl\n      @saveOperation 'next_cl', next_cl\n      if origin?\n        @saveOperation 'origin', origin\n      else\n        @saveOperation 'origin', prev_cl\n      super custom_type, uid, content, content_operations\n\n    type: \"Insert\"\n\n    val: ()->\n      @getContent()\n\n    getNext: (i=1)->\n      n = @\n      while i > 0 and n.next_cl?\n        n = n.next_cl\n        if not n.is_deleted\n          i--\n      if n.is_deleted\n        null\n      n\n\n    getPrev: (i=1)->\n      n = @\n      while i > 0 and n.prev_cl?\n        n = n.prev_cl\n        if not n.is_deleted\n          i--\n      if n.is_deleted\n        null\n      else\n        n\n\n    #\n    # set content to null and other stuff\n    # @private\n    #\n    applyDelete: (o)->\n      @deleted_by ?= []\n      callLater = false\n      if @parent? and not @is_deleted and o? # o? : if not o?, then the delimiter deleted this Insertion. Furthermore, it would be wrong to call it. TODO: make this more expressive and save\n        # call iff wasn't deleted earlyer\n        callLater = true\n      if o?\n        @deleted_by.push o\n      garbagecollect = false\n      if @next_cl.isDeleted()\n        garbagecollect = true\n      super garbagecollect\n      if callLater\n        @parent.callOperationSpecificDeleteEvents(this, o)\n      if @prev_cl? and @prev_cl.isDeleted()\n        # garbage collect prev_cl\n        @prev_cl.applyDelete()\n\n    cleanup: ()->\n      if @next_cl.isDeleted()\n        # delete all ops that delete this insertion\n        for d in @deleted_by\n          d.cleanup()\n\n        # throw new Error \"right is not deleted. inconsistency!, wrararar\"\n        # change origin references to the right\n        o = @next_cl\n        while o.type isnt \"Delimiter\"\n          if o.origin is @\n            o.origin = @prev_cl\n          o = o.next_cl\n        # reconnect left/right\n        @prev_cl.next_cl = @next_cl\n        @next_cl.prev_cl = @prev_cl\n\n        # delete content\n        # - we must not do this in applyDelete, because this would lead to inconsistencies\n        # (e.g. the following operation order must be invertible :\n        #   Insert refers to content, then the content is deleted)\n        # Therefore, we have to do this in the cleanup\n        # * NODE: We never delete Insertions!\n        if @content instanceof ops.Operation and not (@content instanceof ops.Insert)\n          @content.referenced_by--\n          if @content.referenced_by <= 0 and not @content.is_deleted\n            @content.applyDelete()\n        delete @content\n        super\n      # else\n      #   Someone inserted something in the meantime.\n      #   Remember: this can only be garbage collected when next_cl is deleted\n\n    #\n    # @private\n    # The amount of positions that $this operation was moved to the right.\n    #\n    getDistanceToOrigin: ()->\n      d = 0\n      o = @prev_cl\n      while true\n        if @origin is o\n          break\n        d++\n        o = o.prev_cl\n      d\n\n    #\n    # @private\n    # Include this operation in the associative lists.\n    execute: ()->\n      if not @validateSavedOperations()\n        return false\n      else\n        if @content instanceof ops.Operation\n          @content.insert_parent = @ # TODO: this is probably not necessary and only nice for debugging\n          @content.referenced_by ?= 0\n          @content.referenced_by++\n        if @parent?\n          if not @prev_cl?\n            @prev_cl = @parent.beginning\n          if not @origin?\n            @origin = @prev_cl\n          else if @origin is \"Delimiter\"\n            @origin = @parent.beginning\n          if not @next_cl?\n            @next_cl = @parent.end\n        if @prev_cl?\n          distance_to_origin = @getDistanceToOrigin() # most cases: 0\n          o = @prev_cl.next_cl\n          i = distance_to_origin # loop counter\n\n          # $this has to find a unique position between origin and the next known character\n          # case 1: $origin equals $o.origin: the $creator parameter decides if left or right\n          #         let $OL= [o1,o2,o3,o4], whereby $this is to be inserted between o1 and o4\n          #         o2,o3 and o4 origin is 1 (the position of o2)\n          #         there is the case that $this.creator < o2.creator, but o3.creator < $this.creator\n          #         then o2 knows o3. Since on another client $OL could be [o1,o3,o4] the problem is complex\n          #         therefore $this would be always to the right of o3\n          # case 2: $origin < $o.origin\n          #         if current $this insert_position > $o origin: $this ins\n          #         else $insert_position will not change\n          #         (maybe we encounter case 1 later, then this will be to the right of $o)\n          # case 3: $origin > $o.origin\n          #         $this insert_position is to the left of $o (forever!)\n          while true\n            if o isnt @next_cl\n              # $o happened concurrently\n              if o.getDistanceToOrigin() is i\n                # case 1\n                if o.uid.creator < @uid.creator\n                  @prev_cl = o\n                  distance_to_origin = i + 1\n                else\n                  # nop\n              else if o.getDistanceToOrigin() < i\n                # case 2\n                if i - distance_to_origin <= o.getDistanceToOrigin()\n                  @prev_cl = o\n                  distance_to_origin = i + 1\n                else\n                  #nop\n              else\n                # case 3\n                break\n              i++\n              o = o.next_cl\n            else\n              # $this knows that $o exists,\n              break\n          # now reconnect everything\n          @next_cl = @prev_cl.next_cl\n          @prev_cl.next_cl = @\n          @next_cl.prev_cl = @\n\n        @setParent @prev_cl.getParent() # do Insertions always have a parent?\n        super # notify the execution_listeners\n        @parent.callOperationSpecificInsertEvents(this)\n        @\n\n    #\n    # Compute the position of this operation.\n    #\n    getPosition: ()->\n      position = 0\n      prev = @prev_cl\n      while true\n        if prev instanceof ops.Delimiter\n          break\n        if not prev.isDeleted()\n          position++\n        prev = prev.prev_cl\n      position\n\n    #\n    # Convert all relevant information of this operation to the json-format.\n    # This result can be send to other clients.\n    #\n    _encode: (json = {})->\n      json.prev = @prev_cl.getUid()\n      json.next = @next_cl.getUid()\n\n      if @origin.type is \"Delimiter\"\n        json.origin = \"Delimiter\"\n      else if @origin isnt @prev_cl\n        json.origin = @origin.getUid()\n\n      # if not (json.prev? and json.next?)\n      json.parent = @parent.getUid()\n\n      super json\n\n  ops.Insert.parse = (json)->\n    {\n      'content' : content\n      'content_operations' : content_operations\n      'uid' : uid\n      'prev': prev\n      'next': next\n      'origin' : origin\n      'parent' : parent\n    } = json\n    new this null, content, content_operations, parent, uid, prev, next, origin\n\n  #\n  # @nodoc\n  # A delimiter is placed at the end and at the beginning of the associative lists.\n  # This is necessary in order to have a beginning and an end even if the content\n  # of the Engine is empty.\n  #\n  class ops.Delimiter extends ops.Operation\n    #\n    # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n    # @param {Operation} prev_cl The predecessor of this operation in the complete-list (cl)\n    # @param {Operation} next_cl The successor of this operation in the complete-list (cl)\n    #\n    constructor: (prev_cl, next_cl, origin)->\n      @saveOperation 'prev_cl', prev_cl\n      @saveOperation 'next_cl', next_cl\n      @saveOperation 'origin', prev_cl\n      super null, {noOperation: true}\n\n    type: \"Delimiter\"\n\n    applyDelete: ()->\n      super()\n      o = @prev_cl\n      while o?\n        o.applyDelete()\n        o = o.prev_cl\n      undefined\n\n    cleanup: ()->\n      super()\n\n    #\n    # @private\n    #\n    execute: ()->\n      if @unchecked?['next_cl']?\n        super\n      else if @unchecked?['prev_cl']\n        if @validateSavedOperations()\n          if @prev_cl.next_cl?\n            throw new Error \"Probably duplicated operations\"\n          @prev_cl.next_cl = @\n          super\n        else\n          false\n      else if @prev_cl? and not @prev_cl.next_cl?\n        delete @prev_cl.unchecked.next_cl\n        @prev_cl.next_cl = @\n        super\n      else if @prev_cl? or @next_cl? or true # TODO: are you sure? This can happen right?\n        super\n      #else\n      #  throw new Error \"Delimiter is unsufficient defined!\"\n\n    #\n    # @private\n    #\n    _encode: ()->\n      {\n        'type' : @type\n        'uid' : @getUid()\n        'prev' : @prev_cl?.getUid()\n        'next' : @next_cl?.getUid()\n      }\n\n  ops.Delimiter.parse = (json)->\n    {\n    'uid' : uid\n    'prev' : prev\n    'next' : next\n    } = json\n    new this(uid, prev, next)\n\n  # This is what this module exports after initializing it with the HistoryBuffer\n  {\n    'operations' : ops\n    'execution_listener' : execution_listener\n  }\n","basic_ops_uninitialized = require \"./Basic\"\n\nmodule.exports = ()->\n  basic_ops = basic_ops_uninitialized()\n  ops = basic_ops.operations\n\n  #\n  # @nodoc\n  # Manages map like objects. E.g. Json-Type and XML attributes.\n  #\n  class ops.MapManager extends ops.Operation\n\n    #\n    # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n    #\n    constructor: (custom_type, uid, content, content_operations)->\n      @_map = {}\n      super custom_type, uid, content, content_operations\n\n    type: \"MapManager\"\n\n    applyDelete: ()->\n      for name,p of @_map\n        p.applyDelete()\n      super()\n\n    cleanup: ()->\n      super()\n\n    map: (f)->\n      for n,v of @_map\n        f(n,v)\n      undefined\n\n    #\n    # @see JsonOperations.val\n    #\n    val: (name, content)->\n      if arguments.length > 1\n        if content? and content._getModel?\n          rep = content._getModel(@custom_types, @operations)\n        else\n          rep = content\n        @retrieveSub(name).replace rep\n        @getCustomType()\n      else if name?\n        prop = @_map[name]\n        if prop? and not prop.isContentDeleted()\n          res = prop.val()\n          if res instanceof ops.Operation\n            res.getCustomType()\n          else\n            res\n        else\n          undefined\n      else\n        result = {}\n        for name,o of @_map\n          if not o.isContentDeleted()\n            result[name] = o.val()\n        result\n\n    delete: (name)->\n      @_map[name]?.deleteContent()\n      @\n\n    retrieveSub: (property_name)->\n      if not @_map[property_name]?\n        event_properties =\n          name: property_name\n        event_this = @\n        rm_uid =\n          noOperation: true\n          sub: property_name\n          alt: @\n        rm = new ops.ReplaceManager null, event_properties, event_this, rm_uid # this operation shall not be saved in the HB\n        @_map[property_name] = rm\n        rm.setParent @, property_name\n        rm.execute()\n      @_map[property_name]\n\n  ops.MapManager.parse = (json)->\n    {\n      'uid' : uid\n      'custom_type' : custom_type\n      'content' : content\n      'content_operations' : content_operations\n    } = json\n    new this(custom_type, uid, content, content_operations)\n\n\n\n  #\n  # @nodoc\n  # Manages a list of Insert-type operations.\n  #\n  class ops.ListManager extends ops.Operation\n\n    #\n    # A ListManager maintains a non-empty list that has a beginning and an end (both Delimiters!)\n    # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n    # @param {Delimiter} beginning Reference or Object.\n    # @param {Delimiter} end Reference or Object.\n    constructor: (custom_type, uid, content, content_operations)->\n      @beginning = new ops.Delimiter undefined, undefined\n      @end =       new ops.Delimiter @beginning, undefined\n      @beginning.next_cl = @end\n      @beginning.execute()\n      @end.execute()\n      super custom_type, uid, content, content_operations\n\n    type: \"ListManager\"\n\n\n    applyDelete: ()->\n      o = @beginning\n      while o?\n        o.applyDelete()\n        o = o.next_cl\n      super()\n\n    cleanup: ()->\n      super()\n\n\n    toJson: (transform_to_value = false)->\n      val = @val()\n      for i, o in val\n        if o instanceof ops.Object\n          o.toJson(transform_to_value)\n        else if o instanceof ops.ListManager\n          o.toJson(transform_to_value)\n        else if transform_to_value and o instanceof ops.Operation\n          o.val()\n        else\n          o\n\n    #\n    # @private\n    # @see Operation.execute\n    #\n    execute: ()->\n      if @validateSavedOperations()\n        @beginning.setParent @\n        @end.setParent @\n        super\n      else\n        false\n\n    # Get the element previous to the delemiter at the end\n    getLastOperation: ()->\n      @end.prev_cl\n\n    # similar to the above\n    getFirstOperation: ()->\n      @beginning.next_cl\n\n    # Transforms the the list to an array\n    # Doesn't return left-right delimiter.\n    toArray: ()->\n      o = @beginning.next_cl\n      result = []\n      while o isnt @end\n        if not o.is_deleted\n          result.push o.val()\n        o = o.next_cl\n      result\n\n    map: (f)->\n      o = @beginning.next_cl\n      result = []\n      while o isnt @end\n        if not o.is_deleted\n          result.push f(o)\n        o = o.next_cl\n      result\n\n    fold: (init, f)->\n      o = @beginning.next_cl\n      while o isnt @end\n        if not o.is_deleted\n          init = f(init, o)\n        o = o.next_cl\n      init\n\n    val: (pos)->\n      if pos?\n        o = @getOperationByPosition(pos+1)\n        if not (o instanceof ops.Delimiter)\n          o.val()\n        else\n          throw new Error \"this position does not exist\"\n      else\n        @toArray()\n\n    ref: (pos)->\n      if pos?\n        o = @getOperationByPosition(pos+1)\n        if not (o instanceof ops.Delimiter)\n          o\n        else\n          null\n          # throw new Error \"this position does not exist\"\n      else\n        throw new Error \"you must specify a position parameter\"\n\n    #\n    # Retrieves the x-th not deleted element.\n    # e.g. \"abc\" : the 1th character is \"a\"\n    # the 0th character is the left Delimiter\n    #\n    getOperationByPosition: (position)->\n      o = @beginning\n      while true\n        # find the i-th op\n        if o instanceof ops.Delimiter and o.prev_cl?\n          # the user or you gave a position parameter that is to big\n          # for the current array. Therefore we reach a Delimiter.\n          # Then, we'll just return the last character.\n          o = o.prev_cl\n          while o.isDeleted() and o.prev_cl?\n            o = o.prev_cl\n          break\n        if position <= 0 and not o.isDeleted()\n          break\n\n        o = o.next_cl\n        if not o.isDeleted()\n          position -= 1\n      o\n\n    push: (content)->\n      @insertAfter @end.prev_cl, [content]\n\n    insertAfter: (left, contents)->\n      right = left.next_cl\n      while right.isDeleted()\n        right = right.next_cl # find the first character to the right, that is not deleted. In the case that position is 0, its the Delimiter.\n      left = right.prev_cl\n\n      # TODO: always expect an array as content. Then you can combine this with the other option (else)\n      if contents instanceof ops.Operation\n        (new ops.Insert null, content, null, undefined, undefined, left, right).execute()\n      else\n        for c in contents\n          if c? and c._name? and c._getModel?\n            c = c._getModel(@custom_types, @operations)\n          tmp = (new ops.Insert null, c, null, undefined, undefined, left, right).execute()\n          left = tmp\n      @\n\n    #\n    # Inserts an array of content into this list.\n    # @Note: This expects an array as content!\n    #\n    # @return {ListManager Type} This String object.\n    #\n    insert: (position, contents)->\n      ith = @getOperationByPosition position\n      # the (i-1)th character. e.g. \"abc\" the 1th character is \"a\"\n      # the 0th character is the left Delimiter\n      @insertAfter ith, contents\n\n    #\n    # Deletes a part of the word.\n    #\n    # @return {ListManager Type} This String object\n    #\n    delete: (position, length = 1)->\n      o = @getOperationByPosition(position+1) # position 0 in this case is the deletion of the first character\n\n      delete_ops = []\n      for i in [0...length]\n        if o instanceof ops.Delimiter\n          break\n        d = (new ops.Delete null, undefined, o).execute()\n        o = o.next_cl\n        while (not (o instanceof ops.Delimiter)) and o.isDeleted()\n          o = o.next_cl\n        delete_ops.push d._encode()\n      @\n\n\n    callOperationSpecificInsertEvents: (op)->\n      getContentType = (content)->\n        if content instanceof ops.Operation\n          content.getCustomType()\n        else\n          content\n      @callEvent [\n        type: \"insert\"\n        reference: op\n        position: op.getPosition()\n        object: @getCustomType()\n        changedBy: op.uid.creator\n        value: getContentType op.val()\n      ]\n\n    callOperationSpecificDeleteEvents: (op, del_op)->\n      @callEvent [\n        type: \"delete\"\n        reference: op\n        position: op.getPosition()\n        object: @getCustomType() # TODO: You can combine getPosition + getParent in a more efficient manner! (only left Delimiter will hold @parent)\n        length: 1\n        changedBy: del_op.uid.creator\n        oldValue: op.val()\n      ]\n\n  ops.ListManager.parse = (json)->\n    {\n      'uid' : uid\n      'custom_type': custom_type\n      'content' : content\n      'content_operations' : content_operations\n    } = json\n    new this(custom_type, uid, content, content_operations)\n\n  class ops.Composition extends ops.ListManager\n\n    constructor: (custom_type, @_composition_value, composition_value_operations, uid, tmp_composition_ref)->\n      # we can't use @seveOperation 'composition_ref', tmp_composition_ref here,\n      # because then there is a \"loop\" (insertion refers to parent, refers to insertion..)\n      # This is why we have to check in @callOperationSpecificInsertEvents until we find it\n      super custom_type, uid\n      if tmp_composition_ref?\n        @tmp_composition_ref = tmp_composition_ref\n      else\n        @composition_ref = @end.prev_cl\n      if composition_value_operations?\n        @composition_value_operations = {}\n        for n,o of composition_value_operations\n          @saveOperation n, o, '_composition_value'\n\n    type: \"Composition\"\n\n    #\n    # @private\n    # @see Operation.execute\n    #\n    execute: ()->\n      if @validateSavedOperations()\n        @getCustomType()._setCompositionValue @_composition_value\n        delete @_composition_value\n        # check if tmp_composition_ref already exists\n        if @tmp_composition_ref\n          composition_ref = @HB.getOperation @tmp_composition_ref\n          if composition_ref?\n            delete @tmp_composition_ref\n            @composition_ref = composition_ref\n        super\n      else\n        false\n\n    #\n    # This is called, when the Insert-operation was successfully executed.\n    #\n    callOperationSpecificInsertEvents: (op)->\n      if @tmp_composition_ref?\n        if op.uid.creator is @tmp_composition_ref.creator and op.uid.op_number is @tmp_composition_ref.op_number\n          @composition_ref = op\n          delete @tmp_composition_ref\n          op = op.next_cl\n          if op is @end\n            return\n        else\n          return\n\n      o = @end.prev_cl\n      while o isnt op\n        @getCustomType()._unapply o.undo_delta\n        o = o.prev_cl\n      while o isnt @end\n        o.undo_delta = @getCustomType()._apply o.val()\n        o = o.next_cl\n      @composition_ref = @end.prev_cl\n\n      @callEvent [\n        type: \"update\"\n        changedBy: op.uid.creator\n        newValue: @val()\n      ]\n\n    callOperationSpecificDeleteEvents: (op, del_op)->\n      return\n\n    #\n    # Create a new Delta\n    # - inserts new Content at the end of the list\n    # - updates the composition_value\n    # - updates the composition_ref\n    #\n    # @param delta The delta that is applied to the composition_value\n    #\n    applyDelta: (delta, operations)->\n      (new ops.Insert null, delta, operations, @, null, @end.prev_cl, @end).execute()\n      undefined\n\n    #\n    # Encode this operation in such a way that it can be parsed by remote peers.\n    #\n    _encode: (json = {})->\n      custom = @getCustomType()._getCompositionValue()\n      json.composition_value = custom.composition_value\n      if custom.composition_value_operations?\n        json.composition_value_operations = {}\n        for n,o of custom.composition_value_operations\n          json.composition_value_operations[n] = o.getUid()\n      if @composition_ref?\n        json.composition_ref = @composition_ref.getUid()\n      else\n        json.composition_ref = @tmp_composition_ref\n      super json\n\n  ops.Composition.parse = (json)->\n    {\n      'uid' : uid\n      'custom_type': custom_type\n      'composition_value' : composition_value\n      'composition_value_operations' : composition_value_operations\n      'composition_ref' : composition_ref\n    } = json\n    new this(custom_type, composition_value, composition_value_operations, uid, composition_ref)\n\n\n  #\n  # @nodoc\n  # Adds support for replace. The ReplaceManager manages Replaceable operations.\n  # Each Replaceable holds a value that is now replaceable.\n  #\n  # The TextType-type has implemented support for replace\n  # @see TextType\n  #\n  class ops.ReplaceManager extends ops.ListManager\n    #\n    # @param {Object} event_properties Decorates the event that is thrown by the RM\n    # @param {Object} event_this The object on which the event shall be executed\n    # @param {Operation} initial_content Initialize this with a Replaceable that holds the initial_content.\n    # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n    # @param {Delimiter} beginning Reference or Object.\n    # @param {Delimiter} end Reference or Object.\n    constructor: (custom_type, @event_properties, @event_this, uid)->\n      if not @event_properties['object']?\n        @event_properties['object'] = @event_this.getCustomType()\n      super custom_type, uid\n\n    type: \"ReplaceManager\"\n\n    #\n    # This doesn't throw the same events as the ListManager. Therefore, the\n    # Replaceables also not throw the same events.\n    # So, ReplaceManager and ListManager both implement\n    # these functions that are called when an Insertion is executed (at the end).\n    #\n    #\n    callEventDecorator: (events)->\n      if not @isDeleted()\n        for event in events\n          for name,prop of @event_properties\n            event[name] = prop\n        @event_this.callEvent events\n      undefined\n\n    #\n    # This is called, when the Insert-type was successfully executed.\n    # TODO: consider doing this in a more consistent manner. This could also be\n    # done with execute. But currently, there are no specital Insert-ops for ListManager.\n    #\n    callOperationSpecificInsertEvents: (op)->\n      if op.next_cl.type is \"Delimiter\" and op.prev_cl.type isnt \"Delimiter\"\n        # this replaces another Replaceable\n        if not op.is_deleted # When this is received from the HB, this could already be deleted!\n          old_value = op.prev_cl.val()\n          @callEventDecorator [\n            type: \"update\"\n            changedBy: op.uid.creator\n            oldValue: old_value\n          ]\n        op.prev_cl.applyDelete()\n      else if op.next_cl.type isnt \"Delimiter\"\n        # This won't be recognized by the user, because another\n        # concurrent operation is set as the current value of the RM\n        op.applyDelete()\n      else # prev _and_ next are Delimiters. This is the first created Replaceable in the RM\n        @callEventDecorator [\n          type: \"add\"\n          changedBy: op.uid.creator\n        ]\n      undefined\n\n    callOperationSpecificDeleteEvents: (op, del_op)->\n      if op.next_cl.type is \"Delimiter\"\n        @callEventDecorator [\n          type: \"delete\"\n          changedBy: del_op.uid.creator\n          oldValue: op.val()\n        ]\n\n\n    #\n    # Replace the existing word with a new word.\n    #\n    # @param content {Operation} The new value of this ReplaceManager.\n    # @param replaceable_uid {UID} Optional: Unique id of the Replaceable that is created\n    #\n    replace: (content, replaceable_uid)->\n      o = @getLastOperation()\n      relp = (new ops.Insert null, content, null, @, replaceable_uid, o, o.next_cl).execute()\n      # TODO: delete repl (for debugging)\n      undefined\n\n    isContentDeleted: ()->\n      @getLastOperation().isDeleted()\n\n    deleteContent: ()->\n      last_op = @getLastOperation()\n      if (not last_op.isDeleted()) and last_op.type isnt \"Delimiter\"\n        (new ops.Delete null, undefined, @getLastOperation().uid).execute()\n      undefined\n\n    #\n    # Get the value of this\n    # @return {String}\n    #\n    val: ()->\n      o = @getLastOperation()\n      #if o instanceof ops.Delimiter\n        # throw new Error \"Replace Manager doesn't contain anything.\"\n      o.val?() # ? - for the case that (currently) the RM does not contain anything (then o is a Delimiter)\n\n\n\n  basic_ops\n","\nstructured_ops_uninitialized = require \"./Operations/Structured\"\n\nHistoryBuffer = require \"./HistoryBuffer\"\nEngine = require \"./Engine\"\nadaptConnector = require \"./ConnectorAdapter\"\n\ncreateY = (connector)->\n  if connector.user_id?\n    user_id = connector.user_id # TODO: change to getUniqueId()\n  else\n    user_id = \"_temp\"\n    connector.when_received_state_vector_listeners = [(state_vector)->\n        HB.setUserId this.user_id, state_vector\n      ]\n  HB = new HistoryBuffer user_id\n  ops_manager = structured_ops_uninitialized HB, this.constructor\n  ops = ops_manager.operations\n\n  engine = new Engine HB, ops\n  adaptConnector connector, engine, HB, ops_manager.execution_listener\n\n  ops.Operation.prototype.HB = HB\n  ops.Operation.prototype.operations = ops\n  ops.Operation.prototype.engine = engine\n  ops.Operation.prototype.connector = connector\n  ops.Operation.prototype.custom_types = this.constructor\n\n  ct = new createY.Object()\n  model = new ops.MapManager(ct, HB.getReservedUniqueIdentifier()).execute()\n  ct._setModel model\n  ct\n\nmodule.exports = createY\nif window?\n  window.Y = createY\n\ncreateY.Object = require \"./ObjectType\"\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = Buffer\nexports.INSPECT_MAX_BYTES = 50\nBuffer.poolSize = 8192\n\n/**\n * If `Buffer._useTypedArrays`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (compatible down to IE6)\n */\nBuffer._useTypedArrays = (function () {\n  // Detect if browser supports Typed Arrays. Supported browsers are IE 10+, Firefox 4+,\n  // Chrome 7+, Safari 5.1+, Opera 11.6+, iOS 4.2+. If the browser does not support adding\n  // properties to `Uint8Array` instances, then that's the same as no `Uint8Array` support\n  // because we need to be able to add all the node Buffer API methods. This is an issue\n  // in Firefox 4-29. Now fixed: https://bugzilla.mozilla.org/show_bug.cgi?id=695438\n  try {\n    var buf = new ArrayBuffer(0)\n    var arr = new Uint8Array(buf)\n    arr.foo = function () { return 42 }\n    return 42 === arr.foo() &&\n        typeof arr.subarray === 'function' // Chrome 9-10 lack `subarray`\n  } catch (e) {\n    return false\n  }\n})()\n\n/**\n * Class: Buffer\n * =============\n *\n * The Buffer constructor returns instances of `Uint8Array` that are augmented\n * with function properties for all the node `Buffer` API functions. We use\n * `Uint8Array` so that square bracket notation works as expected -- it returns\n * a single octet.\n *\n * By augmenting the instances, we can avoid modifying the `Uint8Array`\n * prototype.\n */\nfunction Buffer (subject, encoding, noZero) {\n  if (!(this instanceof Buffer))\n    return new Buffer(subject, encoding, noZero)\n\n  var type = typeof subject\n\n  // Workaround: node's base64 implementation allows for non-padded strings\n  // while base64-js does not.\n  if (encoding === 'base64' && type === 'string') {\n    subject = stringtrim(subject)\n    while (subject.length % 4 !== 0) {\n      subject = subject + '='\n    }\n  }\n\n  // Find the length\n  var length\n  if (type === 'number')\n    length = coerce(subject)\n  else if (type === 'string')\n    length = Buffer.byteLength(subject, encoding)\n  else if (type === 'object')\n    length = coerce(subject.length) // assume that object is array-like\n  else\n    throw new Error('First argument needs to be a number, array or string.')\n\n  var buf\n  if (Buffer._useTypedArrays) {\n    // Preferred: Return an augmented `Uint8Array` instance for best performance\n    buf = Buffer._augment(new Uint8Array(length))\n  } else {\n    // Fallback: Return THIS instance of Buffer (created by `new`)\n    buf = this\n    buf.length = length\n    buf._isBuffer = true\n  }\n\n  var i\n  if (Buffer._useTypedArrays && typeof subject.byteLength === 'number') {\n    // Speed optimization -- use set if we're copying from a typed array\n    buf._set(subject)\n  } else if (isArrayish(subject)) {\n    // Treat array-ish objects as a byte array\n    for (i = 0; i < length; i++) {\n      if (Buffer.isBuffer(subject))\n        buf[i] = subject.readUInt8(i)\n      else\n        buf[i] = subject[i]\n    }\n  } else if (type === 'string') {\n    buf.write(subject, 0, encoding)\n  } else if (type === 'number' && !Buffer._useTypedArrays && !noZero) {\n    for (i = 0; i < length; i++) {\n      buf[i] = 0\n    }\n  }\n\n  return buf\n}\n\n// STATIC METHODS\n// ==============\n\nBuffer.isEncoding = function (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'binary':\n    case 'base64':\n    case 'raw':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.isBuffer = function (b) {\n  return !!(b !== null && b !== undefined && b._isBuffer)\n}\n\nBuffer.byteLength = function (str, encoding) {\n  var ret\n  str = str + ''\n  switch (encoding || 'utf8') {\n    case 'hex':\n      ret = str.length / 2\n      break\n    case 'utf8':\n    case 'utf-8':\n      ret = utf8ToBytes(str).length\n      break\n    case 'ascii':\n    case 'binary':\n    case 'raw':\n      ret = str.length\n      break\n    case 'base64':\n      ret = base64ToBytes(str).length\n      break\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      ret = str.length * 2\n      break\n    default:\n      throw new Error('Unknown encoding')\n  }\n  return ret\n}\n\nBuffer.concat = function (list, totalLength) {\n  assert(isArray(list), 'Usage: Buffer.concat(list, [totalLength])\\n' +\n      'list should be an Array.')\n\n  if (list.length === 0) {\n    return new Buffer(0)\n  } else if (list.length === 1) {\n    return list[0]\n  }\n\n  var i\n  if (typeof totalLength !== 'number') {\n    totalLength = 0\n    for (i = 0; i < list.length; i++) {\n      totalLength += list[i].length\n    }\n  }\n\n  var buf = new Buffer(totalLength)\n  var pos = 0\n  for (i = 0; i < list.length; i++) {\n    var item = list[i]\n    item.copy(buf, pos)\n    pos += item.length\n  }\n  return buf\n}\n\n// BUFFER INSTANCE METHODS\n// =======================\n\nfunction _hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  assert(strLen % 2 === 0, 'Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; i++) {\n    var byte = parseInt(string.substr(i * 2, 2), 16)\n    assert(!isNaN(byte), 'Invalid hex string')\n    buf[offset + i] = byte\n  }\n  Buffer._charsWritten = i * 2\n  return i\n}\n\nfunction _utf8Write (buf, string, offset, length) {\n  var charsWritten = Buffer._charsWritten =\n    blitBuffer(utf8ToBytes(string), buf, offset, length)\n  return charsWritten\n}\n\nfunction _asciiWrite (buf, string, offset, length) {\n  var charsWritten = Buffer._charsWritten =\n    blitBuffer(asciiToBytes(string), buf, offset, length)\n  return charsWritten\n}\n\nfunction _binaryWrite (buf, string, offset, length) {\n  return _asciiWrite(buf, string, offset, length)\n}\n\nfunction _base64Write (buf, string, offset, length) {\n  var charsWritten = Buffer._charsWritten =\n    blitBuffer(base64ToBytes(string), buf, offset, length)\n  return charsWritten\n}\n\nfunction _utf16leWrite (buf, string, offset, length) {\n  var charsWritten = Buffer._charsWritten =\n    blitBuffer(utf16leToBytes(string), buf, offset, length)\n  return charsWritten\n}\n\nBuffer.prototype.write = function (string, offset, length, encoding) {\n  // Support both (string, offset, length, encoding)\n  // and the legacy (string, encoding, offset, length)\n  if (isFinite(offset)) {\n    if (!isFinite(length)) {\n      encoding = length\n      length = undefined\n    }\n  } else {  // legacy\n    var swap = encoding\n    encoding = offset\n    offset = length\n    length = swap\n  }\n\n  offset = Number(offset) || 0\n  var remaining = this.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n  encoding = String(encoding || 'utf8').toLowerCase()\n\n  var ret\n  switch (encoding) {\n    case 'hex':\n      ret = _hexWrite(this, string, offset, length)\n      break\n    case 'utf8':\n    case 'utf-8':\n      ret = _utf8Write(this, string, offset, length)\n      break\n    case 'ascii':\n      ret = _asciiWrite(this, string, offset, length)\n      break\n    case 'binary':\n      ret = _binaryWrite(this, string, offset, length)\n      break\n    case 'base64':\n      ret = _base64Write(this, string, offset, length)\n      break\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      ret = _utf16leWrite(this, string, offset, length)\n      break\n    default:\n      throw new Error('Unknown encoding')\n  }\n  return ret\n}\n\nBuffer.prototype.toString = function (encoding, start, end) {\n  var self = this\n\n  encoding = String(encoding || 'utf8').toLowerCase()\n  start = Number(start) || 0\n  end = (end !== undefined)\n    ? Number(end)\n    : end = self.length\n\n  // Fastpath empty strings\n  if (end === start)\n    return ''\n\n  var ret\n  switch (encoding) {\n    case 'hex':\n      ret = _hexSlice(self, start, end)\n      break\n    case 'utf8':\n    case 'utf-8':\n      ret = _utf8Slice(self, start, end)\n      break\n    case 'ascii':\n      ret = _asciiSlice(self, start, end)\n      break\n    case 'binary':\n      ret = _binarySlice(self, start, end)\n      break\n    case 'base64':\n      ret = _base64Slice(self, start, end)\n      break\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      ret = _utf16leSlice(self, start, end)\n      break\n    default:\n      throw new Error('Unknown encoding')\n  }\n  return ret\n}\n\nBuffer.prototype.toJSON = function () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function (target, target_start, start, end) {\n  var source = this\n\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (!target_start) target_start = 0\n\n  // Copy 0 bytes; we're done\n  if (end === start) return\n  if (target.length === 0 || source.length === 0) return\n\n  // Fatal error conditions\n  assert(end >= start, 'sourceEnd < sourceStart')\n  assert(target_start >= 0 && target_start < target.length,\n      'targetStart out of bounds')\n  assert(start >= 0 && start < source.length, 'sourceStart out of bounds')\n  assert(end >= 0 && end <= source.length, 'sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length)\n    end = this.length\n  if (target.length - target_start < end - start)\n    end = target.length - target_start + start\n\n  var len = end - start\n\n  if (len < 100 || !Buffer._useTypedArrays) {\n    for (var i = 0; i < len; i++)\n      target[i + target_start] = this[i + start]\n  } else {\n    target._set(this.subarray(start, start + len), target_start)\n  }\n}\n\nfunction _base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction _utf8Slice (buf, start, end) {\n  var res = ''\n  var tmp = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; i++) {\n    if (buf[i] <= 0x7F) {\n      res += decodeUtf8Char(tmp) + String.fromCharCode(buf[i])\n      tmp = ''\n    } else {\n      tmp += '%' + buf[i].toString(16)\n    }\n  }\n\n  return res + decodeUtf8Char(tmp)\n}\n\nfunction _asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; i++)\n    ret += String.fromCharCode(buf[i])\n  return ret\n}\n\nfunction _binarySlice (buf, start, end) {\n  return _asciiSlice(buf, start, end)\n}\n\nfunction _hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; i++) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction _utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i+1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function (start, end) {\n  var len = this.length\n  start = clamp(start, len, 0)\n  end = clamp(end, len, len)\n\n  if (Buffer._useTypedArrays) {\n    return Buffer._augment(this.subarray(start, end))\n  } else {\n    var sliceLen = end - start\n    var newBuf = new Buffer(sliceLen, undefined, true)\n    for (var i = 0; i < sliceLen; i++) {\n      newBuf[i] = this[i + start]\n    }\n    return newBuf\n  }\n}\n\n// `get` will be removed in Node 0.13+\nBuffer.prototype.get = function (offset) {\n  console.log('.get() is deprecated. Access using array indexes instead.')\n  return this.readUInt8(offset)\n}\n\n// `set` will be removed in Node 0.13+\nBuffer.prototype.set = function (v, offset) {\n  console.log('.set() is deprecated. Access using array indexes instead.')\n  return this.writeUInt8(v, offset)\n}\n\nBuffer.prototype.readUInt8 = function (offset, noAssert) {\n  if (!noAssert) {\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset < this.length, 'Trying to read beyond buffer length')\n  }\n\n  if (offset >= this.length)\n    return\n\n  return this[offset]\n}\n\nfunction _readUInt16 (buf, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  var val\n  if (littleEndian) {\n    val = buf[offset]\n    if (offset + 1 < len)\n      val |= buf[offset + 1] << 8\n  } else {\n    val = buf[offset] << 8\n    if (offset + 1 < len)\n      val |= buf[offset + 1]\n  }\n  return val\n}\n\nBuffer.prototype.readUInt16LE = function (offset, noAssert) {\n  return _readUInt16(this, offset, true, noAssert)\n}\n\nBuffer.prototype.readUInt16BE = function (offset, noAssert) {\n  return _readUInt16(this, offset, false, noAssert)\n}\n\nfunction _readUInt32 (buf, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  var val\n  if (littleEndian) {\n    if (offset + 2 < len)\n      val = buf[offset + 2] << 16\n    if (offset + 1 < len)\n      val |= buf[offset + 1] << 8\n    val |= buf[offset]\n    if (offset + 3 < len)\n      val = val + (buf[offset + 3] << 24 >>> 0)\n  } else {\n    if (offset + 1 < len)\n      val = buf[offset + 1] << 16\n    if (offset + 2 < len)\n      val |= buf[offset + 2] << 8\n    if (offset + 3 < len)\n      val |= buf[offset + 3]\n    val = val + (buf[offset] << 24 >>> 0)\n  }\n  return val\n}\n\nBuffer.prototype.readUInt32LE = function (offset, noAssert) {\n  return _readUInt32(this, offset, true, noAssert)\n}\n\nBuffer.prototype.readUInt32BE = function (offset, noAssert) {\n  return _readUInt32(this, offset, false, noAssert)\n}\n\nBuffer.prototype.readInt8 = function (offset, noAssert) {\n  if (!noAssert) {\n    assert(offset !== undefined && offset !== null,\n        'missing offset')\n    assert(offset < this.length, 'Trying to read beyond buffer length')\n  }\n\n  if (offset >= this.length)\n    return\n\n  var neg = this[offset] & 0x80\n  if (neg)\n    return (0xff - this[offset] + 1) * -1\n  else\n    return this[offset]\n}\n\nfunction _readInt16 (buf, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 1 < buf.length, 'Trying to read beyond buffer length')\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  var val = _readUInt16(buf, offset, littleEndian, true)\n  var neg = val & 0x8000\n  if (neg)\n    return (0xffff - val + 1) * -1\n  else\n    return val\n}\n\nBuffer.prototype.readInt16LE = function (offset, noAssert) {\n  return _readInt16(this, offset, true, noAssert)\n}\n\nBuffer.prototype.readInt16BE = function (offset, noAssert) {\n  return _readInt16(this, offset, false, noAssert)\n}\n\nfunction _readInt32 (buf, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  var val = _readUInt32(buf, offset, littleEndian, true)\n  var neg = val & 0x80000000\n  if (neg)\n    return (0xffffffff - val + 1) * -1\n  else\n    return val\n}\n\nBuffer.prototype.readInt32LE = function (offset, noAssert) {\n  return _readInt32(this, offset, true, noAssert)\n}\n\nBuffer.prototype.readInt32BE = function (offset, noAssert) {\n  return _readInt32(this, offset, false, noAssert)\n}\n\nfunction _readFloat (buf, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset + 3 < buf.length, 'Trying to read beyond buffer length')\n  }\n\n  return ieee754.read(buf, offset, littleEndian, 23, 4)\n}\n\nBuffer.prototype.readFloatLE = function (offset, noAssert) {\n  return _readFloat(this, offset, true, noAssert)\n}\n\nBuffer.prototype.readFloatBE = function (offset, noAssert) {\n  return _readFloat(this, offset, false, noAssert)\n}\n\nfunction _readDouble (buf, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset + 7 < buf.length, 'Trying to read beyond buffer length')\n  }\n\n  return ieee754.read(buf, offset, littleEndian, 52, 8)\n}\n\nBuffer.prototype.readDoubleLE = function (offset, noAssert) {\n  return _readDouble(this, offset, true, noAssert)\n}\n\nBuffer.prototype.readDoubleBE = function (offset, noAssert) {\n  return _readDouble(this, offset, false, noAssert)\n}\n\nBuffer.prototype.writeUInt8 = function (value, offset, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset < this.length, 'trying to write beyond buffer length')\n    verifuint(value, 0xff)\n  }\n\n  if (offset >= this.length) return\n\n  this[offset] = value\n}\n\nfunction _writeUInt16 (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 1 < buf.length, 'trying to write beyond buffer length')\n    verifuint(value, 0xffff)\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  for (var i = 0, j = Math.min(len - offset, 2); i < j; i++) {\n    buf[offset + i] =\n        (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n            (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function (value, offset, noAssert) {\n  _writeUInt16(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeUInt16BE = function (value, offset, noAssert) {\n  _writeUInt16(this, value, offset, false, noAssert)\n}\n\nfunction _writeUInt32 (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 3 < buf.length, 'trying to write beyond buffer length')\n    verifuint(value, 0xffffffff)\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  for (var i = 0, j = Math.min(len - offset, 4); i < j; i++) {\n    buf[offset + i] =\n        (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function (value, offset, noAssert) {\n  _writeUInt32(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeUInt32BE = function (value, offset, noAssert) {\n  _writeUInt32(this, value, offset, false, noAssert)\n}\n\nBuffer.prototype.writeInt8 = function (value, offset, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset < this.length, 'Trying to write beyond buffer length')\n    verifsint(value, 0x7f, -0x80)\n  }\n\n  if (offset >= this.length)\n    return\n\n  if (value >= 0)\n    this.writeUInt8(value, offset, noAssert)\n  else\n    this.writeUInt8(0xff + value + 1, offset, noAssert)\n}\n\nfunction _writeInt16 (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 1 < buf.length, 'Trying to write beyond buffer length')\n    verifsint(value, 0x7fff, -0x8000)\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  if (value >= 0)\n    _writeUInt16(buf, value, offset, littleEndian, noAssert)\n  else\n    _writeUInt16(buf, 0xffff + value + 1, offset, littleEndian, noAssert)\n}\n\nBuffer.prototype.writeInt16LE = function (value, offset, noAssert) {\n  _writeInt16(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeInt16BE = function (value, offset, noAssert) {\n  _writeInt16(this, value, offset, false, noAssert)\n}\n\nfunction _writeInt32 (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')\n    verifsint(value, 0x7fffffff, -0x80000000)\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  if (value >= 0)\n    _writeUInt32(buf, value, offset, littleEndian, noAssert)\n  else\n    _writeUInt32(buf, 0xffffffff + value + 1, offset, littleEndian, noAssert)\n}\n\nBuffer.prototype.writeInt32LE = function (value, offset, noAssert) {\n  _writeInt32(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeInt32BE = function (value, offset, noAssert) {\n  _writeInt32(this, value, offset, false, noAssert)\n}\n\nfunction _writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 3 < buf.length, 'Trying to write beyond buffer length')\n    verifIEEE754(value, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n}\n\nBuffer.prototype.writeFloatLE = function (value, offset, noAssert) {\n  _writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function (value, offset, noAssert) {\n  _writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction _writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    assert(value !== undefined && value !== null, 'missing value')\n    assert(typeof littleEndian === 'boolean', 'missing or invalid endian')\n    assert(offset !== undefined && offset !== null, 'missing offset')\n    assert(offset + 7 < buf.length,\n        'Trying to write beyond buffer length')\n    verifIEEE754(value, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n\n  var len = buf.length\n  if (offset >= len)\n    return\n\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n}\n\nBuffer.prototype.writeDoubleLE = function (value, offset, noAssert) {\n  _writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function (value, offset, noAssert) {\n  _writeDouble(this, value, offset, false, noAssert)\n}\n\n// fill(value, start=0, end=buffer.length)\nBuffer.prototype.fill = function (value, start, end) {\n  if (!value) value = 0\n  if (!start) start = 0\n  if (!end) end = this.length\n\n  if (typeof value === 'string') {\n    value = value.charCodeAt(0)\n  }\n\n  assert(typeof value === 'number' && !isNaN(value), 'value is not a number')\n  assert(end >= start, 'end < start')\n\n  // Fill 0 bytes; we're done\n  if (end === start) return\n  if (this.length === 0) return\n\n  assert(start >= 0 && start < this.length, 'start out of bounds')\n  assert(end >= 0 && end <= this.length, 'end out of bounds')\n\n  for (var i = start; i < end; i++) {\n    this[i] = value\n  }\n}\n\nBuffer.prototype.inspect = function () {\n  var out = []\n  var len = this.length\n  for (var i = 0; i < len; i++) {\n    out[i] = toHex(this[i])\n    if (i === exports.INSPECT_MAX_BYTES) {\n      out[i + 1] = '...'\n      break\n    }\n  }\n  return '<Buffer ' + out.join(' ') + '>'\n}\n\n/**\n * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.\n * Added in Node 0.12. Only available in browsers that support ArrayBuffer.\n */\nBuffer.prototype.toArrayBuffer = function () {\n  if (typeof Uint8Array !== 'undefined') {\n    if (Buffer._useTypedArrays) {\n      return (new Buffer(this)).buffer\n    } else {\n      var buf = new Uint8Array(this.length)\n      for (var i = 0, len = buf.length; i < len; i += 1)\n        buf[i] = this[i]\n      return buf.buffer\n    }\n  } else {\n    throw new Error('Buffer.toArrayBuffer not supported in this browser')\n  }\n}\n\n// HELPER FUNCTIONS\n// ================\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nvar BP = Buffer.prototype\n\n/**\n * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods\n */\nBuffer._augment = function (arr) {\n  arr._isBuffer = true\n\n  // save reference to original Uint8Array get/set methods before overwriting\n  arr._get = arr.get\n  arr._set = arr.set\n\n  // deprecated, will be removed in node 0.13+\n  arr.get = BP.get\n  arr.set = BP.set\n\n  arr.write = BP.write\n  arr.toString = BP.toString\n  arr.toLocaleString = BP.toString\n  arr.toJSON = BP.toJSON\n  arr.copy = BP.copy\n  arr.slice = BP.slice\n  arr.readUInt8 = BP.readUInt8\n  arr.readUInt16LE = BP.readUInt16LE\n  arr.readUInt16BE = BP.readUInt16BE\n  arr.readUInt32LE = BP.readUInt32LE\n  arr.readUInt32BE = BP.readUInt32BE\n  arr.readInt8 = BP.readInt8\n  arr.readInt16LE = BP.readInt16LE\n  arr.readInt16BE = BP.readInt16BE\n  arr.readInt32LE = BP.readInt32LE\n  arr.readInt32BE = BP.readInt32BE\n  arr.readFloatLE = BP.readFloatLE\n  arr.readFloatBE = BP.readFloatBE\n  arr.readDoubleLE = BP.readDoubleLE\n  arr.readDoubleBE = BP.readDoubleBE\n  arr.writeUInt8 = BP.writeUInt8\n  arr.writeUInt16LE = BP.writeUInt16LE\n  arr.writeUInt16BE = BP.writeUInt16BE\n  arr.writeUInt32LE = BP.writeUInt32LE\n  arr.writeUInt32BE = BP.writeUInt32BE\n  arr.writeInt8 = BP.writeInt8\n  arr.writeInt16LE = BP.writeInt16LE\n  arr.writeInt16BE = BP.writeInt16BE\n  arr.writeInt32LE = BP.writeInt32LE\n  arr.writeInt32BE = BP.writeInt32BE\n  arr.writeFloatLE = BP.writeFloatLE\n  arr.writeFloatBE = BP.writeFloatBE\n  arr.writeDoubleLE = BP.writeDoubleLE\n  arr.writeDoubleBE = BP.writeDoubleBE\n  arr.fill = BP.fill\n  arr.inspect = BP.inspect\n  arr.toArrayBuffer = BP.toArrayBuffer\n\n  return arr\n}\n\n// slice(start, end)\nfunction clamp (index, len, defaultValue) {\n  if (typeof index !== 'number') return defaultValue\n  index = ~~index;  // Coerce to integer.\n  if (index >= len) return len\n  if (index >= 0) return index\n  index += len\n  if (index >= 0) return index\n  return 0\n}\n\nfunction coerce (length) {\n  // Coerce length to a number (possibly NaN), round up\n  // in case it's fractional (e.g. 123.456) then do a\n  // double negate to coerce a NaN to 0. Easy, right?\n  length = ~~Math.ceil(+length)\n  return length < 0 ? 0 : length\n}\n\nfunction isArray (subject) {\n  return (Array.isArray || function (subject) {\n    return Object.prototype.toString.call(subject) === '[object Array]'\n  })(subject)\n}\n\nfunction isArrayish (subject) {\n  return isArray(subject) || Buffer.isBuffer(subject) ||\n      subject && typeof subject === 'object' &&\n      typeof subject.length === 'number'\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    var b = str.charCodeAt(i)\n    if (b <= 0x7F)\n      byteArray.push(str.charCodeAt(i))\n    else {\n      var start = i\n      if (b >= 0xD800 && b <= 0xDFFF) i++\n      var h = encodeURIComponent(str.slice(start, i+1)).substr(1).split('%')\n      for (var j = 0; j < h.length; j++)\n        byteArray.push(parseInt(h[j], 16))\n    }\n  }\n  return byteArray\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; i++) {\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(str)\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  var pos\n  for (var i = 0; i < length; i++) {\n    if ((i + offset >= dst.length) || (i >= src.length))\n      break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction decodeUtf8Char (str) {\n  try {\n    return decodeURIComponent(str)\n  } catch (err) {\n    return String.fromCharCode(0xFFFD) // UTF 8 invalid char\n  }\n}\n\n/*\n * We have to make sure that the value is a valid integer. This means that it\n * is non-negative. It has no fractional component and that it does not\n * exceed the maximum allowed value.\n */\nfunction verifuint (value, max) {\n  assert(typeof value === 'number', 'cannot write a non-number as a number')\n  assert(value >= 0, 'specified a negative value for writing an unsigned value')\n  assert(value <= max, 'value is larger than maximum value for type')\n  assert(Math.floor(value) === value, 'value has a fractional component')\n}\n\nfunction verifsint (value, max, min) {\n  assert(typeof value === 'number', 'cannot write a non-number as a number')\n  assert(value <= max, 'value larger than maximum allowed value')\n  assert(value >= min, 'value smaller than minimum allowed value')\n  assert(Math.floor(value) === value, 'value has a fractional component')\n}\n\nfunction verifIEEE754 (value, max, min) {\n  assert(typeof value === 'number', 'cannot write a non-number as a number')\n  assert(value <= max, 'value larger than maximum allowed value')\n  assert(value >= min, 'value smaller than minimum allowed value')\n}\n\nfunction assert (test, message) {\n  if (!test) throw new Error(message || 'Failed assertion')\n}\n","var lookup = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\n;(function (exports) {\n\t'use strict';\n\n  var Arr = (typeof Uint8Array !== 'undefined')\n    ? Uint8Array\n    : Array\n\n\tvar PLUS   = '+'.charCodeAt(0)\n\tvar SLASH  = '/'.charCodeAt(0)\n\tvar NUMBER = '0'.charCodeAt(0)\n\tvar LOWER  = 'a'.charCodeAt(0)\n\tvar UPPER  = 'A'.charCodeAt(0)\n\tvar PLUS_URL_SAFE = '-'.charCodeAt(0)\n\tvar SLASH_URL_SAFE = '_'.charCodeAt(0)\n\n\tfunction decode (elt) {\n\t\tvar code = elt.charCodeAt(0)\n\t\tif (code === PLUS ||\n\t\t    code === PLUS_URL_SAFE)\n\t\t\treturn 62 // '+'\n\t\tif (code === SLASH ||\n\t\t    code === SLASH_URL_SAFE)\n\t\t\treturn 63 // '/'\n\t\tif (code < NUMBER)\n\t\t\treturn -1 //no match\n\t\tif (code < NUMBER + 10)\n\t\t\treturn code - NUMBER + 26 + 26\n\t\tif (code < UPPER + 26)\n\t\t\treturn code - UPPER\n\t\tif (code < LOWER + 26)\n\t\t\treturn code - LOWER + 26\n\t}\n\n\tfunction b64ToByteArray (b64) {\n\t\tvar i, j, l, tmp, placeHolders, arr\n\n\t\tif (b64.length % 4 > 0) {\n\t\t\tthrow new Error('Invalid string. Length must be a multiple of 4')\n\t\t}\n\n\t\t// the number of equal signs (place holders)\n\t\t// if there are two placeholders, than the two characters before it\n\t\t// represent one byte\n\t\t// if there is only one, then the three characters before it represent 2 bytes\n\t\t// this is just a cheap hack to not do indexOf twice\n\t\tvar len = b64.length\n\t\tplaceHolders = '=' === b64.charAt(len - 2) ? 2 : '=' === b64.charAt(len - 1) ? 1 : 0\n\n\t\t// base64 is 4/3 + up to two characters of the original data\n\t\tarr = new Arr(b64.length * 3 / 4 - placeHolders)\n\n\t\t// if there are placeholders, only get up to the last complete 4 chars\n\t\tl = placeHolders > 0 ? b64.length - 4 : b64.length\n\n\t\tvar L = 0\n\n\t\tfunction push (v) {\n\t\t\tarr[L++] = v\n\t\t}\n\n\t\tfor (i = 0, j = 0; i < l; i += 4, j += 3) {\n\t\t\ttmp = (decode(b64.charAt(i)) << 18) | (decode(b64.charAt(i + 1)) << 12) | (decode(b64.charAt(i + 2)) << 6) | decode(b64.charAt(i + 3))\n\t\t\tpush((tmp & 0xFF0000) >> 16)\n\t\t\tpush((tmp & 0xFF00) >> 8)\n\t\t\tpush(tmp & 0xFF)\n\t\t}\n\n\t\tif (placeHolders === 2) {\n\t\t\ttmp = (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4)\n\t\t\tpush(tmp & 0xFF)\n\t\t} else if (placeHolders === 1) {\n\t\t\ttmp = (decode(b64.charAt(i)) << 10) | (decode(b64.charAt(i + 1)) << 4) | (decode(b64.charAt(i + 2)) >> 2)\n\t\t\tpush((tmp >> 8) & 0xFF)\n\t\t\tpush(tmp & 0xFF)\n\t\t}\n\n\t\treturn arr\n\t}\n\n\tfunction uint8ToBase64 (uint8) {\n\t\tvar i,\n\t\t\textraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes\n\t\t\toutput = \"\",\n\t\t\ttemp, length\n\n\t\tfunction encode (num) {\n\t\t\treturn lookup.charAt(num)\n\t\t}\n\n\t\tfunction tripletToBase64 (num) {\n\t\t\treturn encode(num >> 18 & 0x3F) + encode(num >> 12 & 0x3F) + encode(num >> 6 & 0x3F) + encode(num & 0x3F)\n\t\t}\n\n\t\t// go through the array every three bytes, we'll deal with trailing stuff later\n\t\tfor (i = 0, length = uint8.length - extraBytes; i < length; i += 3) {\n\t\t\ttemp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2])\n\t\t\toutput += tripletToBase64(temp)\n\t\t}\n\n\t\t// pad the end with zeros, but make sure to not forget the extra bytes\n\t\tswitch (extraBytes) {\n\t\t\tcase 1:\n\t\t\t\ttemp = uint8[uint8.length - 1]\n\t\t\t\toutput += encode(temp >> 2)\n\t\t\t\toutput += encode((temp << 4) & 0x3F)\n\t\t\t\toutput += '=='\n\t\t\t\tbreak\n\t\t\tcase 2:\n\t\t\t\ttemp = (uint8[uint8.length - 2] << 8) + (uint8[uint8.length - 1])\n\t\t\t\toutput += encode(temp >> 10)\n\t\t\t\toutput += encode((temp >> 4) & 0x3F)\n\t\t\t\toutput += encode((temp << 2) & 0x3F)\n\t\t\t\toutput += '='\n\t\t\t\tbreak\n\t\t}\n\n\t\treturn output\n\t}\n\n\texports.toByteArray = b64ToByteArray\n\texports.fromByteArray = uint8ToBase64\n}(typeof exports === 'undefined' ? (this.base64js = {}) : exports))\n","exports.read = function(buffer, offset, isLE, mLen, nBytes) {\n  var e, m,\n      eLen = nBytes * 8 - mLen - 1,\n      eMax = (1 << eLen) - 1,\n      eBias = eMax >> 1,\n      nBits = -7,\n      i = isLE ? (nBytes - 1) : 0,\n      d = isLE ? -1 : 1,\n      s = buffer[offset + i];\n\n  i += d;\n\n  e = s & ((1 << (-nBits)) - 1);\n  s >>= (-nBits);\n  nBits += eLen;\n  for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);\n\n  m = e & ((1 << (-nBits)) - 1);\n  e >>= (-nBits);\n  nBits += mLen;\n  for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);\n\n  if (e === 0) {\n    e = 1 - eBias;\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity);\n  } else {\n    m = m + Math.pow(2, mLen);\n    e = e - eBias;\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen);\n};\n\nexports.write = function(buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c,\n      eLen = nBytes * 8 - mLen - 1,\n      eMax = (1 << eLen) - 1,\n      eBias = eMax >> 1,\n      rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0),\n      i = isLE ? 0 : (nBytes - 1),\n      d = isLE ? 1 : -1,\n      s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;\n\n  value = Math.abs(value);\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0;\n    e = eMax;\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2);\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--;\n      c *= 2;\n    }\n    if (e + eBias >= 1) {\n      value += rt / c;\n    } else {\n      value += rt * Math.pow(2, 1 - eBias);\n    }\n    if (value * c >= 2) {\n      e++;\n      c /= 2;\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0;\n      e = eMax;\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * Math.pow(2, mLen);\n      e = e + eBias;\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);\n      e = 0;\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);\n\n  e = (e << mLen) | m;\n  eLen += mLen;\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);\n\n  buffer[offset + i - d] |= s * 128;\n};\n","if (typeof Object.create === 'function') {\n  // implementation from standard node.js 'util' module\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    ctor.prototype = Object.create(superCtor.prototype, {\n      constructor: {\n        value: ctor,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n  };\n} else {\n  // old school shim for old browsers\n  module.exports = function inherits(ctor, superCtor) {\n    ctor.super_ = superCtor\n    var TempCtor = function () {}\n    TempCtor.prototype = superCtor.prototype\n    ctor.prototype = new TempCtor()\n    ctor.prototype.constructor = ctor\n  }\n}\n","// shim for using process in browser\n\nvar process = module.exports = {};\n\nprocess.nextTick = (function () {\n    var canSetImmediate = typeof window !== 'undefined'\n    && window.setImmediate;\n    var canPost = typeof window !== 'undefined'\n    && window.postMessage && window.addEventListener\n    ;\n\n    if (canSetImmediate) {\n        return function (f) { return window.setImmediate(f) };\n    }\n\n    if (canPost) {\n        var queue = [];\n        window.addEventListener('message', function (ev) {\n            var source = ev.source;\n            if ((source === window || source === null) && ev.data === 'process-tick') {\n                ev.stopPropagation();\n                if (queue.length > 0) {\n                    var fn = queue.shift();\n                    fn();\n                }\n            }\n        }, true);\n\n        return function nextTick(fn) {\n            queue.push(fn);\n            window.postMessage('process-tick', '*');\n        };\n    }\n\n    return function nextTick(fn) {\n        setTimeout(fn, 0);\n    };\n})();\n\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n}\n\n// TODO(shtylman)\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\n","module.exports = function isBuffer(arg) {\n  return arg && typeof arg === 'object'\n    && typeof arg.copy === 'function'\n    && typeof arg.fill === 'function'\n    && typeof arg.readUInt8 === 'function';\n}","(function (process,global){\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n  if (!isString(f)) {\n    var objects = [];\n    for (var i = 0; i < arguments.length; i++) {\n      objects.push(inspect(arguments[i]));\n    }\n    return objects.join(' ');\n  }\n\n  var i = 1;\n  var args = arguments;\n  var len = args.length;\n  var str = String(f).replace(formatRegExp, function(x) {\n    if (x === '%%') return '%';\n    if (i >= len) return x;\n    switch (x) {\n      case '%s': return String(args[i++]);\n      case '%d': return Number(args[i++]);\n      case '%j':\n        try {\n          return JSON.stringify(args[i++]);\n        } catch (_) {\n          return '[Circular]';\n        }\n      default:\n        return x;\n    }\n  });\n  for (var x = args[i]; i < len; x = args[++i]) {\n    if (isNull(x) || !isObject(x)) {\n      str += ' ' + x;\n    } else {\n      str += ' ' + inspect(x);\n    }\n  }\n  return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n  // Allow for deprecating things in the process of starting up.\n  if (isUndefined(global.process)) {\n    return function() {\n      return exports.deprecate(fn, msg).apply(this, arguments);\n    };\n  }\n\n  if (process.noDeprecation === true) {\n    return fn;\n  }\n\n  var warned = false;\n  function deprecated() {\n    if (!warned) {\n      if (process.throwDeprecation) {\n        throw new Error(msg);\n      } else if (process.traceDeprecation) {\n        console.trace(msg);\n      } else {\n        console.error(msg);\n      }\n      warned = true;\n    }\n    return fn.apply(this, arguments);\n  }\n\n  return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnviron;\nexports.debuglog = function(set) {\n  if (isUndefined(debugEnviron))\n    debugEnviron = process.env.NODE_DEBUG || '';\n  set = set.toUpperCase();\n  if (!debugs[set]) {\n    if (new RegExp('\\\\b' + set + '\\\\b', 'i').test(debugEnviron)) {\n      var pid = process.pid;\n      debugs[set] = function() {\n        var msg = exports.format.apply(exports, arguments);\n        console.error('%s %d: %s', set, pid, msg);\n      };\n    } else {\n      debugs[set] = function() {};\n    }\n  }\n  return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n  // default options\n  var ctx = {\n    seen: [],\n    stylize: stylizeNoColor\n  };\n  // legacy...\n  if (arguments.length >= 3) ctx.depth = arguments[2];\n  if (arguments.length >= 4) ctx.colors = arguments[3];\n  if (isBoolean(opts)) {\n    // legacy...\n    ctx.showHidden = opts;\n  } else if (opts) {\n    // got an \"options\" object\n    exports._extend(ctx, opts);\n  }\n  // set default options\n  if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n  if (isUndefined(ctx.depth)) ctx.depth = 2;\n  if (isUndefined(ctx.colors)) ctx.colors = false;\n  if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n  if (ctx.colors) ctx.stylize = stylizeWithColor;\n  return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n  'bold' : [1, 22],\n  'italic' : [3, 23],\n  'underline' : [4, 24],\n  'inverse' : [7, 27],\n  'white' : [37, 39],\n  'grey' : [90, 39],\n  'black' : [30, 39],\n  'blue' : [34, 39],\n  'cyan' : [36, 39],\n  'green' : [32, 39],\n  'magenta' : [35, 39],\n  'red' : [31, 39],\n  'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n  'special': 'cyan',\n  'number': 'yellow',\n  'boolean': 'yellow',\n  'undefined': 'grey',\n  'null': 'bold',\n  'string': 'green',\n  'date': 'magenta',\n  // \"name\": intentionally not styling\n  'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n  var style = inspect.styles[styleType];\n\n  if (style) {\n    return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n           '\\u001b[' + inspect.colors[style][1] + 'm';\n  } else {\n    return str;\n  }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n  return str;\n}\n\n\nfunction arrayToHash(array) {\n  var hash = {};\n\n  array.forEach(function(val, idx) {\n    hash[val] = true;\n  });\n\n  return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n  // Provide a hook for user-specified inspect functions.\n  // Check that value is an object with an inspect function on it\n  if (ctx.customInspect &&\n      value &&\n      isFunction(value.inspect) &&\n      // Filter out the util module, it's inspect function is special\n      value.inspect !== exports.inspect &&\n      // Also filter out any prototype objects using the circular check.\n      !(value.constructor && value.constructor.prototype === value)) {\n    var ret = value.inspect(recurseTimes, ctx);\n    if (!isString(ret)) {\n      ret = formatValue(ctx, ret, recurseTimes);\n    }\n    return ret;\n  }\n\n  // Primitive types cannot have properties\n  var primitive = formatPrimitive(ctx, value);\n  if (primitive) {\n    return primitive;\n  }\n\n  // Look up the keys of the object.\n  var keys = Object.keys(value);\n  var visibleKeys = arrayToHash(keys);\n\n  if (ctx.showHidden) {\n    keys = Object.getOwnPropertyNames(value);\n  }\n\n  // IE doesn't make error fields non-enumerable\n  // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n  if (isError(value)\n      && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n    return formatError(value);\n  }\n\n  // Some type of object without properties can be shortcutted.\n  if (keys.length === 0) {\n    if (isFunction(value)) {\n      var name = value.name ? ': ' + value.name : '';\n      return ctx.stylize('[Function' + name + ']', 'special');\n    }\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    }\n    if (isDate(value)) {\n      return ctx.stylize(Date.prototype.toString.call(value), 'date');\n    }\n    if (isError(value)) {\n      return formatError(value);\n    }\n  }\n\n  var base = '', array = false, braces = ['{', '}'];\n\n  // Make Array say that they are Array\n  if (isArray(value)) {\n    array = true;\n    braces = ['[', ']'];\n  }\n\n  // Make functions say that they are functions\n  if (isFunction(value)) {\n    var n = value.name ? ': ' + value.name : '';\n    base = ' [Function' + n + ']';\n  }\n\n  // Make RegExps say that they are RegExps\n  if (isRegExp(value)) {\n    base = ' ' + RegExp.prototype.toString.call(value);\n  }\n\n  // Make dates with properties first say the date\n  if (isDate(value)) {\n    base = ' ' + Date.prototype.toUTCString.call(value);\n  }\n\n  // Make error with message first say the error\n  if (isError(value)) {\n    base = ' ' + formatError(value);\n  }\n\n  if (keys.length === 0 && (!array || value.length == 0)) {\n    return braces[0] + base + braces[1];\n  }\n\n  if (recurseTimes < 0) {\n    if (isRegExp(value)) {\n      return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n    } else {\n      return ctx.stylize('[Object]', 'special');\n    }\n  }\n\n  ctx.seen.push(value);\n\n  var output;\n  if (array) {\n    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n  } else {\n    output = keys.map(function(key) {\n      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n    });\n  }\n\n  ctx.seen.pop();\n\n  return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n  if (isUndefined(value))\n    return ctx.stylize('undefined', 'undefined');\n  if (isString(value)) {\n    var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n                                             .replace(/'/g, \"\\\\'\")\n                                             .replace(/\\\\\"/g, '\"') + '\\'';\n    return ctx.stylize(simple, 'string');\n  }\n  if (isNumber(value))\n    return ctx.stylize('' + value, 'number');\n  if (isBoolean(value))\n    return ctx.stylize('' + value, 'boolean');\n  // For some reason typeof null is \"object\", so special case here.\n  if (isNull(value))\n    return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n  return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n  var output = [];\n  for (var i = 0, l = value.length; i < l; ++i) {\n    if (hasOwnProperty(value, String(i))) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          String(i), true));\n    } else {\n      output.push('');\n    }\n  }\n  keys.forEach(function(key) {\n    if (!key.match(/^\\d+$/)) {\n      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n          key, true));\n    }\n  });\n  return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n  var name, str, desc;\n  desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n  if (desc.get) {\n    if (desc.set) {\n      str = ctx.stylize('[Getter/Setter]', 'special');\n    } else {\n      str = ctx.stylize('[Getter]', 'special');\n    }\n  } else {\n    if (desc.set) {\n      str = ctx.stylize('[Setter]', 'special');\n    }\n  }\n  if (!hasOwnProperty(visibleKeys, key)) {\n    name = '[' + key + ']';\n  }\n  if (!str) {\n    if (ctx.seen.indexOf(desc.value) < 0) {\n      if (isNull(recurseTimes)) {\n        str = formatValue(ctx, desc.value, null);\n      } else {\n        str = formatValue(ctx, desc.value, recurseTimes - 1);\n      }\n      if (str.indexOf('\\n') > -1) {\n        if (array) {\n          str = str.split('\\n').map(function(line) {\n            return '  ' + line;\n          }).join('\\n').substr(2);\n        } else {\n          str = '\\n' + str.split('\\n').map(function(line) {\n            return '   ' + line;\n          }).join('\\n');\n        }\n      }\n    } else {\n      str = ctx.stylize('[Circular]', 'special');\n    }\n  }\n  if (isUndefined(name)) {\n    if (array && key.match(/^\\d+$/)) {\n      return str;\n    }\n    name = JSON.stringify('' + key);\n    if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n      name = name.substr(1, name.length - 2);\n      name = ctx.stylize(name, 'name');\n    } else {\n      name = name.replace(/'/g, \"\\\\'\")\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/(^\"|\"$)/g, \"'\");\n      name = ctx.stylize(name, 'string');\n    }\n  }\n\n  return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n  var numLinesEst = 0;\n  var length = output.reduce(function(prev, cur) {\n    numLinesEst++;\n    if (cur.indexOf('\\n') >= 0) numLinesEst++;\n    return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n  }, 0);\n\n  if (length > 60) {\n    return braces[0] +\n           (base === '' ? '' : base + '\\n ') +\n           ' ' +\n           output.join(',\\n  ') +\n           ' ' +\n           braces[1];\n  }\n\n  return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nfunction isArray(ar) {\n  return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return isObject(e) &&\n      (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n  return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n              'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n  var d = new Date();\n  var time = [pad(d.getHours()),\n              pad(d.getMinutes()),\n              pad(d.getSeconds())].join(':');\n  return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n  console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n *     prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n  // Don't do anything if add isn't an object\n  if (!add || !isObject(add)) return origin;\n\n  var keys = Object.keys(add);\n  var i = keys.length;\n  while (i--) {\n    origin[keys[i]] = add[keys[i]];\n  }\n  return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n  return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\n}).call(this,require(\"1YiZ5S\"),typeof self !== \"undefined\" ? self : typeof window !== \"undefined\" ? window : {})","chai      = require('chai')\nexpect    = chai.expect\nsinon     = require('sinon')\nsinonChai = require('sinon-chai')\n_         = require(\"underscore\")\n\nchai.use(sinonChai)\n\nConnector = require \"../../y-test/lib/y-test.coffee\"\nY = null # need global reference!\n\nmodule.exports = class Test\n  constructor: (@name_suffix = \"\", Yjs)->\n    Y = Yjs\n    @number_of_test_cases_multiplier = 1\n    @repeat_this = 1 * @number_of_test_cases_multiplier\n    @doSomething_amount = 123 * @number_of_test_cases_multiplier\n    @number_of_engines = 5 + @number_of_test_cases_multiplier - 1\n\n    @time = 0 # denotes to the time when run was started\n    @ops = 0 # number of operations (used with @time)\n    @time_now = 0 # current time\n    @max_depth = 3\n\n    @debug = false\n\n    @reinitialize()\n    for gf in @getGeneratingFunctions(0)\n      if not (gf.types? and gf.f?)\n        throw new Error \"Generating Functions are not initialized properly!\"\n      for t in gf.types\n        if not t?\n          throw new Error \"You havent includedt this type in Y (do require 'y-whatever')\"\n\n  reinitialize: ()->\n    @users = []\n    for i in [0...@number_of_engines]\n      u = @makeNewUser (i+@name_suffix)\n      for user in @users\n        u._model.connector.join(user._model.connector) # TODO: change the test-connector to make this more convenient\n      @users.push u\n    @initUsers?(@users[0])\n    @flushAll()\n\n  # is called by implementing class\n  makeNewUser: (user)->\n    user._model.HB.stopGarbageCollection()\n    user\n\n  getSomeUser: ()->\n    i = _.random 0, (@users.length-1)\n    @users[i]\n\n  getRandomText: (chars, min_length = 0)->\n    chars ?= \"abcdefghijklmnopqrstuvwxyz\"\n    length = _.random min_length, 10\n    #length = 1\n    nextchar = chars[(_.random 0, (chars.length-1))]\n    text = \"\"\n    _(length).times ()-> text += nextchar\n    text\n\n  getRandomObject: ()->\n    result = {}\n    key1 = @getRandomKey()\n    key2 = @getRandomKey()\n    val1 = @getRandomText()\n    val2 = null\n    if _.random(0,1) is 1\n      val2 = @getRandomObject()\n    else\n      val2 = @getRandomText()\n    result[key1] = val1\n    result[key2] = val2\n    result\n\n  getRandomKey: ()->\n    @getRandomText [1,2,'x','y'], 1 # only 4 keys\n\n  getGeneratingFunctions: (user_num)=>\n    types = @users[user_num]._model.operations\n    []\n  getRandomRoot: (user_num)->\n    throw new Error \"implement me!\"\n\n  compare: (o1, o2, depth = (@max_depth+1))->\n    if o1 is o2 or depth <= 0\n      true\n    else if o1._name? and o1._name isnt o2._name\n      throw new Error \"different types\"\n    else if o1._model?\n      @compare o1._model, o2._model, depth\n    else if o1.type is \"MapManager\"\n      for name, val of o1.val()\n        @compare(val, o2.val(name), depth-1)\n    else if o1.type is \"ListManager\"\n      for val,i in o1.val()\n        @compare(val, o2.val(i), depth-1)\n    else if o1.constructor is Array and o2.constructor is Array\n      if o1.length isnt o2.length\n        throw new Error \"The Arrays do not have the same size!\"\n      for o,i in o1\n        @compare o, o2[i], (depth-1)\n    else if o1 isnt o2\n      throw new Error \"different values\"\n    else\n      throw new Error \"I don't know what to do .. \"\n\n  generateRandomOp: (user_num)=>\n    y = @getRandomRoot(user_num)\n    choices = @getGeneratingFunctions(user_num).filter (gf)->\n      _.some gf.types, (type)->\n        y instanceof type\n\n    if choices.length is 0\n      console.dir(y)\n      throw new Error \"You forgot to specify a test generation methot for this Operation! (#{y.type})\"\n    i = _.random 0, (choices.length-1)\n    choices[i].f y\n\n  applyRandomOp: (user_num)=>\n    user = @users[user_num]\n    user._model.connector.flushOneRandom()\n\n  doSomething: ()->\n    user_num = _.random (@number_of_engines-1)\n    choices = [@applyRandomOp, @generateRandomOp]\n    choice = _.random (choices.length-1)\n    choices[choice](user_num)\n\n  flushAll: (final)->\n    # TODO:!!\n    final = false\n    if @users.length <= 1 or not final\n      for user,user_number in @users\n        user._model.connector.flushAll()\n    else\n      for user,user_number in @users[1..]\n        user._model.connector.flushAll()\n      ops = @users[1].getHistoryBuffer()._encode @users[0].HB.getOperationCounter()\n      @users[0].engine.applyOpsCheckDouble ops\n\n\n  compareAll: (test_number)->\n    @flushAll(true)\n\n    @time += (new Date()).getTime() - @time_now\n\n    number_of_created_operations = 0\n    for i in [0...(@users.length)]\n      number_of_created_operations += @users[i]._model.connector.getOpsInExecutionOrder().length\n    @ops += number_of_created_operations*@users.length\n\n    ops_per_msek = Math.floor(@ops/@time)\n    if test_number? # and @debug\n      console.log \"#{test_number}/#{@repeat_this}: #{number_of_created_operations} were created and applied on (#{@users.length}) users ops in a different order.\" + \" Over all we consumed #{@ops} operations in #{@time/1000} seconds (#{ops_per_msek} ops/msek).\"\n\n    for i in [0...(@users.length-1)]\n      if @debug\n        if not _.isEqual @getContent(i), @getContent(i+1)\n          printOpsInExecutionOrder = (otnumber, otherotnumber)=>\n            ops = _.filter @users[otnumber]._model.connector.getOpsInExecutionOrder(), (o)->\n              typeof o.uid.op_name isnt 'string' and o.uid.creator isnt '_'\n            for s,j in ops\n              console.log \"op#{j} = \" + (JSON.stringify s)\n            console.log \"\"\n            s = \"ops = [\"\n            for o,j in ops\n              if j isnt 0\n                s += \", \"\n              s += \"op#{j}\"\n            s += \"]\"\n            console.log s\n            console.log \"@test_user.engine.applyOps ops\"\n            console.log \"expect(@test_user.val('name').val()).to.equal(\\\"#{@users[otherotnumber].val('name').val()}\\\")\"\n            ops\n          console.log \"\"\n          console.log \"Found an OT Puzzle!\"\n          console.log \"OT states:\"\n          for u,j in @users\n            console.log \"OT#{j}: \"+u.val('name').val()\n          console.log \"\\nOT execution order (#{i},#{i+1}):\"\n          printOpsInExecutionOrder i, i+1\n          console.log \"\"\n          ops = printOpsInExecutionOrder i+1, i\n\n          console.log \"\"\n      expect(@compare(@users[i], @users[i+1])).to.not.be.undefined\n\n  run: ()->\n    if @debug\n      console.log ''\n    for times in [1..@repeat_this]\n      @time_now = (new Date).getTime()\n      for i in [1..Math.floor(@doSomething_amount/2)]\n        @doSomething()\n      @flushAll(false)\n      for u in @users\n        u._model.HB.emptyGarbage()\n      for i in [1..Math.floor(@doSomething_amount/2)]\n        @doSomething()\n\n      @compareAll(times)\n      @testHBencoding()\n      if times isnt @repeat_this\n        @reinitialize()\n\n  testHBencoding: ()->\n    # in case of JsonFramework, every user will create its JSON first! therefore, the testusers id must be small than all the others (see InsertType)\n    @users[@users.length] = @makeNewUser (-1) # this does not want to join with anymody\n\n    @users[@users.length-1]._model.HB.renewStateVector @users[0]._model.HB.getOperationCounter()\n    @users[@users.length-1]._model.engine.applyOps @users[0]._model.HB._encode()\n\n    #if @getContent(@users.length-1) isnt @getContent(0)\n    #  console.log \"testHBencoding:\"\n    #  console.log \"Unprocessed ops first: #{@users[0].engine.unprocessed_ops.length}\"\n    #  console.log \"Unprocessed ops last: #{@users[@users.length-1].engine.unprocessed_ops.length}\"\n    expect(@compare(@users[@users.length-1], @users[0])).to.not.be.undefined\n"]}