16590 lines
1.3 MiB
16590 lines
1.3 MiB
(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 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;
|
||
}
|
||
|
||
|
||
},{}],2:[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":3}],3:[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;
|
||
},
|
||
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) {
|
||
delete this.connections[user];
|
||
return this.findNewSyncTarget();
|
||
},
|
||
userJoined: function(user, role) {
|
||
var _base;
|
||
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") {
|
||
return this.performSync(user);
|
||
} else if (role === "master") {
|
||
return this.performSyncWithMaster(user);
|
||
}
|
||
}
|
||
},
|
||
whenSynced: function(args) {
|
||
if (args.constructore === 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: []
|
||
});
|
||
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 > 30) {
|
||
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: []
|
||
});
|
||
hb = this.getHB([]).hb;
|
||
_hb = [];
|
||
for (_i = 0, _len = hb.length; _i < _len; _i++) {
|
||
o = hb[_i];
|
||
_hb.push(o);
|
||
if (_hb.length > 30) {
|
||
this.broadcast({
|
||
sync_step: "applyHB_",
|
||
data: _hb
|
||
});
|
||
_hb = [];
|
||
}
|
||
}
|
||
return this.broadcast({
|
||
sync_step: "applyHB",
|
||
data: _hb
|
||
});
|
||
},
|
||
setStateSynced: function() {
|
||
var 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++) {
|
||
f = _ref[_i];
|
||
f();
|
||
}
|
||
delete this.compute_when_synced;
|
||
}
|
||
return null;
|
||
}
|
||
},
|
||
receiveMessage: function(sender, res) {
|
||
var data, f, hb, o, sendApplyHB, send_again, _hb, _i, _j, _len, _len1, _ref, _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") {
|
||
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 (_j = 0, _len1 = hb.length; _j < _len1; _j++) {
|
||
o = hb[_j];
|
||
_hb.push(o);
|
||
if (_hb.length > 30) {
|
||
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() {
|
||
hb = _this.getHB(sv).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;
|
||
}
|
||
};
|
||
|
||
|
||
},{}],4:[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;
|
||
|
||
|
||
},{}],5:[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.resetUserId = function(id) {
|
||
var o, o_name, own;
|
||
own = this.buffer[this.user_id];
|
||
if (own != null) {
|
||
for (o_name in own) {
|
||
o = own[o_name];
|
||
if (o.uid.creator != null) {
|
||
o.uid.creator = id;
|
||
}
|
||
if (o.uid.alt != null) {
|
||
o.uid.alt.creator = id;
|
||
}
|
||
}
|
||
if (this.buffer[id] != null) {
|
||
throw new Error("You are re-assigning an old user id - this is not (yet) possible!");
|
||
}
|
||
this.buffer[id] = own;
|
||
delete this.buffer[this.user_id];
|
||
}
|
||
if (this.operation_counter[this.user_id] != null) {
|
||
this.operation_counter[id] = this.operation_counter[this.user_id];
|
||
delete this.operation_counter[this.user_id];
|
||
}
|
||
return this.user_id = id;
|
||
};
|
||
|
||
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.creator !== this.getUserId()) {
|
||
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;
|
||
|
||
|
||
},{}],6:[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) {
|
||
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;
|
||
}
|
||
}
|
||
|
||
Operation.prototype.type = "Operation";
|
||
|
||
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;
|
||
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;
|
||
};
|
||
|
||
Operation.prototype._encode = function(json) {
|
||
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;
|
||
}
|
||
}
|
||
return json;
|
||
};
|
||
|
||
Operation.prototype.saveOperation = function(name, op) {
|
||
if (op == null) {
|
||
|
||
} else if ((op.execute != null) || !((op.op_number != null) && (op.creator != null))) {
|
||
return this[name] = op;
|
||
} else {
|
||
if (this.unchecked == null) {
|
||
this.unchecked = {};
|
||
}
|
||
return this.unchecked[name] = op;
|
||
}
|
||
};
|
||
|
||
Operation.prototype.validateSavedOperations = function() {
|
||
var name, op, op_uid, success, uninstantiated, _ref;
|
||
uninstantiated = {};
|
||
success = this;
|
||
_ref = this.unchecked;
|
||
for (name in _ref) {
|
||
op_uid = _ref[name];
|
||
op = this.HB.getOperation(op_uid);
|
||
if (op) {
|
||
this[name] = op;
|
||
} else {
|
||
uninstantiated[name] = op_uid;
|
||
success = false;
|
||
}
|
||
}
|
||
delete this.unchecked;
|
||
if (!success) {
|
||
this.unchecked = uninstantiated;
|
||
}
|
||
return success;
|
||
};
|
||
|
||
Operation.prototype.getCustomType = function() {
|
||
if (this.custom_type == null) {
|
||
throw new Error("This operation was not initialized with a custom type");
|
||
}
|
||
if (this.custom_type.constructor === String) {
|
||
this.custom_type = new this.custom_types[this.custom_type]();
|
||
this.custom_type._setModel(this);
|
||
}
|
||
return this.custom_type;
|
||
};
|
||
|
||
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, uid, prev_cl, next_cl, origin, parent) {
|
||
if (content === void 0) {
|
||
|
||
} else if ((content != null) && (content.creator != null)) {
|
||
this.saveOperation('content', content);
|
||
} else {
|
||
this.content = content;
|
||
}
|
||
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);
|
||
}
|
||
|
||
Insert.prototype.type = "Insert";
|
||
|
||
Insert.prototype.val = function() {
|
||
if ((this.content != null) && (this.content.getCustomType != null)) {
|
||
return this.content.getCustomType();
|
||
} else {
|
||
return this.content;
|
||
}
|
||
};
|
||
|
||
Insert.prototype.applyDelete = function(o) {
|
||
var callLater, garbagecollect, _ref;
|
||
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.callOperationSpecificDeleteEvents(o);
|
||
}
|
||
if ((_ref = this.prev_cl) != null ? _ref.isDeleted() : void 0) {
|
||
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 && !deleted_earlyer) {
|
||
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.callOperationSpecificInsertEvents();
|
||
return this;
|
||
}
|
||
};
|
||
|
||
Insert.prototype.callOperationSpecificInsertEvents = function() {
|
||
var getContentType, _ref;
|
||
getContentType = function(content) {
|
||
if (content instanceof ops.Operation) {
|
||
return content.getCustomType();
|
||
} else {
|
||
return content;
|
||
}
|
||
};
|
||
return (_ref = this.parent) != null ? _ref.callEvent([
|
||
{
|
||
type: "insert",
|
||
position: this.getPosition(),
|
||
object: this.parent.getCustomType(),
|
||
changedBy: this.uid.creator,
|
||
value: getContentType(this.content)
|
||
}
|
||
]) : void 0;
|
||
};
|
||
|
||
Insert.prototype.callOperationSpecificDeleteEvents = function(o) {
|
||
return this.parent.callEvent([
|
||
{
|
||
type: "delete",
|
||
position: this.getPosition(),
|
||
object: this.parent.getCustomType(),
|
||
length: 1,
|
||
changedBy: o.uid.creator,
|
||
oldValue: this.val()
|
||
}
|
||
]);
|
||
};
|
||
|
||
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) {
|
||
var _ref;
|
||
if (json == null) {
|
||
json = {};
|
||
}
|
||
json.prev = this.prev_cl.getUid();
|
||
json.next = this.next_cl.getUid();
|
||
json.parent = this.parent.getUid();
|
||
if (this.origin.type === "Delimiter") {
|
||
json.origin = "Delimiter";
|
||
} else if (this.origin !== this.prev_cl) {
|
||
json.origin = this.origin.getUid();
|
||
}
|
||
if (((_ref = this.content) != null ? _ref.getUid : void 0) != null) {
|
||
json['content'] = this.content.getUid();
|
||
} else {
|
||
json['content'] = JSON.stringify(this.content);
|
||
}
|
||
return Insert.__super__._encode.call(this, json);
|
||
};
|
||
|
||
return Insert;
|
||
|
||
})(ops.Operation);
|
||
ops.Insert.parse = function(json) {
|
||
var content, next, origin, parent, prev, uid;
|
||
content = json['content'], uid = json['uid'], prev = json['prev'], next = json['next'], origin = json['origin'], parent = json['parent'];
|
||
if (typeof content === "string") {
|
||
content = JSON.parse(content);
|
||
}
|
||
return new this(null, content, uid, prev, next, origin, parent);
|
||
};
|
||
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
|
||
};
|
||
};
|
||
|
||
|
||
},{}],7:[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) {
|
||
this._map = {};
|
||
MapManager.__super__.constructor.call(this, custom_type, uid);
|
||
}
|
||
|
||
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 custom_type, uid;
|
||
uid = json['uid'], custom_type = json['custom_type'];
|
||
return new this(custom_type, uid);
|
||
};
|
||
ops.ListManager = (function(_super) {
|
||
__extends(ListManager, _super);
|
||
|
||
function ListManager(custom_type, uid) {
|
||
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);
|
||
}
|
||
|
||
ListManager.prototype.type = "ListManager";
|
||
|
||
ListManager.prototype.applyDelete = function() {
|
||
var o;
|
||
o = this.end;
|
||
while (o != null) {
|
||
o.applyDelete();
|
||
o = o.prev_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.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, 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, 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;
|
||
};
|
||
|
||
return ListManager;
|
||
|
||
})(ops.Operation);
|
||
ops.ListManager.parse = function(json) {
|
||
var custom_type, uid;
|
||
uid = json['uid'], custom_type = json['custom_type'];
|
||
return new this(custom_type, uid);
|
||
};
|
||
ops.ReplaceManager = (function(_super) {
|
||
__extends(ReplaceManager, _super);
|
||
|
||
function ReplaceManager(custom_type, event_properties, event_this, uid, beginning, end) {
|
||
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, beginning, end);
|
||
}
|
||
|
||
ReplaceManager.prototype.type = "ReplaceManager";
|
||
|
||
ReplaceManager.prototype.applyDelete = function() {
|
||
var o;
|
||
o = this.beginning;
|
||
while (o != null) {
|
||
o.applyDelete();
|
||
o = o.next_cl;
|
||
}
|
||
return ReplaceManager.__super__.applyDelete.call(this);
|
||
};
|
||
|
||
ReplaceManager.prototype.cleanup = function() {
|
||
return ReplaceManager.__super__.cleanup.call(this);
|
||
};
|
||
|
||
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.replace = function(content, replaceable_uid) {
|
||
var o, relp;
|
||
o = this.getLastOperation();
|
||
relp = (new ops.Replaceable(null, content, this, replaceable_uid, o, o.next_cl)).execute();
|
||
return void 0;
|
||
};
|
||
|
||
ReplaceManager.prototype.isContentDeleted = function() {
|
||
return this.getLastOperation().isDeleted();
|
||
};
|
||
|
||
ReplaceManager.prototype.deleteContent = function() {
|
||
(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;
|
||
};
|
||
|
||
ReplaceManager.prototype._encode = function(json) {
|
||
if (json == null) {
|
||
json = {};
|
||
}
|
||
json.beginning = this.beginning.getUid();
|
||
json.end = this.end.getUid();
|
||
return ReplaceManager.__super__._encode.call(this, json);
|
||
};
|
||
|
||
return ReplaceManager;
|
||
|
||
})(ops.ListManager);
|
||
ops.Replaceable = (function(_super) {
|
||
__extends(Replaceable, _super);
|
||
|
||
function Replaceable(custom_type, content, parent, uid, prev, next, origin) {
|
||
this.saveOperation('parent', parent);
|
||
Replaceable.__super__.constructor.call(this, custom_type, content, uid, prev, next, origin);
|
||
}
|
||
|
||
Replaceable.prototype.type = "Replaceable";
|
||
|
||
Replaceable.prototype.callOperationSpecificInsertEvents = function() {
|
||
var old_value;
|
||
if (this.next_cl.type === "Delimiter" && this.prev_cl.type !== "Delimiter") {
|
||
if (!this.is_deleted) {
|
||
old_value = this.prev_cl.val();
|
||
this.parent.callEventDecorator([
|
||
{
|
||
type: "update",
|
||
changedBy: this.uid.creator,
|
||
oldValue: old_value
|
||
}
|
||
]);
|
||
}
|
||
this.prev_cl.applyDelete();
|
||
} else if (this.next_cl.type !== "Delimiter") {
|
||
this.applyDelete();
|
||
} else {
|
||
this.parent.callEventDecorator([
|
||
{
|
||
type: "add",
|
||
changedBy: this.uid.creator
|
||
}
|
||
]);
|
||
}
|
||
return void 0;
|
||
};
|
||
|
||
Replaceable.prototype.callOperationSpecificDeleteEvents = function(o) {
|
||
if (this.next_cl.type === "Delimiter") {
|
||
return this.parent.callEventDecorator([
|
||
{
|
||
type: "delete",
|
||
changedBy: o.uid.creator,
|
||
oldValue: this.val()
|
||
}
|
||
]);
|
||
}
|
||
};
|
||
|
||
Replaceable.prototype._encode = function(json) {
|
||
if (json == null) {
|
||
json = {};
|
||
}
|
||
return Replaceable.__super__._encode.call(this, json);
|
||
};
|
||
|
||
return Replaceable;
|
||
|
||
})(ops.Insert);
|
||
ops.Replaceable.parse = function(json) {
|
||
var content, custom_type, next, origin, parent, prev, uid;
|
||
content = json['content'], parent = json['parent'], uid = json['uid'], prev = json['prev'], next = json['next'], origin = json['origin'], custom_type = json['custom_type'];
|
||
if (typeof content === "string") {
|
||
content = JSON.parse(content);
|
||
}
|
||
return new this(custom_type, content, parent, uid, prev, next, origin);
|
||
};
|
||
return basic_ops;
|
||
};
|
||
|
||
|
||
},{"./Basic":6}],8:[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;
|
||
}
|
||
|
||
|
||
},{}],9:[function(require,module,exports){
|
||
var YText;
|
||
|
||
YText = (function() {
|
||
function YText(text) {
|
||
this.textfields = [];
|
||
if (text == null) {
|
||
this._text = "";
|
||
} else if (text.constructor === String) {
|
||
this._text = text;
|
||
} else {
|
||
throw new Error("Y.Text expects a String as a constructor");
|
||
}
|
||
}
|
||
|
||
YText.prototype._name = "Text";
|
||
|
||
YText.prototype._getModel = function(types, ops) {
|
||
if (this._model == null) {
|
||
this._model = new ops.ListManager(this).execute();
|
||
this.insert(0, this._text);
|
||
}
|
||
delete this._text;
|
||
return this._model;
|
||
};
|
||
|
||
YText.prototype._setModel = function(_model) {
|
||
this._model = _model;
|
||
return delete this._text;
|
||
};
|
||
|
||
YText.prototype.val = function() {
|
||
return this._model.fold("", function(left, o) {
|
||
return left + o.val();
|
||
});
|
||
};
|
||
|
||
YText.prototype.observe = function() {
|
||
return this._model.observe.apply(this._model, arguments);
|
||
};
|
||
|
||
YText.prototype.unobserve = function() {
|
||
return this._model.unobserve.apply(this._model, arguments);
|
||
};
|
||
|
||
YText.prototype.toString = function() {
|
||
return this.val();
|
||
};
|
||
|
||
YText.prototype.insert = function(position, content) {
|
||
var ith;
|
||
if (content.constructor !== String) {
|
||
throw new Error("Y.String.insert expects a String as the second parameter!");
|
||
}
|
||
if (typeof position !== "number") {
|
||
throw new Error("Y.String.insert expects a Number as the first parameter!");
|
||
}
|
||
if (content.length > 0) {
|
||
ith = this._model.getOperationByPosition(position);
|
||
return this._model.insertAfter(ith, content);
|
||
}
|
||
};
|
||
|
||
YText.prototype["delete"] = function(position, length) {
|
||
return this._model["delete"](position, length);
|
||
};
|
||
|
||
YText.prototype.bind = function(textfield, dom_root) {
|
||
var createRange, creator_token, t, word, writeContent, writeRange, _i, _len, _ref;
|
||
if (dom_root == null) {
|
||
dom_root = window;
|
||
}
|
||
if (dom_root.getSelection == null) {
|
||
dom_root = window;
|
||
}
|
||
_ref = this.textfields;
|
||
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
|
||
t = _ref[_i];
|
||
if (t === textfield) {
|
||
return;
|
||
}
|
||
}
|
||
creator_token = false;
|
||
word = this;
|
||
textfield.value = this.val();
|
||
this.textfields.push(textfield);
|
||
if ((textfield.selectionStart != null) && (textfield.setSelectionRange != null)) {
|
||
createRange = function(fix) {
|
||
var left, right;
|
||
left = textfield.selectionStart;
|
||
right = textfield.selectionEnd;
|
||
if (fix != null) {
|
||
left = fix(left);
|
||
right = fix(right);
|
||
}
|
||
return {
|
||
left: left,
|
||
right: right
|
||
};
|
||
};
|
||
writeRange = function(range) {
|
||
writeContent(word.val());
|
||
return textfield.setSelectionRange(range.left, range.right);
|
||
};
|
||
writeContent = function(content) {
|
||
return textfield.value = content;
|
||
};
|
||
} else {
|
||
createRange = function(fix) {
|
||
var clength, edited_element, range, s;
|
||
range = {};
|
||
s = dom_root.getSelection();
|
||
clength = textfield.textContent.length;
|
||
range.left = Math.min(s.anchorOffset, clength);
|
||
range.right = Math.min(s.focusOffset, clength);
|
||
if (fix != null) {
|
||
range.left = fix(range.left);
|
||
range.right = fix(range.right);
|
||
}
|
||
edited_element = s.focusNode;
|
||
if (edited_element === textfield || edited_element === textfield.childNodes[0]) {
|
||
range.isReal = true;
|
||
} else {
|
||
range.isReal = false;
|
||
}
|
||
return range;
|
||
};
|
||
writeRange = function(range) {
|
||
var r, s, textnode;
|
||
writeContent(word.val());
|
||
textnode = textfield.childNodes[0];
|
||
if (range.isReal && (textnode != null)) {
|
||
if (range.left < 0) {
|
||
range.left = 0;
|
||
}
|
||
range.right = Math.max(range.left, range.right);
|
||
if (range.right > textnode.length) {
|
||
range.right = textnode.length;
|
||
}
|
||
range.left = Math.min(range.left, range.right);
|
||
r = document.createRange();
|
||
r.setStart(textnode, range.left);
|
||
r.setEnd(textnode, range.right);
|
||
s = window.getSelection();
|
||
s.removeAllRanges();
|
||
return s.addRange(r);
|
||
}
|
||
};
|
||
writeContent = function(content) {
|
||
var c, content_array, i, _j, _len1, _results;
|
||
content_array = content.replace(new RegExp("\n", 'g'), " ").split(" ");
|
||
textfield.innerText = "";
|
||
_results = [];
|
||
for (i = _j = 0, _len1 = content_array.length; _j < _len1; i = ++_j) {
|
||
c = content_array[i];
|
||
textfield.innerText += c;
|
||
if (i !== content_array.length - 1) {
|
||
_results.push(textfield.innerHTML += ' ');
|
||
} else {
|
||
_results.push(void 0);
|
||
}
|
||
}
|
||
return _results;
|
||
};
|
||
}
|
||
writeContent(this.val());
|
||
this.observe(function(events) {
|
||
var event, fix, o_pos, r, _j, _len1, _results;
|
||
_results = [];
|
||
for (_j = 0, _len1 = events.length; _j < _len1; _j++) {
|
||
event = events[_j];
|
||
if (!creator_token) {
|
||
if (event.type === "insert") {
|
||
o_pos = event.position;
|
||
fix = function(cursor) {
|
||
if (cursor <= o_pos) {
|
||
return cursor;
|
||
} else {
|
||
cursor += 1;
|
||
return cursor;
|
||
}
|
||
};
|
||
r = createRange(fix);
|
||
_results.push(writeRange(r));
|
||
} else if (event.type === "delete") {
|
||
o_pos = event.position;
|
||
fix = function(cursor) {
|
||
if (cursor < o_pos) {
|
||
return cursor;
|
||
} else {
|
||
cursor -= 1;
|
||
return cursor;
|
||
}
|
||
};
|
||
r = createRange(fix);
|
||
_results.push(writeRange(r));
|
||
} else {
|
||
_results.push(void 0);
|
||
}
|
||
} else {
|
||
_results.push(void 0);
|
||
}
|
||
}
|
||
return _results;
|
||
});
|
||
textfield.onkeypress = function(event) {
|
||
var char, diff, pos, r;
|
||
if (word.is_deleted) {
|
||
textfield.onkeypress = null;
|
||
return true;
|
||
}
|
||
creator_token = true;
|
||
char = null;
|
||
if (event.keyCode === 13) {
|
||
char = '\n';
|
||
} else if (event.key != null) {
|
||
if (event.charCode === 32) {
|
||
char = " ";
|
||
} else {
|
||
char = event.key;
|
||
}
|
||
} else {
|
||
char = window.String.fromCharCode(event.keyCode);
|
||
}
|
||
if (char.length > 1) {
|
||
return true;
|
||
} else if (char.length > 0) {
|
||
r = createRange();
|
||
pos = Math.min(r.left, r.right);
|
||
diff = Math.abs(r.right - r.left);
|
||
word["delete"](pos, diff);
|
||
word.insert(pos, char);
|
||
r.left = pos + char.length;
|
||
r.right = r.left;
|
||
writeRange(r);
|
||
}
|
||
event.preventDefault();
|
||
creator_token = false;
|
||
return false;
|
||
};
|
||
textfield.onpaste = function(event) {
|
||
if (word.is_deleted) {
|
||
textfield.onpaste = null;
|
||
return true;
|
||
}
|
||
return event.preventDefault();
|
||
};
|
||
textfield.oncut = function(event) {
|
||
if (word.is_deleted) {
|
||
textfield.oncut = null;
|
||
return true;
|
||
}
|
||
return event.preventDefault();
|
||
};
|
||
return textfield.onkeydown = function(event) {
|
||
var del_length, diff, new_pos, pos, r, val;
|
||
creator_token = true;
|
||
if (word.is_deleted) {
|
||
textfield.onkeydown = null;
|
||
return true;
|
||
}
|
||
r = createRange();
|
||
pos = Math.min(r.left, r.right, word.val().length);
|
||
diff = Math.abs(r.left - r.right);
|
||
if ((event.keyCode != null) && event.keyCode === 8) {
|
||
if (diff > 0) {
|
||
word["delete"](pos, diff);
|
||
r.left = pos;
|
||
r.right = pos;
|
||
writeRange(r);
|
||
} else {
|
||
if ((event.ctrlKey != null) && event.ctrlKey) {
|
||
val = word.val();
|
||
new_pos = pos;
|
||
del_length = 0;
|
||
if (pos > 0) {
|
||
new_pos--;
|
||
del_length++;
|
||
}
|
||
while (new_pos > 0 && val[new_pos] !== " " && val[new_pos] !== '\n') {
|
||
new_pos--;
|
||
del_length++;
|
||
}
|
||
word["delete"](new_pos, pos - new_pos);
|
||
r.left = new_pos;
|
||
r.right = new_pos;
|
||
writeRange(r);
|
||
} else {
|
||
if (pos > 0) {
|
||
word["delete"](pos - 1, 1);
|
||
r.left = pos - 1;
|
||
r.right = pos - 1;
|
||
writeRange(r);
|
||
}
|
||
}
|
||
}
|
||
event.preventDefault();
|
||
creator_token = false;
|
||
return false;
|
||
} else if ((event.keyCode != null) && event.keyCode === 46) {
|
||
if (diff > 0) {
|
||
word["delete"](pos, diff);
|
||
r.left = pos;
|
||
r.right = pos;
|
||
writeRange(r);
|
||
} else {
|
||
word["delete"](pos, 1);
|
||
r.left = pos;
|
||
r.right = pos;
|
||
writeRange(r);
|
||
}
|
||
event.preventDefault();
|
||
creator_token = false;
|
||
return false;
|
||
} else {
|
||
creator_token = false;
|
||
return true;
|
||
}
|
||
};
|
||
};
|
||
|
||
return YText;
|
||
|
||
})();
|
||
|
||
if (typeof window !== "undefined" && window !== null) {
|
||
if (window.Y != null) {
|
||
window.Y.Text = YText;
|
||
} else {
|
||
throw new Error("You must first import Y!");
|
||
}
|
||
}
|
||
|
||
if (typeof module !== "undefined" && module !== null) {
|
||
module.exports = YText;
|
||
}
|
||
|
||
|
||
},{}],10:[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;
|
||
user_id = null;
|
||
if (connector.user_id != null) {
|
||
user_id = connector.user_id;
|
||
} else {
|
||
user_id = "_temp";
|
||
connector.on_user_id_set = function(id) {
|
||
user_id = id;
|
||
return HB.resetUserId(id);
|
||
};
|
||
}
|
||
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("./Types/Object");
|
||
|
||
|
||
},{"./ConnectorAdapter":2,"./Engine":4,"./HistoryBuffer":5,"./Operations/Structured":7,"./Types/Object":8}],11:[function(require,module,exports){
|
||
module.exports = require('./lib/chai');
|
||
|
||
},{"./lib/chai":12}],12:[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 = '1.10.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;
|
||
};
|
||
|
||
/*!
|
||
* 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":13,"./chai/config":14,"./chai/core/assertions":15,"./chai/interface/assert":16,"./chai/interface/expect":17,"./chai/interface/should":18,"./chai/utils":29,"assertion-error":38}],13:[function(require,module,exports){
|
||
/*!
|
||
* chai
|
||
* http://chaijs.com
|
||
* Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
|
||
* MIT Licensed
|
||
*/
|
||
|
||
var config = require('./config');
|
||
var NOOP = function() { };
|
||
|
||
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.addChainableNoop = function(name, fn) {
|
||
util.addChainableMethod(this.prototype, name, NOOP, fn);
|
||
};
|
||
|
||
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 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`
|
||
* @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":14}],14:[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,
|
||
* the value is truncated.
|
||
*
|
||
* Set it to zero if you want to disable truncating altogether.
|
||
*
|
||
* chai.config.truncateThreshold = 0; // disable truncating
|
||
*
|
||
* @param {Number}
|
||
* @api public
|
||
*/
|
||
|
||
truncateThreshold: 40
|
||
|
||
};
|
||
|
||
},{}],15:[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
|
||
* - and
|
||
* - has
|
||
* - have
|
||
* - with
|
||
* - at
|
||
* - of
|
||
* - same
|
||
*
|
||
* @name language chains
|
||
* @api public
|
||
*/
|
||
|
||
[ 'to', 'be', 'been'
|
||
, 'is', 'and', 'has', 'have'
|
||
, 'with', 'that', 'at'
|
||
, 'of', 'same' ].forEach(function (chain) {
|
||
Assertion.addProperty(chain, function () {
|
||
return this;
|
||
});
|
||
});
|
||
|
||
/**
|
||
* ### .not
|
||
*
|
||
* Negates any of assertions following in the chain.
|
||
*
|
||
* expect(foo).to.not.equal('bar');
|
||
* expect(goodFn).to.not.throw(Error);
|
||
* expect({ foo: 'baz' }).to.have.property('foo')
|
||
* .and.not.equal('bar');
|
||
*
|
||
* @name not
|
||
* @api public
|
||
*/
|
||
|
||
Assertion.addProperty('not', function () {
|
||
flag(this, 'negate', true);
|
||
});
|
||
|
||
/**
|
||
* ### .deep
|
||
*
|
||
* Sets the `deep` flag, later used by the `equal` and
|
||
* `property` assertions.
|
||
*
|
||
* expect(foo).to.deep.equal({ bar: 'baz' });
|
||
* expect({ foo: { bar: { baz: 'quux' } } })
|
||
* .to.have.deep.property('foo.bar.baz', 'quux');
|
||
*
|
||
* @name deep
|
||
* @api public
|
||
*/
|
||
|
||
Assertion.addProperty('deep', function () {
|
||
flag(this, 'deep', true);
|
||
});
|
||
|
||
/**
|
||
* ### .a(type)
|
||
*
|
||
* The `a` and `an` assertions are aliases that can be
|
||
* used either as language chains or to assert a value's
|
||
* type.
|
||
*
|
||
* // typeof
|
||
* expect('test').to.be.a('string');
|
||
* expect({ foo: 'bar' }).to.be.an('object');
|
||
* expect(null).to.be.a('null');
|
||
* expect(undefined).to.be.an('undefined');
|
||
*
|
||
* // language chain
|
||
* expect(foo).to.be.an.instanceof(Foo);
|
||
*
|
||
* @name a
|
||
* @alias an
|
||
* @param {String} type
|
||
* @param {String} message _optional_
|
||
* @api public
|
||
*/
|
||
|
||
function an (type, msg) {
|
||
if (msg) flag(this, 'message', msg);
|
||
type = type.toLowerCase();
|
||
var obj = flag(this, 'object')
|
||
, article = ~[ 'a', 'e', 'i', 'o', 'u' ].indexOf(type.charAt(0)) ? 'an ' : 'a ';
|
||
|
||
this.assert(
|
||
type === _.type(obj)
|
||
, 'expected #{this} to be ' + article + type
|
||
, 'expected #{this} not to be ' + article + type
|
||
);
|
||
}
|
||
|
||
Assertion.addChainableMethod('an', an);
|
||
Assertion.addChainableMethod('a', an);
|
||
|
||
/**
|
||
* ### .include(value)
|
||
*
|
||
* The `include` and `contain` assertions can be used as either property
|
||
* based language chains or as methods to assert the inclusion of an object
|
||
* in an array or a substring in a string. When used as language chains,
|
||
* they toggle the `contain` flag for the `keys` assertion.
|
||
*
|
||
* expect([1,2,3]).to.include(2);
|
||
* expect('foobar').to.contain('foo');
|
||
* expect({ foo: 'bar', hello: 'universe' }).to.include.keys('foo');
|
||
*
|
||
* @name include
|
||
* @alias contain
|
||
* @param {Object|String|Number} obj
|
||
* @param {String} message _optional_
|
||
* @api public
|
||
*/
|
||
|
||
function includeChainingBehavior () {
|
||
flag(this, 'contains', true);
|
||
}
|
||
|
||
function include (val, msg) {
|
||
if (msg) flag(this, 'message', msg);
|
||
var obj = flag(this, 'object');
|
||
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);
|
||
|
||
/**
|
||
* ### .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;
|
||
*
|
||
* Can also be used as a function, which prevents some linter errors.
|
||
*
|
||
* expect('everthing').to.be.ok();
|
||
*
|
||
* @name ok
|
||
* @api public
|
||
*/
|
||
|
||
Assertion.addChainableNoop('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;
|
||
*
|
||
* Can also be used as a function, which prevents some linter errors.
|
||
*
|
||
* expect(true).to.be.true();
|
||
*
|
||
* @name true
|
||
* @api public
|
||
*/
|
||
|
||
Assertion.addChainableNoop('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;
|
||
*
|
||
* Can also be used as a function, which prevents some linter errors.
|
||
*
|
||
* expect(false).to.be.false();
|
||
*
|
||
* @name false
|
||
* @api public
|
||
*/
|
||
|
||
Assertion.addChainableNoop('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;
|
||
*
|
||
* Can also be used as a function, which prevents some linter errors.
|
||
*
|
||
* expect(null).to.be.null();
|
||
*
|
||
* @name null
|
||
* @api public
|
||
*/
|
||
|
||
Assertion.addChainableNoop('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;
|
||
*
|
||
* Can also be used as a function, which prevents some linter errors.
|
||
*
|
||
* expect(undefined).to.be.undefined();
|
||
*
|
||
* @name undefined
|
||
* @api public
|
||
*/
|
||
|
||
Assertion.addChainableNoop('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;
|
||
*
|
||
* Can also be used as a function, which prevents some linter errors.
|
||
*
|
||
* expect(foo).to.exist();
|
||
*
|
||
* @name exist
|
||
* @api public
|
||
*/
|
||
|
||
Assertion.addChainableNoop('exist', function () {
|
||
this.assert(
|
||
null != flag(this, 'object')
|
||
, 'expected #{this} to exist'
|
||
, 'expected #{this} to not exist'
|
||
);
|
||
});
|
||
|
||
|
||
/**
|
||
* ### .empty
|
||
*
|
||
* Asserts that the target's length is `0`. For arrays, it checks
|
||
* the `length` property. For objects, it gets the count of
|
||
* enumerable keys.
|
||
*
|
||
* expect([]).to.be.empty;
|
||
* expect('').to.be.empty;
|
||
* expect({}).to.be.empty;
|
||
*
|
||
* Can also be used as a function, which prevents some linter errors.
|
||
*
|
||
* expect([]).to.be.empty();
|
||
*
|
||
* @name empty
|
||
* @api public
|
||
*/
|
||
|
||
Assertion.addChainableNoop('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;
|
||
* }
|
||
*
|
||
* Can also be used as a function, which prevents some linter errors.
|
||
*
|
||
* 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.addChainableNoop('arguments', checkArguments);
|
||
Assertion.addChainableNoop('Arguments', checkArguments);
|
||
|
||
/**
|
||
* ### .equal(value)
|
||
*
|
||
* Asserts that the target is strictly equal (`===`) to `value`.
|
||
* Alternately, if the `deep` flag is set, asserts that
|
||
* the target is deeply equal to `value`.
|
||
*
|
||
* expect('hello').to.equal('hello');
|
||
* expect(42).to.equal(42);
|
||
* expect(1).to.not.equal(true);
|
||
* expect({ foo: 'bar' }).to.not.equal({ foo: 'bar' });
|
||
* expect({ foo: 'bar' }).to.deep.equal({ foo: 'bar' });
|
||
*
|
||
* @name equal
|
||
* @alias equals
|
||
* @alias eq
|
||
* @alias deep.equal
|
||
* @param {Mixed} value
|
||
* @param {String} message _optional_
|
||
* @api public
|
||
*/
|
||
|
||
function assertEqual (val, msg) {
|
||
if (msg) flag(this, 'message', msg);
|
||
var obj = flag(this, 'object');
|
||
if (flag(this, 'deep')) {
|
||
return this.eql(val);
|
||
} else {
|
||
this.assert(
|
||
val === obj
|
||
, 'expected #{this} to equal #{exp}'
|
||
, 'expected #{this} to not equal #{exp}'
|
||
, val
|
||
, this._obj
|
||
, true
|
||
);
|
||
}
|
||
}
|
||
|
||
Assertion.addMethod('equal', assertEqual);
|
||
Assertion.addMethod('equals', assertEqual);
|
||
Assertion.addMethod('eq', assertEqual);
|
||
|
||
/**
|
||
* ### .eql(value)
|
||
*
|
||
* Asserts that the target is deeply equal to `value`.
|
||
*
|
||
* expect({ foo: 'bar' }).to.eql({ foo: 'bar' });
|
||
* expect([ 1, 2, 3 ]).to.eql([ 1, 2, 3 ]);
|
||
*
|
||
* @name eql
|
||
* @alias eqls
|
||
* @param {Mixed} value
|
||
* @param {String} message _optional_
|
||
* @api public
|
||
*/
|
||
|
||
function assertEql(obj, msg) {
|
||
if (msg) flag(this, 'message', msg);
|
||
this.assert(
|
||
_.eql(obj, flag(this, 'object'))
|
||
, 'expected #{this} to deeply equal #{exp}'
|
||
, 'expected #{this} to not deeply equal #{exp}'
|
||
, obj
|
||
, this._obj
|
||
, true
|
||
);
|
||
}
|
||
|
||
Assertion.addMethod('eql', assertEql);
|
||
Assertion.addMethod('eqls', assertEql);
|
||
|
||
/**
|
||
* ### .above(value)
|
||
*
|
||
* Asserts that the target is greater than `value`.
|
||
*
|
||
* expect(10).to.be.above(5);
|
||
*
|
||
* Can also be used in conjunction with `length` to
|
||
* assert a minimum length. The benefit being a
|
||
* more informative error message than if the length
|
||
* was supplied directly.
|
||
*
|
||
* expect('foo').to.have.length.above(2);
|
||
* expect([ 1, 2, 3 ]).to.have.length.above(2);
|
||
*
|
||
* @name above
|
||
* @alias gt
|
||
* @alias greaterThan
|
||
* @param {Number} value
|
||
* @param {String} message _optional_
|
||
* @api public
|
||
*/
|
||
|
||
function assertAbove (n, msg) {
|
||
if (msg) flag(this, 'message', msg);
|
||
var obj = flag(this, 'object');
|
||
if (flag(this, 'doLength')) {
|
||
new Assertion(obj, msg).to.have.property('length');
|
||
var len = obj.length;
|
||
this.assert(
|
||
len > n
|
||
, 'expected #{this} to have a length above #{exp} but got #{act}'
|
||
, 'expected #{this} to not have a length above #{exp}'
|
||
, n
|
||
, len
|
||
);
|
||
} else {
|
||
this.assert(
|
||
obj > n
|
||
, 'expected #{this} to be above ' + n
|
||
, 'expected #{this} to be at most ' + n
|
||
);
|
||
}
|
||
}
|
||
|
||
Assertion.addMethod('above', assertAbove);
|
||
Assertion.addMethod('gt', assertAbove);
|
||
Assertion.addMethod('greaterThan', assertAbove);
|
||
|
||
/**
|
||
* ### .least(value)
|
||
*
|
||
* Asserts that the target is greater than or equal to `value`.
|
||
*
|
||
* expect(10).to.be.at.least(10);
|
||
*
|
||
* Can also be used in conjunction with `length` to
|
||
* assert a minimum length. The benefit being a
|
||
* more informative error message than if the length
|
||
* was supplied directly.
|
||
*
|
||
* expect('foo').to.have.length.of.at.least(2);
|
||
* expect([ 1, 2, 3 ]).to.have.length.of.at.least(3);
|
||
*
|
||
* @name least
|
||
* @alias gte
|
||
* @param {Number} value
|
||
* @param {String} message _optional_
|
||
* @api public
|
||
*/
|
||
|
||
function assertLeast (n, msg) {
|
||
if (msg) flag(this, 'message', msg);
|
||
var obj = flag(this, 'object');
|
||
if (flag(this, 'doLength')) {
|
||
new Assertion(obj, msg).to.have.property('length');
|
||
var len = obj.length;
|
||
this.assert(
|
||
len >= n
|
||
, 'expected #{this} to have a length at least #{exp} but got #{act}'
|
||
, 'expected #{this} to have a length below #{exp}'
|
||
, n
|
||
, len
|
||
);
|
||
} else {
|
||
this.assert(
|
||
obj >= n
|
||
, 'expected #{this} to be at least ' + n
|
||
, 'expected #{this} to be below ' + n
|
||
);
|
||
}
|
||
}
|
||
|
||
Assertion.addMethod('least', assertLeast);
|
||
Assertion.addMethod('gte', assertLeast);
|
||
|
||
/**
|
||
* ### .below(value)
|
||
*
|
||
* Asserts that the target is less than `value`.
|
||
*
|
||
* expect(5).to.be.below(10);
|
||
*
|
||
* Can also be used in conjunction with `length` to
|
||
* assert a maximum length. The benefit being a
|
||
* more informative error message than if the length
|
||
* was supplied directly.
|
||
*
|
||
* expect('foo').to.have.length.below(4);
|
||
* expect([ 1, 2, 3 ]).to.have.length.below(4);
|
||
*
|
||
* @name below
|
||
* @alias lt
|
||
* @alias lessThan
|
||
* @param {Number} value
|
||
* @param {String} message _optional_
|
||
* @api public
|
||
*/
|
||
|
||
function assertBelow (n, msg) {
|
||
if (msg) flag(this, 'message', msg);
|
||
var obj = flag(this, 'object');
|
||
if (flag(this, 'doLength')) {
|
||
new Assertion(obj, msg).to.have.property('length');
|
||
var len = obj.length;
|
||
this.assert(
|
||
len < n
|
||
, 'expected #{this} to have a length below #{exp} but got #{act}'
|
||
, 'expected #{this} to not have a length below #{exp}'
|
||
, n
|
||
, len
|
||
);
|
||
} else {
|
||
this.assert(
|
||
obj < n
|
||
, 'expected #{this} to be below ' + n
|
||
, 'expected #{this} to be at least ' + n
|
||
);
|
||
}
|
||
}
|
||
|
||
Assertion.addMethod('below', assertBelow);
|
||
Assertion.addMethod('lt', assertBelow);
|
||
Assertion.addMethod('lessThan', assertBelow);
|
||
|
||
/**
|
||
* ### .most(value)
|
||
*
|
||
* Asserts that the target is less than or equal to `value`.
|
||
*
|
||
* expect(5).to.be.at.most(5);
|
||
*
|
||
* Can also be used in conjunction with `length` to
|
||
* assert a maximum length. The benefit being a
|
||
* more informative error message than if the length
|
||
* was supplied directly.
|
||
*
|
||
* expect('foo').to.have.length.of.at.most(4);
|
||
* expect([ 1, 2, 3 ]).to.have.length.of.at.most(3);
|
||
*
|
||
* @name most
|
||
* @alias lte
|
||
* @param {Number} value
|
||
* @param {String} message _optional_
|
||
* @api public
|
||
*/
|
||
|
||
function assertMost (n, msg) {
|
||
if (msg) flag(this, 'message', msg);
|
||
var obj = flag(this, 'object');
|
||
if (flag(this, 'doLength')) {
|
||
new Assertion(obj, msg).to.have.property('length');
|
||
var len = obj.length;
|
||
this.assert(
|
||
len <= n
|
||
, 'expected #{this} to have a length at most #{exp} but got #{act}'
|
||
, 'expected #{this} to have a length above #{exp}'
|
||
, n
|
||
, len
|
||
);
|
||
} else {
|
||
this.assert(
|
||
obj <= n
|
||
, 'expected #{this} to be at most ' + n
|
||
, 'expected #{this} to be above ' + n
|
||
);
|
||
}
|
||
}
|
||
|
||
Assertion.addMethod('most', assertMost);
|
||
Assertion.addMethod('lte', assertMost);
|
||
|
||
/**
|
||
* ### .within(start, finish)
|
||
*
|
||
* Asserts that the target is within a range.
|
||
*
|
||
* expect(7).to.be.within(5,10);
|
||
*
|
||
* Can also be used in conjunction with `length` to
|
||
* assert a length range. The benefit being a
|
||
* more informative error message than if the length
|
||
* was supplied directly.
|
||
*
|
||
* expect('foo').to.have.length.within(2,4);
|
||
* expect([ 1, 2, 3 ]).to.have.length.within(2,4);
|
||
*
|
||
* @name within
|
||
* @param {Number} start lowerbound inclusive
|
||
* @param {Number} finish upperbound inclusive
|
||
* @param {String} message _optional_
|
||
* @api public
|
||
*/
|
||
|
||
Assertion.addMethod('within', function (start, finish, msg) {
|
||
if (msg) flag(this, 'message', msg);
|
||
var obj = flag(this, 'object')
|
||
, range = start + '..' + finish;
|
||
if (flag(this, 'doLength')) {
|
||
new Assertion(obj, msg).to.have.property('length');
|
||
var len = obj.length;
|
||
this.assert(
|
||
len >= start && len <= finish
|
||
, 'expected #{this} to have a length within ' + range
|
||
, 'expected #{this} to not have a length within ' + range
|
||
);
|
||
} else {
|
||
this.assert(
|
||
obj >= start && obj <= finish
|
||
, 'expected #{this} to be within ' + range
|
||
, 'expected #{this} to not be within ' + range
|
||
);
|
||
}
|
||
});
|
||
|
||
/**
|
||
* ### .instanceof(constructor)
|
||
*
|
||
* Asserts that the target is an instance of `constructor`.
|
||
*
|
||
* var Tea = function (name) { this.name = name; }
|
||
* , Chai = new Tea('chai');
|
||
*
|
||
* expect(Chai).to.be.an.instanceof(Tea);
|
||
* expect([ 1, 2, 3 ]).to.be.instanceof(Array);
|
||
*
|
||
* @name instanceof
|
||
* @param {Constructor} constructor
|
||
* @param {String} message _optional_
|
||
* @alias instanceOf
|
||
* @api public
|
||
*/
|
||
|
||
function assertInstanceOf (constructor, msg) {
|
||
if (msg) flag(this, 'message', msg);
|
||
var name = _.getName(constructor);
|
||
this.assert(
|
||
flag(this, 'object') instanceof constructor
|
||
, 'expected #{this} to be an instance of ' + name
|
||
, 'expected #{this} to not be an instance of ' + name
|
||
);
|
||
};
|
||
|
||
Assertion.addMethod('instanceof', assertInstanceOf);
|
||
Assertion.addMethod('instanceOf', assertInstanceOf);
|
||
|
||
/**
|
||
* ### .property(name, [value])
|
||
*
|
||
* Asserts that the target has a property `name`, optionally asserting that
|
||
* the value of that property is strictly equal to `value`.
|
||
* If the `deep` flag is set, you can use dot- and bracket-notation for deep
|
||
* references into objects and arrays.
|
||
*
|
||
* // simple referencing
|
||
* var obj = { foo: 'bar' };
|
||
* expect(obj).to.have.property('foo');
|
||
* expect(obj).to.have.property('foo', 'bar');
|
||
*
|
||
* // deep referencing
|
||
* var deepObj = {
|
||
* green: { tea: 'matcha' }
|
||
* , teas: [ 'chai', 'matcha', { tea: 'konacha' } ]
|
||
* };
|
||
|
||
* expect(deepObj).to.have.deep.property('green.tea', 'matcha');
|
||
* expect(deepObj).to.have.deep.property('teas[1]', 'matcha');
|
||
* expect(deepObj).to.have.deep.property('teas[2].tea', 'konacha');
|
||
*
|
||
* You can also use an array as the starting point of a `deep.property`
|
||
* assertion, or traverse nested arrays.
|
||
*
|
||
* var arr = [
|
||
* [ 'chai', 'matcha', 'konacha' ]
|
||
* , [ { tea: 'chai' }
|
||
* , { tea: 'matcha' }
|
||
* , { tea: 'konacha' } ]
|
||
* ];
|
||
*
|
||
* expect(arr).to.have.deep.property('[0][1]', 'matcha');
|
||
* expect(arr).to.have.deep.property('[1][2].tea', 'konacha');
|
||
*
|
||
* Furthermore, `property` changes the subject of the assertion
|
||
* to be the value of that property from the original object. This
|
||
* permits for further chainable assertions on that property.
|
||
*
|
||
* expect(obj).to.have.property('foo')
|
||
* .that.is.a('string');
|
||
* expect(deepObj).to.have.property('green')
|
||
* .that.is.an('object')
|
||
* .that.deep.equals({ tea: 'matcha' });
|
||
* expect(deepObj).to.have.property('teas')
|
||
* .that.is.an('array')
|
||
* .with.deep.property('[2]')
|
||
* .that.deep.equals({ tea: 'konacha' });
|
||
*
|
||
* @name property
|
||
* @alias deep.property
|
||
* @param {String} name
|
||
* @param {Mixed} value (optional)
|
||
* @param {String} message _optional_
|
||
* @returns value of property for chaining
|
||
* @api public
|
||
*/
|
||
|
||
Assertion.addMethod('property', function (name, val, msg) {
|
||
if (msg) flag(this, 'message', msg);
|
||
|
||
var descriptor = flag(this, 'deep') ? 'deep property ' : 'property '
|
||
, negate = flag(this, 'negate')
|
||
, obj = flag(this, 'object')
|
||
, value = flag(this, 'deep')
|
||
? _.getPathValue(name, obj)
|
||
: obj[name];
|
||
|
||
if (negate && undefined !== val) {
|
||
if (undefined === value) {
|
||
msg = (msg != null) ? msg + ': ' : '';
|
||
throw new Error(msg + _.inspect(obj) + ' has no ' + descriptor + _.inspect(name));
|
||
}
|
||
} else {
|
||
this.assert(
|
||
undefined !== value
|
||
, 'expected #{this} to have a ' + descriptor + _.inspect(name)
|
||
, 'expected #{this} to not have ' + descriptor + _.inspect(name));
|
||
}
|
||
|
||
if (undefined !== val) {
|
||
this.assert(
|
||
val === value
|
||
, 'expected #{this} to have a ' + descriptor + _.inspect(name) + ' of #{exp}, but got #{act}'
|
||
, 'expected #{this} to not have a ' + descriptor + _.inspect(name) + ' of #{act}'
|
||
, val
|
||
, value
|
||
);
|
||
}
|
||
|
||
flag(this, 'object', value);
|
||
});
|
||
|
||
|
||
/**
|
||
* ### .ownProperty(name)
|
||
*
|
||
* Asserts that the target has an own property `name`.
|
||
*
|
||
* expect('test').to.have.ownProperty('length');
|
||
*
|
||
* @name ownProperty
|
||
* @alias haveOwnProperty
|
||
* @param {String} name
|
||
* @param {String} message _optional_
|
||
* @api public
|
||
*/
|
||
|
||
function assertOwnProperty (name, msg) {
|
||
if (msg) flag(this, 'message', msg);
|
||
var obj = flag(this, 'object');
|
||
this.assert(
|
||
obj.hasOwnProperty(name)
|
||
, 'expected #{this} to have own property ' + _.inspect(name)
|
||
, 'expected #{this} to not have own property ' + _.inspect(name)
|
||
);
|
||
}
|
||
|
||
Assertion.addMethod('ownProperty', assertOwnProperty);
|
||
Assertion.addMethod('haveOwnProperty', assertOwnProperty);
|
||
|
||
/**
|
||
* ### .length(value)
|
||
*
|
||
* Asserts that the target's `length` property has
|
||
* the expected value.
|
||
*
|
||
* expect([ 1, 2, 3]).to.have.length(3);
|
||
* expect('foobar').to.have.length(6);
|
||
*
|
||
* Can also be used as a chain precursor to a value
|
||
* comparison for the length property.
|
||
*
|
||
* expect('foo').to.have.length.above(2);
|
||
* expect([ 1, 2, 3 ]).to.have.length.above(2);
|
||
* expect('foo').to.have.length.below(4);
|
||
* expect([ 1, 2, 3 ]).to.have.length.below(4);
|
||
* expect('foo').to.have.length.within(2,4);
|
||
* expect([ 1, 2, 3 ]).to.have.length.within(2,4);
|
||
*
|
||
* @name length
|
||
* @alias lengthOf
|
||
* @param {Number} length
|
||
* @param {String} message _optional_
|
||
* @api public
|
||
*/
|
||
|
||
function assertLengthChain () {
|
||
flag(this, 'doLength', true);
|
||
}
|
||
|
||
function assertLength (n, msg) {
|
||
if (msg) flag(this, 'message', msg);
|
||
var obj = flag(this, 'object');
|
||
new Assertion(obj, msg).to.have.property('length');
|
||
var len = obj.length;
|
||
|
||
this.assert(
|
||
len == n
|
||
, 'expected #{this} to have a length of #{exp} but got #{act}'
|
||
, 'expected #{this} to not have a length of #{act}'
|
||
, n
|
||
, len
|
||
);
|
||
}
|
||
|
||
Assertion.addChainableMethod('length', assertLength, assertLengthChain);
|
||
Assertion.addMethod('lengthOf', assertLength);
|
||
|
||
/**
|
||
* ### .match(regexp)
|
||
*
|
||
* Asserts that the target matches a regular expression.
|
||
*
|
||
* expect('foobar').to.match(/^foo/);
|
||
*
|
||
* @name match
|
||
* @param {RegExp} RegularExpression
|
||
* @param {String} message _optional_
|
||
* @api public
|
||
*/
|
||
|
||
Assertion.addMethod('match', function (re, msg) {
|
||
if (msg) flag(this, 'message', msg);
|
||
var obj = flag(this, 'object');
|
||
this.assert(
|
||
re.exec(obj)
|
||
, 'expected #{this} to match ' + re
|
||
, 'expected #{this} not to match ' + re
|
||
);
|
||
});
|
||
|
||
/**
|
||
* ### .string(string)
|
||
*
|
||
* Asserts that the string target contains another string.
|
||
*
|
||
* expect('foobar').to.have.string('bar');
|
||
*
|
||
* @name string
|
||
* @param {String} string
|
||
* @param {String} message _optional_
|
||
* @api public
|
||
*/
|
||
|
||
Assertion.addMethod('string', function (str, msg) {
|
||
if (msg) flag(this, 'message', msg);
|
||
var obj = flag(this, 'object');
|
||
new Assertion(obj, msg).is.a('string');
|
||
|
||
this.assert(
|
||
~obj.indexOf(str)
|
||
, 'expected #{this} to contain ' + _.inspect(str)
|
||
, 'expected #{this} to not contain ' + _.inspect(str)
|
||
);
|
||
});
|
||
|
||
|
||
/**
|
||
* ### .keys(key1, [key2], [...])
|
||
*
|
||
* Asserts that the target has exactly the given keys, or
|
||
* asserts the inclusion of some keys when using the
|
||
* `include` or `contain` modifiers.
|
||
*
|
||
* expect({ foo: 1, bar: 2 }).to.have.keys(['foo', 'bar']);
|
||
* expect({ foo: 1, bar: 2, baz: 3 }).to.contain.keys('foo', 'bar');
|
||
*
|
||
* @name keys
|
||
* @alias key
|
||
* @param {String...|Array} keys
|
||
* @api public
|
||
*/
|
||
|
||
function assertKeys (keys) {
|
||
var obj = flag(this, 'object')
|
||
, str
|
||
, ok = true;
|
||
|
||
keys = keys instanceof Array
|
||
? keys
|
||
: Array.prototype.slice.call(arguments);
|
||
|
||
if (!keys.length) throw new Error('keys required');
|
||
|
||
var actual = Object.keys(obj)
|
||
, expected = keys
|
||
, len = keys.length;
|
||
|
||
// Inclusion
|
||
ok = keys.every(function(key){
|
||
return ~actual.indexOf(key);
|
||
});
|
||
|
||
// Strict
|
||
if (!flag(this, 'negate') && !flag(this, 'contains')) {
|
||
ok = ok && keys.length == actual.length;
|
||
}
|
||
|
||
// Key string
|
||
if (len > 1) {
|
||
keys = keys.map(function(key){
|
||
return _.inspect(key);
|
||
});
|
||
var last = keys.pop();
|
||
str = keys.join(', ') + ', and ' + last;
|
||
} else {
|
||
str = _.inspect(keys[0]);
|
||
}
|
||
|
||
// Form
|
||
str = (len > 1 ? 'keys ' : 'key ') + str;
|
||
|
||
// Have / include
|
||
str = (flag(this, 'contains') ? 'contain ' : 'have ') + str;
|
||
|
||
// Assertion
|
||
this.assert(
|
||
ok
|
||
, 'expected #{this} to ' + str
|
||
, 'expected #{this} to not ' + str
|
||
, expected.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
|
||
);
|
||
});
|
||
};
|
||
|
||
},{}],16:[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.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) {
|
||
if (!~['==', '===', '>', '>=', '<', '<=', '!=', '!=='].indexOf(operator)) {
|
||
throw new Error('Invalid operator "' + operator + '"');
|
||
}
|
||
var test = new Assertion(eval(val + operator + val2), msg);
|
||
test.assert(
|
||
true === flag(test, 'object')
|
||
, 'expected ' + util.inspect(val) + ' to be ' + operator + ' ' + util.inspect(val2)
|
||
, 'expected ' + util.inspect(val) + ' to not be ' + operator + ' ' + util.inspect(val2) );
|
||
};
|
||
|
||
/**
|
||
* ### .closeTo(actual, expected, delta, [message])
|
||
*
|
||
* Asserts that the target is equal `expected`, to within a +/- `delta` range.
|
||
*
|
||
* assert.closeTo(1.5, 1, 0.5, 'numbers are close');
|
||
*
|
||
* @name closeTo
|
||
* @param {Number} actual
|
||
* @param {Number} expected
|
||
* @param {Number} delta
|
||
* @param {String} message
|
||
* @api public
|
||
*/
|
||
|
||
assert.closeTo = function (act, exp, delta, msg) {
|
||
new Assertion(act, msg).to.be.closeTo(exp, delta);
|
||
};
|
||
|
||
/**
|
||
* ### .sameMembers(set1, set2, [message])
|
||
*
|
||
* Asserts that `set1` and `set2` have the same members.
|
||
* Order is not taken into account.
|
||
*
|
||
* assert.sameMembers([ 1, 2, 3 ], [ 2, 1, 3 ], 'same members');
|
||
*
|
||
* @name sameMembers
|
||
* @param {Array} set1
|
||
* @param {Array} set2
|
||
* @param {String} message
|
||
* @api public
|
||
*/
|
||
|
||
assert.sameMembers = function (set1, set2, msg) {
|
||
new Assertion(set1, msg).to.have.same.members(set2);
|
||
}
|
||
|
||
/**
|
||
* ### .includeMembers(superset, subset, [message])
|
||
*
|
||
* Asserts that `subset` is included in `superset`.
|
||
* Order is not taken into account.
|
||
*
|
||
* assert.includeMembers([ 1, 2, 3 ], [ 2, 1 ], 'include members');
|
||
*
|
||
* @name includeMembers
|
||
* @param {Array} superset
|
||
* @param {Array} subset
|
||
* @param {String} message
|
||
* @api public
|
||
*/
|
||
|
||
assert.includeMembers = function (superset, subset, msg) {
|
||
new Assertion(superset, msg).to.include.members(subset);
|
||
}
|
||
|
||
/*!
|
||
* Undocumented / untested
|
||
*/
|
||
|
||
assert.ifError = function (val, msg) {
|
||
new Assertion(val, msg).to.not.be.ok;
|
||
};
|
||
|
||
/*!
|
||
* Aliases.
|
||
*/
|
||
|
||
(function alias(name, as){
|
||
assert[as] = assert[name];
|
||
return alias;
|
||
})
|
||
('Throw', 'throw')
|
||
('Throw', 'throws');
|
||
};
|
||
|
||
},{}],17:[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);
|
||
};
|
||
};
|
||
|
||
|
||
},{}],18:[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) {
|
||
return new Assertion(this.constructor(this), null, shouldGetter);
|
||
} else if (this instanceof Boolean) {
|
||
return new Assertion(this == true, 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 = {};
|
||
|
||
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;
|
||
};
|
||
|
||
},{}],19:[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":14,"./flag":22,"./transferFlags":36}],20:[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":14,"./flag":22}],21:[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
|
||
});
|
||
};
|
||
|
||
},{}],22:[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];
|
||
}
|
||
};
|
||
|
||
},{}],23:[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;
|
||
};
|
||
|
||
},{}],24:[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;
|
||
};
|
||
|
||
},{}],25:[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":22,"./getActual":23,"./inspect":30,"./objDisplay":31}],26:[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] : "";
|
||
};
|
||
|
||
},{}],27:[function(require,module,exports){
|
||
/*!
|
||
* Chai - getPathValue utility
|
||
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
|
||
* @see https://github.com/logicalparadox/filtr
|
||
* MIT Licensed
|
||
*/
|
||
|
||
/**
|
||
* ### .getPathValue(path, object)
|
||
*
|
||
* This allows the retrieval of values in an
|
||
* object given a string path.
|
||
*
|
||
* var obj = {
|
||
* prop1: {
|
||
* arr: ['a', 'b', 'c']
|
||
* , str: 'Hello'
|
||
* }
|
||
* , prop2: {
|
||
* arr: [ { nested: 'Universe' } ]
|
||
* , str: 'Hello again!'
|
||
* }
|
||
* }
|
||
*
|
||
* The following would be the results.
|
||
*
|
||
* getPathValue('prop1.str', obj); // Hello
|
||
* getPathValue('prop1.att[2]', obj); // b
|
||
* getPathValue('prop2.arr[0].nested', obj); // Universe
|
||
*
|
||
* @param {String} path
|
||
* @param {Object} object
|
||
* @returns {Object} value or `undefined`
|
||
* @name getPathValue
|
||
* @api public
|
||
*/
|
||
|
||
var getPathValue = module.exports = function (path, obj) {
|
||
var parsed = parsePath(path);
|
||
return _getPathValue(parsed, obj);
|
||
};
|
||
|
||
/*!
|
||
* ## parsePath(path)
|
||
*
|
||
* Helper function used to parse string object
|
||
* paths. Use in conjunction with `_getPathValue`.
|
||
*
|
||
* var parsed = parsePath('myobject.property.subprop');
|
||
*
|
||
* ### Paths:
|
||
*
|
||
* * Can be as near infinitely deep and nested
|
||
* * Arrays are also valid using the formal `myobject.document[3].property`.
|
||
*
|
||
* @param {String} path
|
||
* @returns {Object} parsed
|
||
* @api private
|
||
*/
|
||
|
||
function parsePath (path) {
|
||
var str = path.replace(/\[/g, '.[')
|
||
, parts = str.match(/(\\\.|[^.]+?)+/g);
|
||
return parts.map(function (value) {
|
||
var re = /\[(\d+)\]$/
|
||
, mArr = re.exec(value)
|
||
if (mArr) return { i: parseFloat(mArr[1]) };
|
||
else return { p: value };
|
||
});
|
||
};
|
||
|
||
/*!
|
||
* ## _getPathValue(parsed, obj)
|
||
*
|
||
* Helper companion function for `.parsePath` that returns
|
||
* the value located at the parsed address.
|
||
*
|
||
* var value = getPathValue(parsed, obj);
|
||
*
|
||
* @param {Object} parsed definition from `parsePath`.
|
||
* @param {Object} object to search against
|
||
* @returns {Object|Undefined} value
|
||
* @api private
|
||
*/
|
||
|
||
function _getPathValue (parsed, obj) {
|
||
var tmp = obj
|
||
, res;
|
||
for (var i = 0, l = parsed.length; i < l; i++) {
|
||
var part = parsed[i];
|
||
if (tmp) {
|
||
if ('undefined' !== typeof part.p)
|
||
tmp = tmp[part.p];
|
||
else if ('undefined' !== typeof part.i)
|
||
tmp = tmp[part.i];
|
||
if (i == (l - 1)) res = tmp;
|
||
} else {
|
||
res = undefined;
|
||
}
|
||
}
|
||
return res;
|
||
};
|
||
|
||
},{}],28:[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;
|
||
};
|
||
|
||
},{}],29:[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');
|
||
|
||
/*!
|
||
* 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":19,"./addMethod":20,"./addProperty":21,"./flag":22,"./getActual":23,"./getMessage":25,"./getName":26,"./getPathValue":27,"./inspect":30,"./objDisplay":31,"./overwriteChainableMethod":32,"./overwriteMethod":33,"./overwriteProperty":34,"./test":35,"./transferFlags":36,"./type":37,"deep-eql":39}],30:[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":24,"./getName":26,"./getProperties":28}],31:[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":14,"./inspect":30}],32:[function(require,module,exports){
|
||
/*!
|
||
* Chai - overwriteChainableMethod utility
|
||
* Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
|
||
* MIT Licensed
|
||
*/
|
||
|
||
/**
|
||
* ### overwriteChainableMethod (ctx, name, fn)
|
||
*
|
||
* Overwites an already existing chainable method
|
||
* and provides access to the previous function or
|
||
* property. Must return functions to be used for
|
||
* name.
|
||
*
|
||
* utils.overwriteChainableMethod(chai.Assertion.prototype, 'length',
|
||
* function (_super) {
|
||
* }
|
||
* , function (_super) {
|
||
* }
|
||
* );
|
||
*
|
||
* Can also be accessed directly from `chai.Assertion`.
|
||
*
|
||
* chai.Assertion.overwriteChainableMethod('foo', fn, fn);
|
||
*
|
||
* Then can be used as any other assertion.
|
||
*
|
||
* expect(myFoo).to.have.length(3);
|
||
* expect(myFoo).to.have.length.above(3);
|
||
*
|
||
* @param {Object} ctx object whose method / property is to be overwritten
|
||
* @param {String} name of method / property to overwrite
|
||
* @param {Function} method function that returns a function to be used for name
|
||
* @param {Function} chainingBehavior function that returns a function to be used for property
|
||
* @name overwriteChainableMethod
|
||
* @api public
|
||
*/
|
||
|
||
module.exports = function (ctx, name, method, chainingBehavior) {
|
||
var chainableBehavior = ctx.__methods[name];
|
||
|
||
var _chainingBehavior = chainableBehavior.chainingBehavior;
|
||
chainableBehavior.chainingBehavior = function () {
|
||
var result = chainingBehavior(_chainingBehavior).call(this);
|
||
return result === undefined ? this : result;
|
||
};
|
||
|
||
var _method = chainableBehavior.method;
|
||
chainableBehavior.method = function () {
|
||
var result = method(_method).apply(this, arguments);
|
||
return result === undefined ? this : result;
|
||
};
|
||
};
|
||
|
||
},{}],33:[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;
|
||
}
|
||
};
|
||
|
||
},{}],34:[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
|
||
});
|
||
};
|
||
|
||
},{}],35:[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":22}],36:[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 too; usually a new assertion
|
||
* @param {Boolean} includeAll
|
||
* @name getAllFlags
|
||
* @api private
|
||
*/
|
||
|
||
module.exports = function (assertion, object, includeAll) {
|
||
var flags = assertion.__flags || (assertion.__flags = Object.create(null));
|
||
|
||
if (!object.__flags) {
|
||
object.__flags = Object.create(null);
|
||
}
|
||
|
||
includeAll = arguments.length === 3 ? includeAll : true;
|
||
|
||
for (var flag in flags) {
|
||
if (includeAll ||
|
||
(flag !== 'object' && flag !== 'ssfi' && flag != 'message')) {
|
||
object.__flags[flag] = flags[flag];
|
||
}
|
||
}
|
||
};
|
||
|
||
},{}],37:[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;
|
||
};
|
||
|
||
},{}],38:[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;
|
||
};
|
||
|
||
},{}],39:[function(require,module,exports){
|
||
module.exports = require('./lib/eql');
|
||
|
||
},{"./lib/eql":40}],40:[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":43,"type-detect":41}],41:[function(require,module,exports){
|
||
module.exports = require('./lib/type');
|
||
|
||
},{"./lib/type":42}],42:[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.');
|
||
}
|
||
};
|
||
|
||
},{}],43:[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":44,"ieee754":45}],44:[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))
|
||
|
||
},{}],45:[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;
|
||
};
|
||
|
||
},{}],46:[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
|
||
}
|
||
}
|
||
|
||
},{}],47:[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');
|
||
};
|
||
|
||
},{}],48:[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';
|
||
}
|
||
},{}],49:[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":48,"1YiZ5S":47,"inherits":46}],50:[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");
|
||
}));
|
||
|
||
},{}],51:[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":52,"./sinon/behavior":53,"./sinon/call":54,"./sinon/collection":55,"./sinon/extend":56,"./sinon/format":57,"./sinon/log_error":58,"./sinon/match":59,"./sinon/mock":60,"./sinon/sandbox":61,"./sinon/spy":62,"./sinon/stub":63,"./sinon/test":64,"./sinon/test_case":65,"./sinon/times_in_words":66,"./sinon/typeOf":67,"./sinon/util/core":68}],52:[function(require,module,exports){
|
||
(function (global){
|
||
/**
|
||
* @depend times_in_words.js
|
||
* @depend util/core.js
|
||
* @depend stub.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 (typeof method != "function") {
|
||
assert.fail(method + " is not a function");
|
||
}
|
||
|
||
if (typeof method.getCall != "function") {
|
||
assert.fail(method + " is not stubbed");
|
||
}
|
||
}
|
||
}
|
||
|
||
function failAssertion(object, msg) {
|
||
object = object || global;
|
||
var failMethod = object.fail || assert.fail;
|
||
failMethod.call(object, msg);
|
||
}
|
||
|
||
function mirrorPropAsAssertion(name, method, message) {
|
||
if (arguments.length == 2) {
|
||
message = method;
|
||
method = name;
|
||
}
|
||
|
||
assert[name] = function (fake) {
|
||
verifyIsStub(fake);
|
||
|
||
var args = slice.call(arguments, 1);
|
||
var failed = false;
|
||
|
||
if (typeof method == "function") {
|
||
failed = !method(fake);
|
||
} else {
|
||
failed = typeof fake[method] == "function" ?
|
||
!fake[method].apply(fake, args) : !fake[method];
|
||
}
|
||
|
||
if (failed) {
|
||
failAssertion(this, fake.printf.apply(fake, [message].concat(args)));
|
||
} else {
|
||
assert.pass(name);
|
||
}
|
||
};
|
||
}
|
||
|
||
function exposedName(prefix, prop) {
|
||
return !prefix || /^fail/.test(prop) ? prop :
|
||
prefix + prop.slice(0, 1).toUpperCase() + prop.slice(1);
|
||
}
|
||
|
||
assert = {
|
||
failException: "AssertError",
|
||
|
||
fail: function fail(message) {
|
||
var error = new Error(message);
|
||
error.name = this.failException || assert.failException;
|
||
|
||
throw error;
|
||
},
|
||
|
||
pass: function pass(assertion) {},
|
||
|
||
callOrder: function assertCallOrder() {
|
||
verifyIsStub.apply(null, arguments);
|
||
var expected = "", actual = "";
|
||
|
||
if (!sinon.calledInOrder(arguments)) {
|
||
try {
|
||
expected = [].join.call(arguments, ", ");
|
||
var calls = slice.call(arguments);
|
||
var i = calls.length;
|
||
while (i) {
|
||
if (!calls[--i].called) {
|
||
calls.splice(i, 1);
|
||
}
|
||
}
|
||
actual = sinon.orderByFirstCall(calls).join(", ");
|
||
} catch (e) {
|
||
// If this fails, we'll just fall back to the blank string
|
||
}
|
||
|
||
failAssertion(this, "expected " + expected + " to be " +
|
||
"called in order but were called as " + actual);
|
||
} else {
|
||
assert.pass("callOrder");
|
||
}
|
||
},
|
||
|
||
callCount: function assertCallCount(method, count) {
|
||
verifyIsStub(method);
|
||
|
||
if (method.callCount != count) {
|
||
var msg = "expected %n to be called " + sinon.timesInWords(count) +
|
||
" but was called %c%C";
|
||
failAssertion(this, method.printf(msg));
|
||
} else {
|
||
assert.pass("callCount");
|
||
}
|
||
},
|
||
|
||
expose: function expose(target, options) {
|
||
if (!target) {
|
||
throw new TypeError("target is null or undefined");
|
||
}
|
||
|
||
var o = options || {};
|
||
var prefix = typeof o.prefix == "undefined" && "assert" || o.prefix;
|
||
var includeFail = typeof o.includeFail == "undefined" || !!o.includeFail;
|
||
|
||
for (var method in this) {
|
||
if (method != "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");
|
||
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 : {})
|
||
},{"./match":59,"./util/core":68}],53:[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 nextTick = (function () {
|
||
if (typeof process === "object" && typeof process.nextTick === "function") {
|
||
return process.nextTick;
|
||
} else if (typeof setImmediate === "function") {
|
||
return setImmediate;
|
||
} else {
|
||
return function (callback) {
|
||
setTimeout(callback, 0);
|
||
};
|
||
}
|
||
})();
|
||
|
||
function throwsException(error, message) {
|
||
if (typeof error == "string") {
|
||
this.exception = new Error(message || "");
|
||
this.exception.name = error;
|
||
} else if (!error) {
|
||
this.exception = new Error("Error");
|
||
} else {
|
||
this.exception = error;
|
||
}
|
||
|
||
return this;
|
||
}
|
||
|
||
function getCallback(behavior, args) {
|
||
var callArgAt = behavior.callArgAt;
|
||
|
||
if (callArgAt < 0) {
|
||
var callArgProp = behavior.callArgProp;
|
||
|
||
for (var i = 0, l = args.length; i < l; ++i) {
|
||
if (!callArgProp && typeof args[i] == "function") {
|
||
return args[i];
|
||
}
|
||
|
||
if (callArgProp && args[i] &&
|
||
typeof args[i][callArgProp] == "function") {
|
||
return args[i][callArgProp];
|
||
}
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
return args[callArgAt];
|
||
}
|
||
|
||
function 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 = -1;
|
||
this.callbackArguments = slice.call(arguments, 0);
|
||
this.callbackContext = undefined;
|
||
this.callArgProp = undefined;
|
||
this.callbackAsync = false;
|
||
|
||
return this;
|
||
},
|
||
|
||
yieldsOn: function (context) {
|
||
if (typeof context != "object") {
|
||
throw new TypeError("argument context is not an object");
|
||
}
|
||
|
||
this.callArgAt = -1;
|
||
this.callbackArguments = slice.call(arguments, 1);
|
||
this.callbackContext = context;
|
||
this.callArgProp = undefined;
|
||
this.callbackAsync = false;
|
||
|
||
return this;
|
||
},
|
||
|
||
yieldsTo: function (prop) {
|
||
this.callArgAt = -1;
|
||
this.callbackArguments = slice.call(arguments, 1);
|
||
this.callbackContext = undefined;
|
||
this.callArgProp = prop;
|
||
this.callbackAsync = false;
|
||
|
||
return this;
|
||
},
|
||
|
||
yieldsToOn: function (prop, context) {
|
||
if (typeof context != "object") {
|
||
throw new TypeError("argument context is not an object");
|
||
}
|
||
|
||
this.callArgAt = -1;
|
||
this.callbackArguments = slice.call(arguments, 2);
|
||
this.callbackContext = context;
|
||
this.callArgProp = prop;
|
||
this.callbackAsync = false;
|
||
|
||
return this;
|
||
},
|
||
|
||
throws: throwsException,
|
||
throwsException: throwsException,
|
||
|
||
returns: function returns(value) {
|
||
this.returnValue = value;
|
||
this.returnValueDefined = true;
|
||
|
||
return this;
|
||
},
|
||
|
||
returnsArg: function returnsArg(pos) {
|
||
if (typeof pos != "number") {
|
||
throw new TypeError("argument index is not number");
|
||
}
|
||
|
||
this.returnArgAt = pos;
|
||
|
||
return this;
|
||
},
|
||
|
||
returnsThis: function returnsThis() {
|
||
this.returnThis = true;
|
||
|
||
return this;
|
||
}
|
||
};
|
||
|
||
// create asynchronous versions of callsArg* and yields* methods
|
||
for (var method in proto) {
|
||
// need to avoid creating anotherasync versions of the newly added async methods
|
||
if (proto.hasOwnProperty(method) &&
|
||
method.match(/^(callsArg|yields)/) &&
|
||
!method.match(/Async/)) {
|
||
proto[method + "Async"] = (function (syncFnName) {
|
||
return function () {
|
||
var result = this[syncFnName].apply(this, arguments);
|
||
this.callbackAsync = true;
|
||
return result;
|
||
};
|
||
})(method);
|
||
}
|
||
}
|
||
|
||
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");
|
||
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"))
|
||
},{"./util/core":68,"1YiZ5S":47}],54:[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() {
|
||
for (var i = 0, l = arguments.length; i < l; i += 1) {
|
||
if (!sinon.deepEqual(arguments[i], this.args[i])) {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
return true;
|
||
},
|
||
|
||
calledWithMatch: function calledWithMatch() {
|
||
for (var i = 0, l = arguments.length; i < l; i += 1) {
|
||
var actual = this.args[i];
|
||
var expectation = arguments[i];
|
||
if (!sinon.match || !sinon.match(expectation).test(actual)) {
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
},
|
||
|
||
calledWithExactly: function calledWithExactly() {
|
||
return arguments.length == this.args.length &&
|
||
this.calledWith.apply(this, arguments);
|
||
},
|
||
|
||
notCalledWith: function notCalledWith() {
|
||
return !this.calledWith.apply(this, arguments);
|
||
},
|
||
|
||
notCalledWithMatch: function notCalledWithMatch() {
|
||
return !this.calledWithMatch.apply(this, arguments);
|
||
},
|
||
|
||
returned: function returned(value) {
|
||
return sinon.deepEqual(value, this.returnValue);
|
||
},
|
||
|
||
threw: function threw(error) {
|
||
if (typeof error === "undefined" || !this.exception) {
|
||
return !!this.exception;
|
||
}
|
||
|
||
return this.exception === error || this.exception.name === error;
|
||
},
|
||
|
||
calledWithNew: function calledWithNew() {
|
||
return this.proxy.prototype && this.thisValue instanceof this.proxy;
|
||
},
|
||
|
||
calledBefore: function (other) {
|
||
return this.callId < other.callId;
|
||
},
|
||
|
||
calledAfter: function (other) {
|
||
return this.callId > other.callId;
|
||
},
|
||
|
||
callArg: function (pos) {
|
||
this.args[pos]();
|
||
},
|
||
|
||
callArgOn: function (pos, thisValue) {
|
||
this.args[pos].apply(thisValue);
|
||
},
|
||
|
||
callArgWith: function (pos) {
|
||
this.callArgOnWith.apply(this, [pos, null].concat(slice.call(arguments, 1)));
|
||
},
|
||
|
||
callArgOnWith: function (pos, thisValue) {
|
||
var args = slice.call(arguments, 2);
|
||
this.args[pos].apply(thisValue, args);
|
||
},
|
||
|
||
yield: function () {
|
||
this.yieldOn.apply(this, [null].concat(slice.call(arguments, 0)));
|
||
},
|
||
|
||
yieldOn: function (thisValue) {
|
||
var args = this.args;
|
||
for (var i = 0, l = args.length; i < l; ++i) {
|
||
if (typeof args[i] === "function") {
|
||
args[i].apply(thisValue, slice.call(arguments, 1));
|
||
return;
|
||
}
|
||
}
|
||
throwYieldError(this.proxy, " cannot yield since no callback was passed.", args);
|
||
},
|
||
|
||
yieldTo: function (prop) {
|
||
this.yieldToOn.apply(this, [prop, null].concat(slice.call(arguments, 1)));
|
||
},
|
||
|
||
yieldToOn: function (prop, thisValue) {
|
||
var args = this.args;
|
||
for (var i = 0, l = args.length; i < l; ++i) {
|
||
if (args[i] && typeof args[i][prop] === "function") {
|
||
args[i][prop].apply(thisValue, slice.call(arguments, 2));
|
||
return;
|
||
}
|
||
}
|
||
throwYieldError(this.proxy, " cannot yield to '" + prop +
|
||
"' since no callback was passed.", args);
|
||
},
|
||
|
||
toString: function () {
|
||
var callStr = this.proxy.toString() + "(";
|
||
var args = [];
|
||
|
||
for (var i = 0, l = this.args.length; i < l; ++i) {
|
||
args.push(sinon.format(this.args[i]));
|
||
}
|
||
|
||
callStr = callStr + args.join(", ") + ")";
|
||
|
||
if (typeof this.returnValue != "undefined") {
|
||
callStr += " => " + sinon.format(this.returnValue);
|
||
}
|
||
|
||
if (this.exception) {
|
||
callStr += " !" + this.exception.name;
|
||
|
||
if (this.exception.message) {
|
||
callStr += "(" + this.exception.message + ")";
|
||
}
|
||
}
|
||
|
||
return callStr;
|
||
}
|
||
};
|
||
|
||
callProto.invokeCallback = callProto.yield;
|
||
|
||
function createSpyCall(spy, thisValue, args, returnValue, exception, id) {
|
||
if (typeof id !== "number") {
|
||
throw new TypeError("Call id is not a number");
|
||
}
|
||
var proxyCall = sinon.create(callProto);
|
||
proxyCall.proxy = spy;
|
||
proxyCall.thisValue = thisValue;
|
||
proxyCall.args = args;
|
||
proxyCall.returnValue = returnValue;
|
||
proxyCall.exception = exception;
|
||
proxyCall.callId = id;
|
||
|
||
return proxyCall;
|
||
}
|
||
createSpyCall.toString = callProto.toString; // used by mocks
|
||
|
||
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");
|
||
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));
|
||
|
||
},{"./match":59,"./util/core":68}],55:[function(require,module,exports){
|
||
/**
|
||
* @depend util/core.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":60,"./spy":62,"./stub":63,"./util/core":68}],56:[function(require,module,exports){
|
||
/**
|
||
* @depend ../sinon.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":68}],57:[function(require,module,exports){
|
||
/**
|
||
* @depend ../sinon.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":68,"formatio":73,"util":49}],58:[function(require,module,exports){
|
||
/**
|
||
* @depend ../sinon.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":68}],59:[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");
|
||
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));
|
||
|
||
},{"./util/core":68}],60:[function(require,module,exports){
|
||
/**
|
||
* @depend times_in_words.js
|
||
* @depend util/core.js
|
||
* @depend extend.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("./call");
|
||
require("./match");
|
||
require("./spy");
|
||
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":54,"./match":59,"./spy":62,"./util/core":68}],61:[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("./util/fake_server");
|
||
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":55,"./util/core":68,"./util/fake_server":70,"./util/fake_timers":71}],62:[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) {
|
||
if (!property && typeof object == "function") {
|
||
return spy.create(object);
|
||
}
|
||
|
||
if (!object && !property) {
|
||
return spy.create(function () { });
|
||
}
|
||
|
||
var method = object[property];
|
||
return sinon.wrapMethod(object, property, spy.create(method));
|
||
}
|
||
|
||
function matchingFake(fakes, args, strict) {
|
||
if (!fakes) {
|
||
return;
|
||
}
|
||
|
||
for (var i = 0, l = fakes.length; i < l; i++) {
|
||
if (fakes[i].matches(args, strict)) {
|
||
return fakes[i];
|
||
}
|
||
}
|
||
}
|
||
|
||
function incrementCallCount() {
|
||
this.called = true;
|
||
this.callCount += 1;
|
||
this.notCalled = false;
|
||
this.calledOnce = this.callCount == 1;
|
||
this.calledTwice = this.callCount == 2;
|
||
this.calledThrice = this.callCount == 3;
|
||
}
|
||
|
||
function createCallProperties() {
|
||
this.firstCall = this.getCall(0);
|
||
this.secondCall = this.getCall(1);
|
||
this.thirdCall = this.getCall(2);
|
||
this.lastCall = this.getCall(this.callCount - 1);
|
||
}
|
||
|
||
var vars = "a,b,c,d,e,f,g,h,i,j,k,l";
|
||
function createProxy(func) {
|
||
// Retain the function length:
|
||
var p;
|
||
if (func.length) {
|
||
eval("p = (function proxy(" + vars.substring(0, func.length * 2 - 1) +
|
||
") { return p.invoke(func, this, slice.call(arguments)); });");
|
||
} else {
|
||
p = function proxy() {
|
||
return p.invoke(func, this, slice.call(arguments));
|
||
};
|
||
}
|
||
return p;
|
||
}
|
||
|
||
var uuid = 0;
|
||
|
||
// Public API
|
||
var spyApi = {
|
||
reset: function () {
|
||
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();
|
||
}
|
||
}
|
||
},
|
||
|
||
create: function create(func) {
|
||
var name;
|
||
|
||
if (typeof func != "function") {
|
||
func = function () { };
|
||
} else {
|
||
name = sinon.functionName(func);
|
||
}
|
||
|
||
var proxy = createProxy(func);
|
||
|
||
sinon.extend(proxy, spy);
|
||
delete proxy.create;
|
||
sinon.extend(proxy, func);
|
||
|
||
proxy.reset();
|
||
proxy.prototype = func.prototype;
|
||
proxy.displayName = name || "spy";
|
||
proxy.toString = sinon.functionToString;
|
||
proxy.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");
|
||
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":54,"./util/core":68}],63:[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") {
|
||
throw new TypeError("Custom stub should be function");
|
||
}
|
||
|
||
var wrapper;
|
||
|
||
if (func) {
|
||
wrapper = sinon.spy && sinon.spy.create ? sinon.spy.create(func) : func;
|
||
} else {
|
||
wrapper = stub.create();
|
||
}
|
||
|
||
if (!object && typeof property === "undefined") {
|
||
return sinon.stub.create();
|
||
}
|
||
|
||
if (typeof property === "undefined" && typeof object == "object") {
|
||
for (var prop in object) {
|
||
if (typeof object[prop] === "function") {
|
||
stub(object, prop);
|
||
}
|
||
}
|
||
|
||
return object;
|
||
}
|
||
|
||
return sinon.wrapMethod(object, property, wrapper);
|
||
}
|
||
|
||
function getDefaultBehavior(stub) {
|
||
return stub.defaultBehavior || getParentBehaviour(stub) || sinon.behavior.create(stub);
|
||
}
|
||
|
||
function getParentBehaviour(stub) {
|
||
return (stub.parent && getCurrentBehavior(stub.parent));
|
||
}
|
||
|
||
function getCurrentBehavior(stub) {
|
||
var behavior = stub.behaviors[stub.callCount - 1];
|
||
return behavior && behavior.isPresent() ? behavior : getDefaultBehavior(stub);
|
||
}
|
||
|
||
var uuid = 0;
|
||
|
||
var proto = {
|
||
create: function create() {
|
||
var functionStub = function () {
|
||
return getCurrentBehavior(functionStub).invoke(this, arguments);
|
||
};
|
||
|
||
functionStub.id = "stub#" + uuid++;
|
||
var orig = functionStub;
|
||
functionStub = sinon.spy.create(functionStub);
|
||
functionStub.func = orig;
|
||
|
||
sinon.extend(functionStub, stub);
|
||
functionStub.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");
|
||
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":53,"./spy":62,"./util/core":68}],64:[function(require,module,exports){
|
||
/**
|
||
* @depend util/core.js
|
||
* @depend stub.js
|
||
* @depend mock.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) {
|
||
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 exception, result;
|
||
var doneIsWrapped = false;
|
||
var argumentsCopy = Array.prototype.slice.call(arguments);
|
||
if (argumentsCopy.length > 0 && typeof argumentsCopy[arguments.length - 1] == "function") {
|
||
var oldDone = argumentsCopy[arguments.length - 1];
|
||
argumentsCopy[arguments.length - 1] = function done(result) {
|
||
if (result) {
|
||
sandbox.restore();
|
||
throw exception;
|
||
} else {
|
||
sandbox.verifyAndRestore();
|
||
}
|
||
oldDone(result);
|
||
}
|
||
doneIsWrapped = true;
|
||
}
|
||
|
||
var args = argumentsCopy.concat(sandbox.args);
|
||
|
||
try {
|
||
result = callback.apply(this, args);
|
||
} catch (e) {
|
||
exception = e;
|
||
}
|
||
|
||
if (!doneIsWrapped) {
|
||
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) {
|
||
return;
|
||
} else {
|
||
makeApi(sinon);
|
||
}
|
||
}(typeof sinon == "object" && sinon || null));
|
||
|
||
},{"./sandbox":61,"./util/core":68}],65:[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":64,"./util/core":68}],66:[function(require,module,exports){
|
||
/**
|
||
* @depend ../sinon.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":68}],67:[function(require,module,exports){
|
||
/**
|
||
* @depend ../sinon.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":68}],68:[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;
|
||
}
|
||
|
||
function makeApi(sinon) {
|
||
sinon.wrapMethod = function wrapMethod(object, property, method) {
|
||
if (!object) {
|
||
throw new TypeError("Should wrap property of object");
|
||
}
|
||
|
||
if (typeof method != "function") {
|
||
throw new TypeError("Method wrapper should be function");
|
||
}
|
||
|
||
var wrappedMethod = object[property],
|
||
error;
|
||
|
||
if (!isFunction(wrappedMethod)) {
|
||
error = new TypeError("Attempted to wrap " + (typeof wrappedMethod) + " property " +
|
||
property + " as function");
|
||
} 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;
|
||
}
|
||
|
||
// IE 8 does not support hasOwnProperty on the window object and Firefox has a problem
|
||
// when using hasOwn.call on objects from other frames.
|
||
var owned = object.hasOwnProperty ? object.hasOwnProperty(property) : hasOwn.call(object, property);
|
||
object[property] = method;
|
||
method.displayName = property;
|
||
// Set up a stack trace which can be used later to find what line of
|
||
// code the original method was created on.
|
||
method.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) {
|
||
delete object[property];
|
||
}
|
||
if (object[property] === method) {
|
||
object[property] = wrappedMethod;
|
||
}
|
||
};
|
||
|
||
method.restore.sinon = true;
|
||
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.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));
|
||
|
||
},{}],69:[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;
|
||
};
|
||
|
||
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":68}],70:[function(require,module,exports){
|
||
/**
|
||
* @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);
|
||
this.xhr = sinon.useFakeXMLHttpRequest();
|
||
server.requests = [];
|
||
|
||
this.xhr.onCreate = function (xhrObj) {
|
||
server.addRequest(xhrObj);
|
||
};
|
||
|
||
return server;
|
||
},
|
||
|
||
addRequest: function addRequest(xhrObj) {
|
||
var server = this;
|
||
push.call(this.requests, xhrObj);
|
||
|
||
xhrObj.onSend = function () {
|
||
server.handleRequest(this);
|
||
|
||
if (server.autoRespond && !server.responding) {
|
||
setTimeout(function () {
|
||
server.responding = false;
|
||
server.respond();
|
||
}, server.autoRespondAfter || 10);
|
||
|
||
server.responding = true;
|
||
}
|
||
};
|
||
},
|
||
|
||
getHTTPMethod: function getHTTPMethod(request) {
|
||
if (this.fakeHTTPMethods && /post/i.test(request.method)) {
|
||
var matches = (request.requestBody || "").match(/_method=([^\b;]+)/);
|
||
return !!matches ? matches[1] : request.method;
|
||
}
|
||
|
||
return request.method;
|
||
},
|
||
|
||
handleRequest: function handleRequest(xhr) {
|
||
if (xhr.async) {
|
||
if (!this.queue) {
|
||
this.queue = [];
|
||
}
|
||
|
||
push.call(this.queue, xhr);
|
||
} else {
|
||
this.processRequest(xhr);
|
||
}
|
||
},
|
||
|
||
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_xml_http_request");
|
||
makeApi(sinon);
|
||
module.exports = sinon;
|
||
}
|
||
|
||
if (isAMD) {
|
||
define(loadDependencies);
|
||
} else if (isNode) {
|
||
loadDependencies(require, module.exports, module);
|
||
} else {
|
||
makeApi(sinon);
|
||
}
|
||
}());
|
||
|
||
},{"./core":68,"./fake_xml_http_request":72}],71:[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) {
|
||
var sinon = require("./core");
|
||
makeApi(sinon, require("lolex"));
|
||
module.exports = sinon;
|
||
}
|
||
|
||
if (isAMD) {
|
||
define(loadDependencies);
|
||
} else if (isNode) {
|
||
loadDependencies(require, module.exports, module);
|
||
} else {
|
||
makeApi(sinon);
|
||
}
|
||
}(typeof global != "undefined" && typeof global !== "function" ? global : this));
|
||
|
||
}).call(this,typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
|
||
},{"./core":68,"lolex":75}],72:[function(require,module,exports){
|
||
/**
|
||
* @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}));
|
||
}
|
||
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 {
|
||
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));
|
||
}
|
||
},
|
||
|
||
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("./event");
|
||
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 self !== "undefined" ? self : this);
|
||
|
||
},{"./core":68,"./event":69}],73:[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":74}],74:[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
|
||
};
|
||
});
|
||
|
||
},{}],75:[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 : {})
|
||
},{}],76:[function(require,module,exports){
|
||
// Underscore.js 1.7.0
|
||
// http://underscorejs.org
|
||
// (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
|
||
// Underscore may be freely distributed under the MIT license.
|
||
|
||
(function() {
|
||
|
||
// Baseline setup
|
||
// --------------
|
||
|
||
// Establish the root object, `window` in the browser, or `exports` on the server.
|
||
var root = this;
|
||
|
||
// Save the previous value of the `_` variable.
|
||
var previousUnderscore = root._;
|
||
|
||
// Save bytes in the minified (but not gzipped) version:
|
||
var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;
|
||
|
||
// Create quick reference variables for speed access to core prototypes.
|
||
var
|
||
push = ArrayProto.push,
|
||
slice = ArrayProto.slice,
|
||
concat = ArrayProto.concat,
|
||
toString = ObjProto.toString,
|
||
hasOwnProperty = ObjProto.hasOwnProperty;
|
||
|
||
// All **ECMAScript 5** native function implementations that we hope to use
|
||
// are declared here.
|
||
var
|
||
nativeIsArray = Array.isArray,
|
||
nativeKeys = Object.keys,
|
||
nativeBind = FuncProto.bind;
|
||
|
||
// Create a safe reference to the Underscore object for use below.
|
||
var _ = function(obj) {
|
||
if (obj instanceof _) return obj;
|
||
if (!(this instanceof _)) return new _(obj);
|
||
this._wrapped = obj;
|
||
};
|
||
|
||
// Export the Underscore object for **Node.js**, with
|
||
// backwards-compatibility for the old `require()` API. If we're in
|
||
// the browser, add `_` as a global object.
|
||
if (typeof exports !== 'undefined') {
|
||
if (typeof module !== 'undefined' && module.exports) {
|
||
exports = module.exports = _;
|
||
}
|
||
exports._ = _;
|
||
} else {
|
||
root._ = _;
|
||
}
|
||
|
||
// Current version.
|
||
_.VERSION = '1.7.0';
|
||
|
||
// Internal function that returns an efficient (for current engines) version
|
||
// of the passed-in callback, to be repeatedly applied in other Underscore
|
||
// functions.
|
||
var createCallback = 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.
|
||
_.iteratee = function(value, context, argCount) {
|
||
if (value == null) return _.identity;
|
||
if (_.isFunction(value)) return createCallback(value, context, argCount);
|
||
if (_.isObject(value)) return _.matches(value);
|
||
return _.property(value);
|
||
};
|
||
|
||
// 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) {
|
||
if (obj == null) return obj;
|
||
iteratee = createCallback(iteratee, context);
|
||
var i, length = obj.length;
|
||
if (length === +length) {
|
||
for (i = 0; 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) {
|
||
if (obj == null) return [];
|
||
iteratee = _.iteratee(iteratee, context);
|
||
var keys = obj.length !== +obj.length && _.keys(obj),
|
||
length = (keys || obj).length,
|
||
results = Array(length),
|
||
currentKey;
|
||
for (var index = 0; index < length; index++) {
|
||
currentKey = keys ? keys[index] : index;
|
||
results[index] = iteratee(obj[currentKey], currentKey, obj);
|
||
}
|
||
return results;
|
||
};
|
||
|
||
var reduceError = 'Reduce of empty array with no initial value';
|
||
|
||
// **Reduce** builds up a single result from a list of values, aka `inject`,
|
||
// or `foldl`.
|
||
_.reduce = _.foldl = _.inject = function(obj, iteratee, memo, context) {
|
||
if (obj == null) obj = [];
|
||
iteratee = createCallback(iteratee, context, 4);
|
||
var keys = obj.length !== +obj.length && _.keys(obj),
|
||
length = (keys || obj).length,
|
||
index = 0, currentKey;
|
||
if (arguments.length < 3) {
|
||
if (!length) throw new TypeError(reduceError);
|
||
memo = obj[keys ? keys[index++] : index++];
|
||
}
|
||
for (; index < length; index++) {
|
||
currentKey = keys ? keys[index] : index;
|
||
memo = iteratee(memo, obj[currentKey], currentKey, obj);
|
||
}
|
||
return memo;
|
||
};
|
||
|
||
// The right-associative version of reduce, also known as `foldr`.
|
||
_.reduceRight = _.foldr = function(obj, iteratee, memo, context) {
|
||
if (obj == null) obj = [];
|
||
iteratee = createCallback(iteratee, context, 4);
|
||
var keys = obj.length !== + obj.length && _.keys(obj),
|
||
index = (keys || obj).length,
|
||
currentKey;
|
||
if (arguments.length < 3) {
|
||
if (!index) throw new TypeError(reduceError);
|
||
memo = obj[keys ? keys[--index] : --index];
|
||
}
|
||
while (index--) {
|
||
currentKey = keys ? keys[index] : index;
|
||
memo = iteratee(memo, obj[currentKey], currentKey, obj);
|
||
}
|
||
return memo;
|
||
};
|
||
|
||
// Return the first value which passes a truth test. Aliased as `detect`.
|
||
_.find = _.detect = function(obj, predicate, context) {
|
||
var result;
|
||
predicate = _.iteratee(predicate, context);
|
||
_.some(obj, function(value, index, list) {
|
||
if (predicate(value, index, list)) {
|
||
result = value;
|
||
return true;
|
||
}
|
||
});
|
||
return result;
|
||
};
|
||
|
||
// Return all the elements that pass a truth test.
|
||
// Aliased as `select`.
|
||
_.filter = _.select = function(obj, predicate, context) {
|
||
var results = [];
|
||
if (obj == null) return results;
|
||
predicate = _.iteratee(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(_.iteratee(predicate)), context);
|
||
};
|
||
|
||
// Determine whether all of the elements match a truth test.
|
||
// Aliased as `all`.
|
||
_.every = _.all = function(obj, predicate, context) {
|
||
if (obj == null) return true;
|
||
predicate = _.iteratee(predicate, context);
|
||
var keys = obj.length !== +obj.length && _.keys(obj),
|
||
length = (keys || obj).length,
|
||
index, currentKey;
|
||
for (index = 0; index < length; index++) {
|
||
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) {
|
||
if (obj == null) return false;
|
||
predicate = _.iteratee(predicate, context);
|
||
var keys = obj.length !== +obj.length && _.keys(obj),
|
||
length = (keys || obj).length,
|
||
index, currentKey;
|
||
for (index = 0; index < length; index++) {
|
||
currentKey = keys ? keys[index] : index;
|
||
if (predicate(obj[currentKey], currentKey, obj)) return true;
|
||
}
|
||
return false;
|
||
};
|
||
|
||
// Determine if the array or object contains a given value (using `===`).
|
||
// Aliased as `include`.
|
||
_.contains = _.include = function(obj, target) {
|
||
if (obj == null) return false;
|
||
if (obj.length !== +obj.length) obj = _.values(obj);
|
||
return _.indexOf(obj, target) >= 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) {
|
||
return (isFunc ? method : value[method]).apply(value, args);
|
||
});
|
||
};
|
||
|
||
// Convenience version of a common use case of `map`: fetching a property.
|
||
_.pluck = function(obj, key) {
|
||
return _.map(obj, _.property(key));
|
||
};
|
||
|
||
// Convenience version of a common use case of `filter`: selecting only objects
|
||
// containing specific `key:value` pairs.
|
||
_.where = function(obj, attrs) {
|
||
return _.filter(obj, _.matches(attrs));
|
||
};
|
||
|
||
// Convenience version of a common use case of `find`: getting the first object
|
||
// containing specific `key:value` pairs.
|
||
_.findWhere = function(obj, attrs) {
|
||
return _.find(obj, _.matches(attrs));
|
||
};
|
||
|
||
// Return the maximum element (or element-based computation).
|
||
_.max = function(obj, iteratee, context) {
|
||
var result = -Infinity, lastComputed = -Infinity,
|
||
value, computed;
|
||
if (iteratee == null && obj != null) {
|
||
obj = obj.length === +obj.length ? obj : _.values(obj);
|
||
for (var i = 0, length = obj.length; i < length; i++) {
|
||
value = obj[i];
|
||
if (value > result) {
|
||
result = value;
|
||
}
|
||
}
|
||
} else {
|
||
iteratee = _.iteratee(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 = obj.length === +obj.length ? obj : _.values(obj);
|
||
for (var i = 0, length = obj.length; i < length; i++) {
|
||
value = obj[i];
|
||
if (value < result) {
|
||
result = value;
|
||
}
|
||
}
|
||
} else {
|
||
iteratee = _.iteratee(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 = obj && obj.length === +obj.length ? 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 (obj.length !== +obj.length) 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 = _.iteratee(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 = _.iteratee(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;
|
||
});
|
||
|
||
// 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 = _.iteratee(iteratee, context, 1);
|
||
var value = iteratee(obj);
|
||
var low = 0, high = array.length;
|
||
while (low < high) {
|
||
var mid = low + high >>> 1;
|
||
if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;
|
||
}
|
||
return low;
|
||
};
|
||
|
||
// Safely create a real, live array from anything iterable.
|
||
_.toArray = function(obj) {
|
||
if (!obj) return [];
|
||
if (_.isArray(obj)) return slice.call(obj);
|
||
if (obj.length === +obj.length) return _.map(obj, _.identity);
|
||
return _.values(obj);
|
||
};
|
||
|
||
// Return the number of elements in an object.
|
||
_.size = function(obj) {
|
||
if (obj == null) return 0;
|
||
return obj.length === +obj.length ? obj.length : _.keys(obj).length;
|
||
};
|
||
|
||
// 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 = _.iteratee(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];
|
||
if (n < 0) return [];
|
||
return slice.call(array, 0, n);
|
||
};
|
||
|
||
// Returns everything but the last entry of the array. Especially useful on
|
||
// the arguments object. Passing **n** will return all the values in
|
||
// the array, excluding the last N. The **guard** check allows it to work with
|
||
// `_.map`.
|
||
_.initial = function(array, n, guard) {
|
||
return slice.call(array, 0, 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. The **guard** check allows it to work with `_.map`.
|
||
_.last = function(array, n, guard) {
|
||
if (array == null) return void 0;
|
||
if (n == null || guard) return array[array.length - 1];
|
||
return slice.call(array, Math.max(array.length - n, 0));
|
||
};
|
||
|
||
// Returns everything but the first entry of the array. Aliased as `tail` and `drop`.
|
||
// Especially useful on the arguments object. Passing an **n** will return
|
||
// the rest N values in the array. The **guard**
|
||
// check allows it to work with `_.map`.
|
||
_.rest = _.tail = _.drop = function(array, n, guard) {
|
||
return slice.call(array, n == null || guard ? 1 : n);
|
||
};
|
||
|
||
// Trim out all falsy values from an array.
|
||
_.compact = function(array) {
|
||
return _.filter(array, _.identity);
|
||
};
|
||
|
||
// Internal implementation of a recursive `flatten` function.
|
||
var flatten = function(input, shallow, strict, output) {
|
||
if (shallow && _.every(input, _.isArray)) {
|
||
return concat.apply(output, input);
|
||
}
|
||
for (var i = 0, length = input.length; i < length; i++) {
|
||
var value = input[i];
|
||
if (!_.isArray(value) && !_.isArguments(value)) {
|
||
if (!strict) output.push(value);
|
||
} else if (shallow) {
|
||
push.apply(output, value);
|
||
} else {
|
||
flatten(value, shallow, strict, output);
|
||
}
|
||
}
|
||
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 (array == null) return [];
|
||
if (!_.isBoolean(isSorted)) {
|
||
context = iteratee;
|
||
iteratee = isSorted;
|
||
isSorted = false;
|
||
}
|
||
if (iteratee != null) iteratee = _.iteratee(iteratee, context);
|
||
var result = [];
|
||
var seen = [];
|
||
for (var i = 0, length = array.length; i < length; i++) {
|
||
var value = array[i];
|
||
if (isSorted) {
|
||
if (!i || seen !== value) result.push(value);
|
||
seen = value;
|
||
} else if (iteratee) {
|
||
var computed = iteratee(value, i, array);
|
||
if (_.indexOf(seen, computed) < 0) {
|
||
seen.push(computed);
|
||
result.push(value);
|
||
}
|
||
} else if (_.indexOf(result, value) < 0) {
|
||
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) {
|
||
if (array == null) return [];
|
||
var result = [];
|
||
var argsLength = arguments.length;
|
||
for (var i = 0, length = array.length; 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(slice.call(arguments, 1), true, true, []);
|
||
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(array) {
|
||
if (array == null) return [];
|
||
var length = _.max(arguments, 'length').length;
|
||
var results = Array(length);
|
||
for (var i = 0; i < length; i++) {
|
||
results[i] = _.pluck(arguments, i);
|
||
}
|
||
return results;
|
||
};
|
||
|
||
// Converts lists into objects. Pass either a single array of `[key, value]`
|
||
// pairs, or two parallel arrays of the same length -- one of keys, and one of
|
||
// the corresponding values.
|
||
_.object = function(list, values) {
|
||
if (list == null) return {};
|
||
var result = {};
|
||
for (var i = 0, length = list.length; i < length; i++) {
|
||
if (values) {
|
||
result[list[i]] = values[i];
|
||
} else {
|
||
result[list[i][0]] = list[i][1];
|
||
}
|
||
}
|
||
return result;
|
||
};
|
||
|
||
// 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 = function(array, item, isSorted) {
|
||
if (array == null) return -1;
|
||
var i = 0, length = array.length;
|
||
if (isSorted) {
|
||
if (typeof isSorted == 'number') {
|
||
i = isSorted < 0 ? Math.max(0, length + isSorted) : isSorted;
|
||
} else {
|
||
i = _.sortedIndex(array, item);
|
||
return array[i] === item ? i : -1;
|
||
}
|
||
}
|
||
for (; i < length; i++) if (array[i] === item) return i;
|
||
return -1;
|
||
};
|
||
|
||
_.lastIndexOf = function(array, item, from) {
|
||
if (array == null) return -1;
|
||
var idx = array.length;
|
||
if (typeof from == 'number') {
|
||
idx = from < 0 ? idx + from + 1 : Math.min(idx, from + 1);
|
||
}
|
||
while (--idx >= 0) if (array[idx] === item) return idx;
|
||
return -1;
|
||
};
|
||
|
||
// Generate an integer Array containing an arithmetic progression. A port of
|
||
// the native Python `range()` function. See
|
||
// [the Python documentation](http://docs.python.org/library/functions.html#range).
|
||
_.range = function(start, stop, step) {
|
||
if (arguments.length <= 1) {
|
||
stop = start || 0;
|
||
start = 0;
|
||
}
|
||
step = 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
|
||
// ------------------
|
||
|
||
// Reusable constructor function for prototype setting.
|
||
var Ctor = function(){};
|
||
|
||
// Create a function bound to a given object (assigning `this`, and arguments,
|
||
// optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if
|
||
// available.
|
||
_.bind = function(func, context) {
|
||
var args, bound;
|
||
if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
|
||
if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');
|
||
args = slice.call(arguments, 2);
|
||
bound = function() {
|
||
if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
|
||
Ctor.prototype = func.prototype;
|
||
var self = new Ctor;
|
||
Ctor.prototype = null;
|
||
var result = func.apply(self, args.concat(slice.call(arguments)));
|
||
if (_.isObject(result)) return result;
|
||
return self;
|
||
};
|
||
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);
|
||
return function() {
|
||
var position = 0;
|
||
var args = boundArgs.slice();
|
||
for (var i = 0, length = args.length; i < length; i++) {
|
||
if (args[i] === _) args[i] = arguments[position++];
|
||
}
|
||
while (position < arguments.length) args.push(arguments[position++]);
|
||
return func.apply(this, args);
|
||
};
|
||
};
|
||
|
||
// Bind a number of an object's methods to that object. Remaining arguments
|
||
// are the method names to be bound. Useful for ensuring that all callbacks
|
||
// defined on an object belong to it.
|
||
_.bindAll = function(obj) {
|
||
var 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 = function(func) {
|
||
return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));
|
||
};
|
||
|
||
// Returns a function, that, when invoked, will only be triggered at most once
|
||
// during a given window of time. Normally, the throttled function will run
|
||
// as much as it can, without ever going more than once per `wait` duration;
|
||
// but if you'd like to disable the execution on the leading edge, pass
|
||
// `{leading: false}`. To disable execution on the trailing edge, ditto.
|
||
_.throttle = function(func, wait, options) {
|
||
var context, args, result;
|
||
var timeout = null;
|
||
var previous = 0;
|
||
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) {
|
||
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 after being called N times.
|
||
_.after = function(times, func) {
|
||
return function() {
|
||
if (--times < 1) {
|
||
return func.apply(this, arguments);
|
||
}
|
||
};
|
||
};
|
||
|
||
// Returns a function that will only be executed before being called N times.
|
||
_.before = function(times, func) {
|
||
var memo;
|
||
return function() {
|
||
if (--times > 0) {
|
||
memo = func.apply(this, arguments);
|
||
} else {
|
||
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
|
||
// ----------------
|
||
|
||
// Retrieve the names of an object's properties.
|
||
// Delegates to **ECMAScript 5**'s native `Object.keys`
|
||
_.keys = function(obj) {
|
||
if (!_.isObject(obj)) return [];
|
||
if (nativeKeys) return nativeKeys(obj);
|
||
var keys = [];
|
||
for (var key in obj) if (_.has(obj, key)) keys.push(key);
|
||
return keys;
|
||
};
|
||
|
||
// Retrieve the values of an object's properties.
|
||
_.values = function(obj) {
|
||
var keys = _.keys(obj);
|
||
var length = keys.length;
|
||
var values = Array(length);
|
||
for (var i = 0; i < length; i++) {
|
||
values[i] = obj[keys[i]];
|
||
}
|
||
return values;
|
||
};
|
||
|
||
// Convert an object into a list of `[key, value]` pairs.
|
||
_.pairs = function(obj) {
|
||
var keys = _.keys(obj);
|
||
var length = keys.length;
|
||
var pairs = Array(length);
|
||
for (var i = 0; i < length; i++) {
|
||
pairs[i] = [keys[i], obj[keys[i]]];
|
||
}
|
||
return pairs;
|
||
};
|
||
|
||
// Invert the keys and values of an object. The values must be serializable.
|
||
_.invert = function(obj) {
|
||
var result = {};
|
||
var keys = _.keys(obj);
|
||
for (var i = 0, length = keys.length; i < length; i++) {
|
||
result[obj[keys[i]]] = keys[i];
|
||
}
|
||
return result;
|
||
};
|
||
|
||
// Return a sorted list of the function names available on the object.
|
||
// Aliased as `methods`
|
||
_.functions = _.methods = function(obj) {
|
||
var names = [];
|
||
for (var key in obj) {
|
||
if (_.isFunction(obj[key])) names.push(key);
|
||
}
|
||
return names.sort();
|
||
};
|
||
|
||
// Extend a given object with all the properties in passed-in object(s).
|
||
_.extend = function(obj) {
|
||
if (!_.isObject(obj)) return obj;
|
||
var source, prop;
|
||
for (var i = 1, length = arguments.length; i < length; i++) {
|
||
source = arguments[i];
|
||
for (prop in source) {
|
||
if (hasOwnProperty.call(source, prop)) {
|
||
obj[prop] = source[prop];
|
||
}
|
||
}
|
||
}
|
||
return obj;
|
||
};
|
||
|
||
// Return a copy of the object only containing the whitelisted properties.
|
||
_.pick = function(obj, iteratee, context) {
|
||
var result = {}, key;
|
||
if (obj == null) return result;
|
||
if (_.isFunction(iteratee)) {
|
||
iteratee = createCallback(iteratee, context);
|
||
for (key in obj) {
|
||
var value = obj[key];
|
||
if (iteratee(value, key, obj)) result[key] = value;
|
||
}
|
||
} else {
|
||
var keys = concat.apply([], slice.call(arguments, 1));
|
||
obj = new Object(obj);
|
||
for (var i = 0, length = keys.length; i < length; i++) {
|
||
key = keys[i];
|
||
if (key in obj) result[key] = obj[key];
|
||
}
|
||
}
|
||
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(concat.apply([], slice.call(arguments, 1)), String);
|
||
iteratee = function(value, key) {
|
||
return !_.contains(keys, key);
|
||
};
|
||
}
|
||
return _.pick(obj, iteratee, context);
|
||
};
|
||
|
||
// Fill in a given object with default properties.
|
||
_.defaults = function(obj) {
|
||
if (!_.isObject(obj)) return obj;
|
||
for (var i = 1, length = arguments.length; i < length; i++) {
|
||
var source = arguments[i];
|
||
for (var prop in source) {
|
||
if (obj[prop] === void 0) obj[prop] = source[prop];
|
||
}
|
||
}
|
||
return obj;
|
||
};
|
||
|
||
// Create a (shallow-cloned) duplicate of an object.
|
||
_.clone = function(obj) {
|
||
if (!_.isObject(obj)) return obj;
|
||
return _.isArray(obj) ? obj.slice() : _.extend({}, obj);
|
||
};
|
||
|
||
// Invokes interceptor with the obj, and then returns obj.
|
||
// The primary purpose of this method is to "tap into" a method chain, in
|
||
// order to perform operations on intermediate results within the chain.
|
||
_.tap = function(obj, interceptor) {
|
||
interceptor(obj);
|
||
return obj;
|
||
};
|
||
|
||
// Internal recursive comparison function for `isEqual`.
|
||
var eq = function(a, b, aStack, bStack) {
|
||
// Identical objects are equal. `0 === -0`, but they aren't identical.
|
||
// See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).
|
||
if (a === b) return a !== 0 || 1 / a === 1 / b;
|
||
// A strict comparison is necessary because `null == undefined`.
|
||
if (a == null || b == null) return a === b;
|
||
// Unwrap any wrapped objects.
|
||
if (a instanceof _) a = a._wrapped;
|
||
if (b instanceof _) b = b._wrapped;
|
||
// Compare `[[Class]]` names.
|
||
var className = toString.call(a);
|
||
if (className !== toString.call(b)) return false;
|
||
switch (className) {
|
||
// Strings, numbers, 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;
|
||
}
|
||
if (typeof a != 'object' || typeof b != 'object') return false;
|
||
// Assume equality for cyclic structures. The algorithm for detecting cyclic
|
||
// structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.
|
||
var length = aStack.length;
|
||
while (length--) {
|
||
// Linear search. Performance is inversely proportional to the number of
|
||
// unique nested structures.
|
||
if (aStack[length] === a) return bStack[length] === b;
|
||
}
|
||
// Objects with different constructors are not equivalent, but `Object`s
|
||
// from different frames are.
|
||
var aCtor = a.constructor, bCtor = b.constructor;
|
||
if (
|
||
aCtor !== bCtor &&
|
||
// Handle Object.create(x) cases
|
||
'constructor' in a && 'constructor' in b &&
|
||
!(_.isFunction(aCtor) && aCtor instanceof aCtor &&
|
||
_.isFunction(bCtor) && bCtor instanceof bCtor)
|
||
) {
|
||
return false;
|
||
}
|
||
// Add the first object to the stack of traversed objects.
|
||
aStack.push(a);
|
||
bStack.push(b);
|
||
var size, result;
|
||
// Recursively compare objects and arrays.
|
||
if (className === '[object Array]') {
|
||
// Compare array lengths to determine if a deep comparison is necessary.
|
||
size = a.length;
|
||
result = size === b.length;
|
||
if (result) {
|
||
// Deep compare the contents, ignoring non-numeric properties.
|
||
while (size--) {
|
||
if (!(result = eq(a[size], b[size], aStack, bStack))) break;
|
||
}
|
||
}
|
||
} else {
|
||
// Deep compare objects.
|
||
var keys = _.keys(a), key;
|
||
size = keys.length;
|
||
// Ensure that both objects contain the same number of properties before comparing deep equality.
|
||
result = _.keys(b).length === size;
|
||
if (result) {
|
||
while (size--) {
|
||
// Deep compare each member
|
||
key = keys[size];
|
||
if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;
|
||
}
|
||
}
|
||
}
|
||
// Remove the first object from the stack of traversed objects.
|
||
aStack.pop();
|
||
bStack.pop();
|
||
return result;
|
||
};
|
||
|
||
// Perform a deep comparison to check if two objects are equal.
|
||
_.isEqual = function(a, b) {
|
||
return eq(a, b, [], []);
|
||
};
|
||
|
||
// Is a given array, string, or object empty?
|
||
// An "empty" object has no enumerable own-properties.
|
||
_.isEmpty = function(obj) {
|
||
if (obj == null) return true;
|
||
if (_.isArray(obj) || _.isString(obj) || _.isArguments(obj)) return obj.length === 0;
|
||
for (var key in obj) if (_.has(obj, key)) return false;
|
||
return true;
|
||
};
|
||
|
||
// Is a given value a DOM element?
|
||
_.isElement = function(obj) {
|
||
return !!(obj && obj.nodeType === 1);
|
||
};
|
||
|
||
// Is a given value an array?
|
||
// Delegates to ECMA5's native Array.isArray
|
||
_.isArray = nativeIsArray || function(obj) {
|
||
return toString.call(obj) === '[object Array]';
|
||
};
|
||
|
||
// Is a given variable an object?
|
||
_.isObject = function(obj) {
|
||
var type = typeof obj;
|
||
return type === 'function' || type === 'object' && !!obj;
|
||
};
|
||
|
||
// Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.
|
||
_.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {
|
||
_['is' + name] = function(obj) {
|
||
return toString.call(obj) === '[object ' + name + ']';
|
||
};
|
||
});
|
||
|
||
// Define a fallback version of the method in browsers (ahem, IE), where
|
||
// there isn't any inspectable "Arguments" type.
|
||
if (!_.isArguments(arguments)) {
|
||
_.isArguments = function(obj) {
|
||
return _.has(obj, 'callee');
|
||
};
|
||
}
|
||
|
||
// Optimize `isFunction` if appropriate. Work around an IE 11 bug.
|
||
if (typeof /./ !== 'function') {
|
||
_.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;
|
||
};
|
||
|
||
_.constant = function(value) {
|
||
return function() {
|
||
return value;
|
||
};
|
||
};
|
||
|
||
_.noop = function(){};
|
||
|
||
_.property = function(key) {
|
||
return function(obj) {
|
||
return obj[key];
|
||
};
|
||
};
|
||
|
||
// Returns a predicate for checking whether an object has a given set of `key:value` pairs.
|
||
_.matches = function(attrs) {
|
||
var pairs = _.pairs(attrs), length = pairs.length;
|
||
return function(obj) {
|
||
if (obj == null) return !length;
|
||
obj = new Object(obj);
|
||
for (var i = 0; i < length; i++) {
|
||
var pair = pairs[i], key = pair[0];
|
||
if (pair[1] !== obj[key] || !(key in obj)) return false;
|
||
}
|
||
return true;
|
||
};
|
||
};
|
||
|
||
// Run a function **n** times.
|
||
_.times = function(n, iteratee, context) {
|
||
var accum = Array(Math.max(0, n));
|
||
iteratee = createCallback(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 = {
|
||
'&': '&',
|
||
'<': '<',
|
||
'>': '>',
|
||
'"': '"',
|
||
"'": ''',
|
||
'`': '`'
|
||
};
|
||
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) {
|
||
if (object == null) return void 0;
|
||
var value = object[property];
|
||
return _.isFunction(value) ? object[property]() : 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(obj) {
|
||
return this._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.call(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.call(this, obj);
|
||
};
|
||
});
|
||
|
||
// Add all accessor Array functions to the wrapper.
|
||
_.each(['concat', 'join', 'slice'], function(name) {
|
||
var method = ArrayProto[name];
|
||
_.prototype[name] = function() {
|
||
return result.call(this, method.apply(this._wrapped, arguments));
|
||
};
|
||
});
|
||
|
||
// Extracts the result from a wrapped and chained object.
|
||
_.prototype.value = function() {
|
||
return this._wrapped;
|
||
};
|
||
|
||
// AMD registration happens at the end for compatibility with AMD loaders
|
||
// that may not enforce next-turn semantics on modules. Even though general
|
||
// practice for AMD registration is to be anonymous, underscore registers
|
||
// as a named module because, like jQuery, it is a base library that is
|
||
// popular enough to be bundled in a third party lib, but not be part of
|
||
// an AMD load request. Those cases could generate an error when an
|
||
// anonymous define() is called outside of a loader request.
|
||
if (typeof define === 'function' && define.amd) {
|
||
define('underscore', [], function() {
|
||
return _;
|
||
});
|
||
}
|
||
}.call(this));
|
||
|
||
},{}],77:[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 = 4;
|
||
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 [
|
||
{
|
||
f: (function(_this) {
|
||
return function(y) {
|
||
y;
|
||
var pos;
|
||
pos = _.random(0, y.val().length - 1);
|
||
y.insert(pos, _this.getRandomText());
|
||
return null;
|
||
};
|
||
})(this),
|
||
types: [Y.Text]
|
||
}, {
|
||
f: function(y) {
|
||
var length, ops1, pos;
|
||
if (y.val().length > 0) {
|
||
pos = _.random(0, y.val().length - 1);
|
||
length = _.random(0, y.val().length - pos);
|
||
ops1 = y["delete"](pos, length);
|
||
}
|
||
return void 0;
|
||
},
|
||
types: [Y.Text]
|
||
}
|
||
];
|
||
};
|
||
|
||
Test.prototype.getRandomRoot = function(user_num) {
|
||
throw new Error("implement me!");
|
||
};
|
||
|
||
Test.prototype.compare = function(o1, o2, depth) {
|
||
var i, name, o, val, _i, _len, _ref, _results, _results1;
|
||
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._name === "Object" || 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._name != null) {
|
||
return this.compare(o1.val(), o2.val(), depth - 1);
|
||
} else if (o1.constructor === Array && o2.constructor === Array) {
|
||
if (o1.length !== o2.length) {
|
||
throw new Error("The Arrays do not have the same size!");
|
||
}
|
||
_results1 = [];
|
||
for (i = _i = 0, _len = o1.length; _i < _len; i = ++_i) {
|
||
o = o1[i];
|
||
_results1.push(this.compare(o, o2[i], depth - 1));
|
||
}
|
||
return _results1;
|
||
} 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":1,"chai":11,"sinon":51,"sinon-chai":50,"underscore":76}],78:[function(require,module,exports){
|
||
var Connector, Test, TextTest, 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("../lib/y");
|
||
|
||
Y.Text = require("../lib/Types/Text");
|
||
|
||
Connector = require("../../y-test/lib/y-test.coffee");
|
||
|
||
Test = require("./TestSuite");
|
||
|
||
TextTest = (function(_super) {
|
||
__extends(TextTest, _super);
|
||
|
||
function TextTest(suffix) {
|
||
TextTest.__super__.constructor.call(this, suffix, Y);
|
||
}
|
||
|
||
TextTest.prototype.type = "TextTest";
|
||
|
||
TextTest.prototype.makeNewUser = function(userId) {
|
||
var conn;
|
||
conn = new Connector(userId);
|
||
return new Y(conn);
|
||
};
|
||
|
||
TextTest.prototype.initUsers = function(u) {
|
||
return u.val("TextTest", new Y.Text());
|
||
};
|
||
|
||
TextTest.prototype.getRandomRoot = function(user_num) {
|
||
return this.users[user_num].val("TextTest");
|
||
};
|
||
|
||
TextTest.prototype.getContent = function(user_num) {
|
||
return this.users[user_num].val("TextTest").val();
|
||
};
|
||
|
||
return TextTest;
|
||
|
||
})(Test);
|
||
|
||
describe("TextFramework", function() {
|
||
this.timeout(500000);
|
||
beforeEach(function(done) {
|
||
this.yTest = new TextTest();
|
||
return done();
|
||
});
|
||
it("simple multi-char insert", function() {
|
||
var u;
|
||
u = this.yTest.users[0].val("TextTest");
|
||
u.insert(0, "abc");
|
||
u = this.yTest.users[1].val("TextTest");
|
||
u.insert(0, "xyz");
|
||
this.yTest.compareAll();
|
||
u["delete"](0, 1);
|
||
this.yTest.compareAll();
|
||
return expect(u.val()).to.equal("bcxyz");
|
||
});
|
||
it("Observers work on shared Text (insert type observers, local and foreign)", function() {
|
||
var last_task, observer1, observer2, u, v;
|
||
u = this.yTest.users[0].val("TextTest", new Y.Text("my awesome Text")).val("TextTest");
|
||
this.yTest.flushAll();
|
||
last_task = null;
|
||
observer1 = function(changes) {
|
||
var change;
|
||
expect(changes.length).to.equal(1);
|
||
change = changes[0];
|
||
expect(change.type).to.equal("insert");
|
||
expect(change.object).to.equal(u);
|
||
expect(change.value).to.equal("a");
|
||
expect(change.position).to.equal(1);
|
||
expect(change.changedBy).to.equal('0');
|
||
return last_task = "observer1";
|
||
};
|
||
u.observe(observer1);
|
||
u.insert(1, "a");
|
||
expect(last_task).to.equal("observer1");
|
||
u.unobserve(observer1);
|
||
observer2 = function(changes) {
|
||
var change;
|
||
expect(changes.length).to.equal(1);
|
||
change = changes[0];
|
||
expect(change.type).to.equal("insert");
|
||
expect(change.object).to.equal(u);
|
||
expect(change.value).to.equal("x");
|
||
expect(change.position).to.equal(0);
|
||
expect(change.changedBy).to.equal('1');
|
||
return last_task = "observer2";
|
||
};
|
||
u.observe(observer2);
|
||
v = this.yTest.users[1].val("TextTest");
|
||
v.insert(0, "x");
|
||
this.yTest.flushAll();
|
||
expect(last_task).to.equal("observer2");
|
||
return u.unobserve(observer2);
|
||
});
|
||
it("Observers work on shared Text (delete type observers, local and foreign)", function() {
|
||
var last_task, observer1, observer2, u, v;
|
||
u = this.yTest.users[0].val("TextTest", new Y.Text("my awesome Text")).val("TextTest");
|
||
this.yTest.flushAll();
|
||
last_task = null;
|
||
observer1 = function(changes) {
|
||
var change;
|
||
expect(changes.length).to.equal(1);
|
||
change = changes[0];
|
||
expect(change.type).to.equal("delete");
|
||
expect(change.object).to.equal(u);
|
||
expect(change.position).to.equal(1);
|
||
expect(change.length).to.equal(1);
|
||
expect(change.changedBy).to.equal('0');
|
||
return last_task = "observer1";
|
||
};
|
||
u.observe(observer1);
|
||
u["delete"](1, 1);
|
||
expect(last_task).to.equal("observer1");
|
||
u.unobserve(observer1);
|
||
observer2 = function(changes) {
|
||
var change;
|
||
expect(changes.length).to.equal(1);
|
||
change = changes[0];
|
||
expect(change.type).to.equal("delete");
|
||
expect(change.object).to.equal(u);
|
||
expect(change.position).to.equal(0);
|
||
expect(change.length).to.equal(1);
|
||
expect(change.changedBy).to.equal('1');
|
||
return last_task = "observer2";
|
||
};
|
||
u.observe(observer2);
|
||
v = this.yTest.users[1].val("TextTest");
|
||
v["delete"](0, 1);
|
||
this.yTest.flushAll();
|
||
expect(last_task).to.equal("observer2");
|
||
return u.unobserve(observer2);
|
||
});
|
||
it("can handle many engines, many operations, concurrently (random)", function() {
|
||
console.log("testiy deleted this TODO:dtrn");
|
||
return this.yTest.run();
|
||
});
|
||
return it("handles double-late-join", function() {
|
||
var compare, ops1, ops2, test, u1, u2;
|
||
test = new TextTest("double");
|
||
test.run();
|
||
this.yTest.run();
|
||
u1 = test.users[0];
|
||
u2 = this.yTest.users[1];
|
||
ops1 = u1._model.HB._encode();
|
||
ops2 = u2._model.HB._encode();
|
||
u1._model.engine.applyOp(ops2, true);
|
||
u2._model.engine.applyOp(ops1, true);
|
||
compare = function(o1, o2) {
|
||
var name, val, _ref, _results;
|
||
if ((o1._name != null) && o1._name !== o2._name) {
|
||
throw new Error("different types");
|
||
} else if (o1._name === "Object") {
|
||
_ref = o1.val();
|
||
_results = [];
|
||
for (name in _ref) {
|
||
val = _ref[name];
|
||
_results.push(compare(val, o2.val(name)));
|
||
}
|
||
return _results;
|
||
} else if (o1._name != null) {
|
||
return compare(o1.val(), o2.val());
|
||
} else if (o1 !== o2) {
|
||
throw new Error("different values");
|
||
}
|
||
};
|
||
compare(u1, u2);
|
||
return expect(test.getContent(0)).to.deep.equal(this.yTest.getContent(1));
|
||
});
|
||
});
|
||
|
||
|
||
},{"../../y-test/lib/y-test.coffee":1,"../lib/Types/Text":9,"../lib/y":10,"./TestSuite":77,"chai":11,"sinon":51,"sinon-chai":50,"underscore":76}]},{},[78])
|
||
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/codio/workspace/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/browser-pack/_prelude.js","/home/codio/workspace/y-test/lib/y-test.coffee","/home/codio/workspace/yjs/lib/ConnectorAdapter.coffee","/home/codio/workspace/yjs/lib/ConnectorClass.coffee","/home/codio/workspace/yjs/lib/Engine.coffee","/home/codio/workspace/yjs/lib/HistoryBuffer.coffee","/home/codio/workspace/yjs/lib/Operations/Basic.coffee","/home/codio/workspace/yjs/lib/Operations/Structured.coffee","/home/codio/workspace/yjs/lib/Types/Object.coffee","/home/codio/workspace/yjs/lib/Types/Text.coffee","/home/codio/workspace/yjs/lib/y.coffee","/home/codio/workspace/yjs/node_modules/chai/index.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/assertion.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/config.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/core/assertions.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/interface/assert.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/interface/expect.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/interface/should.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/addChainableMethod.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/addMethod.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/addProperty.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/flag.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/getActual.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/getEnumerableProperties.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/getMessage.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/getName.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/getPathValue.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/getProperties.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/index.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/inspect.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/objDisplay.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/overwriteChainableMethod.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/overwriteMethod.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/overwriteProperty.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/test.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/transferFlags.js","/home/codio/workspace/yjs/node_modules/chai/lib/chai/utils/type.js","/home/codio/workspace/yjs/node_modules/chai/node_modules/assertion-error/index.js","/home/codio/workspace/yjs/node_modules/chai/node_modules/deep-eql/index.js","/home/codio/workspace/yjs/node_modules/chai/node_modules/deep-eql/lib/eql.js","/home/codio/workspace/yjs/node_modules/chai/node_modules/deep-eql/node_modules/type-detect/index.js","/home/codio/workspace/yjs/node_modules/chai/node_modules/deep-eql/node_modules/type-detect/lib/type.js","/home/codio/workspace/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/buffer/index.js","/home/codio/workspace/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/buffer/node_modules/base64-js/lib/b64.js","/home/codio/workspace/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/buffer/node_modules/ieee754/index.js","/home/codio/workspace/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/inherits/inherits_browser.js","/home/codio/workspace/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/process/browser.js","/home/codio/workspace/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/util/support/isBufferBrowser.js","/home/codio/workspace/yjs/node_modules/gulp-browserify/node_modules/browserify/node_modules/util/util.js","/home/codio/workspace/yjs/node_modules/sinon-chai/lib/sinon-chai.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/assert.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/behavior.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/call.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/collection.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/extend.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/format.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/log_error.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/match.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/mock.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/sandbox.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/spy.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/stub.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/test.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/test_case.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/times_in_words.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/typeOf.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/util/core.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/util/event.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/util/fake_server.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/util/fake_timers.js","/home/codio/workspace/yjs/node_modules/sinon/lib/sinon/util/fake_xml_http_request.js","/home/codio/workspace/yjs/node_modules/sinon/node_modules/formatio/lib/formatio.js","/home/codio/workspace/yjs/node_modules/sinon/node_modules/formatio/node_modules/samsam/lib/samsam.js","/home/codio/workspace/yjs/node_modules/sinon/node_modules/lolex/src/lolex.js","/home/codio/workspace/yjs/node_modules/underscore/underscore.js","/home/codio/workspace/yjs/test/TestSuite.coffee","/home/codio/workspace/yjs/test/Text_test.coffee"],"names":[],"mappings":"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AAP,GAAiB,OAjCjB,CAAA;;AAkCA,IAAG,gDAAH;AACE,EAAA,MAAM,CAAC,CAAP,GAAW,OAAX,CADF;CAlCA;;AAAA,OAqCO,CAAC,MAAR,GAAiB,OAAA,CAAQ,gBAAR,CArCjB,CAAA;;;;ACDA;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;;ACvFA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACvIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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/0CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AChiCA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9EA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;;ACtGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;;ACvBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;;ACLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5kBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;;AClNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AClNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACtKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;;AC7PA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACjKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;;ACtTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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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nmBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;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;;ACv4CA,IAAA,qDAAA;EAAA,kFAAA;;AAAA,IAAA,GAAY,OAAA,CAAQ,MAAR,CAAZ,CAAA;;AAAA,MACA,GAAY,IAAI,CAAC,MADjB,CAAA;;AAAA,KAEA,GAAY,OAAA,CAAQ,OAAR,CAFZ,CAAA;;AAAA,SAGA,GAAY,OAAA,CAAQ,YAAR,CAHZ,CAAA;;AAAA,CAIA,GAAY,OAAA,CAAQ,YAAR,CAJZ,CAAA;;AAAA,IAMI,CAAC,GAAL,CAAS,SAAT,CANA,CAAA;;AAAA,SAQA,GAAY,OAAA,CAAQ,gCAAR,CARZ,CAAA;;AAAA,CASA,GAAI,IATJ,CAAA;;AAAA,MAWM,CAAC,OAAP,GAAuB;AACR,EAAA,cAAE,WAAF,EAAoB,GAApB,GAAA;AACX,QAAA,uCAAA;AAAA,IADY,IAAC,CAAA,oCAAA,cAAc,EAC3B,CAAA;AAAA,yDAAA,CAAA;AAAA,+DAAA,CAAA;AAAA,2EAAA,CAAA;AAAA,IAAA,CAAA,GAAI,GAAJ,CAAA;AAAA,IACA,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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})","\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","\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  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\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\n  #\n  # Execute a function _when_ we are connected. If not connected, wait until connected.\n  # @param f {Function} Will be executed on the PeerJs-Connector context.\n  #\n  whenSynced: (args)->\n    if args.constructore 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 > 30\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: []\n    hb = @getHB([]).hb\n    _hb = []\n    for o in hb\n      _hb.push o\n      if _hb.length > 30\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 f in @compute_when_synced\n          f()\n        delete @compute_when_synced\n      null\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        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 > 30\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              @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  resetUserId: (id)->\n    own = @buffer[@user_id]\n    if own?\n      for o_name,o of own\n        if o.uid.creator?\n          o.uid.creator = id\n        if o.uid.alt?\n          o.uid.alt.creator = id\n      if @buffer[id]?\n        throw new Error \"You are re-assigning an old user id - this is not (yet) possible!\"\n      @buffer[id] = own\n      delete @buffer[@user_id]\n    if @operation_counter[@user_id]?\n      @operation_counter[id] = @operation_counter[@user_id]\n      delete @operation_counter[@user_id]\n    @user_id = id\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    if o.uid.creator isnt @getUserId()\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\n    #if @operation_counter[o.uid.creator] isnt (o.uid.op_number + 1)\n      #console.log (@operation_counter[o.uid.creator] - (o.uid.op_number + 1))\n      #console.log o\n      #throw new Error \"You don't receive operations in the proper order. Try counting like this 0,1,2,3,4,.. ;)\"\n\nmodule.exports = HistoryBuffer\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)->\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    type: \"Operation\"\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      @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\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      json\n\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)->\n\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        @[name] = op\n      else\n        # not initialized. Do it when calling $validateSavedOperations()\n        @unchecked ?= {}\n        @unchecked[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 = @\n      for name, op_uid of @unchecked\n        op = @HB.getOperation op_uid\n        if op\n          @[name] = op\n        else\n          uninstantiated[name] = op_uid\n          success = false\n      delete @unchecked\n      if not success\n        @unchecked = uninstantiated\n      success\n\n    getCustomType: ()->\n      if not @custom_type?\n        throw new Error \"This operation was not initialized with a custom type\"\n      if @custom_type.constructor is String\n        # has not been initialized yet (only the name is specified)\n        @custom_type = new @custom_types[@custom_type]()\n        @custom_type._setModel @\n      @custom_type\n\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\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, uid, prev_cl, next_cl, origin, parent)->\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      @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\n\n    type: \"Insert\"\n\n    val: ()->\n      if @content? and @content.getCustomType?\n        @content.getCustomType()\n      else\n        @content\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        @callOperationSpecificDeleteEvents(o)\n      if @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        if @content instanceof ops.Operation and not deleted_earlyer\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        @callOperationSpecificInsertEvents()\n        @\n\n    callOperationSpecificInsertEvents: ()->\n      getContentType = (content)->\n        if content instanceof ops.Operation\n          content.getCustomType()\n        else\n          content\n      @parent?.callEvent [\n        type: \"insert\"\n        position: @getPosition()\n        object: @parent.getCustomType()\n        changedBy: @uid.creator\n        value: getContentType @content\n      ]\n\n    callOperationSpecificDeleteEvents: (o)->\n      @parent.callEvent [\n        type: \"delete\"\n        position: @getPosition()\n        object: @parent.getCustomType() # TODO: You can combine getPosition + getParent in a more efficient manner! (only left Delimiter will hold @parent)\n        length: 1\n        changedBy: o.uid.creator\n        oldValue: @val()\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      json.parent = @parent.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 @content?.getUid?\n        json['content'] = @content.getUid()\n      else\n        json['content'] = JSON.stringify @content\n      super json\n\n  ops.Insert.parse = (json)->\n    {\n      'content' : content\n      'uid' : uid\n      'prev': prev\n      'next': next\n      'origin' : origin\n      'parent' : parent\n    } = json\n    if typeof content is \"string\"\n      content = JSON.parse(content)\n    new this null, content, uid, prev, next, origin, parent\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\n\n\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)->\n      @_map = {}\n      super custom_type, uid\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    } = json\n    new this(custom_type, uid)\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)->\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\n\n    type: \"ListManager\"\n\n    applyDelete: ()->\n      o = @end\n      while o?\n        o.applyDelete()\n        o = o.prev_cl\n      super()\n\n    cleanup: ()->\n      super()\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\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, 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, 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  ops.ListManager.parse = (json)->\n    {\n      'uid' : uid\n      'custom_type': custom_type\n    } = json\n    new this(custom_type, uid)\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, beginning, end)->\n      if not @event_properties['object']?\n        @event_properties['object'] = @event_this.getCustomType()\n      super custom_type, uid, beginning, end\n\n    type: \"ReplaceManager\"\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    # 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    # 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.Replaceable null, content, @, 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      (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    # Encode this operation in such a way that it can be parsed by remote peers.\n    #\n    _encode: (json = {})->\n      json.beginning = @beginning.getUid()\n      json.end = @end.getUid()\n      super json\n\n  #\n  # @nodoc\n  # The ReplaceManager manages Replaceables.\n  # @see ReplaceManager\n  #\n  class ops.Replaceable extends ops.Insert\n\n    #\n    # @param {Operation} content The value that this Replaceable holds.\n    # @param {ReplaceManager} parent Used to replace this Replaceable with another one.\n    # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n    #\n    constructor: (custom_type, content, parent, uid, prev, next, origin)->\n      @saveOperation 'parent', parent\n      super custom_type, content, uid, prev, next, origin # Parent is already saved by Replaceable\n\n    type: \"Replaceable\"\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: ()->\n      if @next_cl.type is \"Delimiter\" and @prev_cl.type isnt \"Delimiter\"\n        # this replaces another Replaceable\n        if not @is_deleted # When this is received from the HB, this could already be deleted!\n          old_value = @prev_cl.val()\n          @parent.callEventDecorator [\n            type: \"update\"\n            changedBy: @uid.creator\n            oldValue: old_value\n          ]\n        @prev_cl.applyDelete()\n      else if @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        @applyDelete()\n      else # prev _and_ next are Delimiters. This is the first created Replaceable in the RM\n        @parent.callEventDecorator [\n          type: \"add\"\n          changedBy: @uid.creator\n        ]\n      undefined\n\n    callOperationSpecificDeleteEvents: (o)->\n      if @next_cl.type is \"Delimiter\"\n        @parent.callEventDecorator [\n          type: \"delete\"\n          changedBy: o.uid.creator\n          oldValue: @val()\n        ]\n\n    #\n    # Encode this operation in such a way that it can be parsed by remote peers.\n    #\n    _encode: (json = {})->\n      super json\n\n  ops.Replaceable.parse = (json)->\n    {\n      'content' : content\n      'parent' : parent\n      'uid' : uid\n      'prev': prev\n      'next': next\n      'origin' : origin\n      'custom_type' : custom_type\n    } = json\n    if typeof content is \"string\"\n      content = JSON.parse(content)\n    new this(custom_type, content, parent, uid, prev, next, origin)\n\n\n  basic_ops\n\n\n\n\n\n\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 [Object Type||String|Object] Depending on the value of the property. If mutable it will return a Operation-type object, if immutable it will return String/Object.\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\n\n\n\n\n\n\n\n","#\n# Handles a String-like data structures with support for insert/delete at a word-position.\n#\nclass YText\n\n  #\n  # @private\n  # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n  #\n  constructor: (text)->\n    @textfields = []\n    if not text?\n      @_text = \"\"\n    else if text.constructor is String\n      @_text = text\n    else\n      throw new Error \"Y.Text expects a String as a constructor\"\n\n  _name: \"Text\"\n\n  _getModel: (types, ops)->\n    if not @_model?\n      @_model = new ops.ListManager(@).execute()\n      @insert 0, @_text\n    delete @_text\n    @_model\n\n  _setModel: (@_model)->\n    delete @_text\n\n  #\n  # Get the String-representation of this word.\n  # @return {String} The String-representation of this object.\n  #\n  val: ()->\n    @_model.fold \"\", (left, o)->\n      left + o.val()\n\n  observe: ()->\n    @_model.observe.apply @_model, arguments\n\n  unobserve: ()->\n    @_model.unobserve.apply @_model, arguments\n\n  #\n  # Same as String.val\n  # @see String.val\n  #\n  toString: ()->\n    @val()\n\n  #\n  # Inserts a string into the word.\n  #\n  # @return {ListManager Type} This String object.\n  #\n  insert: (position, content)->\n    if content.constructor isnt String\n      throw new Error \"Y.String.insert expects a String as the second parameter!\"\n    if typeof position isnt \"number\"\n      throw new Error \"Y.String.insert expects a Number as the first parameter!\"\n    if content.length > 0\n      ith = @_model.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      @_model.insertAfter ith, content\n\n  delete: (position, length)->\n    @_model.delete position, length\n\n  #\n  # Bind this String to a textfield or input field.\n  #\n  # @example\n  #   var textbox = document.getElementById(\"textfield\");\n  #   y.bind(textbox);\n  #\n  bind: (textfield, dom_root)->\n    dom_root ?= window\n    if (not dom_root.getSelection?)\n      dom_root = window\n\n    # don't duplicate!\n    for t in @textfields\n      if t is textfield\n        return\n    creator_token = false;\n\n    word = @\n    textfield.value = @val()\n    @textfields.push textfield\n\n    if textfield.selectionStart? and textfield.setSelectionRange?\n      createRange = (fix)->\n        left = textfield.selectionStart\n        right = textfield.selectionEnd\n        if fix?\n          left = fix left\n          right = fix right\n        {\n          left: left\n          right: right\n        }\n\n      writeRange = (range)->\n        writeContent word.val()\n        textfield.setSelectionRange range.left, range.right\n\n      writeContent = (content)->\n        textfield.value = content\n    else\n      createRange = (fix)->\n        range = {}\n        s = dom_root.getSelection()\n        clength = textfield.textContent.length\n        range.left = Math.min s.anchorOffset, clength\n        range.right = Math.min s.focusOffset, clength\n        if fix?\n          range.left = fix range.left\n          range.right = fix range.right\n\n        edited_element = s.focusNode\n        if edited_element is textfield or edited_element is textfield.childNodes[0]\n          range.isReal = true\n        else\n          range.isReal = false\n        range\n\n      writeRange = (range)->\n        writeContent word.val()\n        textnode = textfield.childNodes[0]\n        if range.isReal and textnode?\n          if range.left < 0\n            range.left = 0\n          range.right = Math.max range.left, range.right\n          if range.right > textnode.length\n            range.right = textnode.length\n          range.left = Math.min range.left, range.right\n          r = document.createRange()\n          r.setStart(textnode, range.left)\n          r.setEnd(textnode, range.right)\n          s = window.getSelection()\n          s.removeAllRanges()\n          s.addRange(r)\n      writeContent = (content)->\n        content_array = content.replace(new RegExp(\"\\n\",'g'),\" \").split(\" \")\n        textfield.innerText = \"\"\n        for c, i in content_array\n          textfield.innerText += c\n          if i isnt content_array.length-1\n            textfield.innerHTML += '&nbsp;'\n\n    writeContent this.val()\n\n    @observe (events)->\n      for event in events\n        if not creator_token\n          if event.type is \"insert\"\n            o_pos = event.position\n            fix = (cursor)->\n              if cursor <= o_pos\n                cursor\n              else\n                cursor += 1\n                cursor\n            r = createRange fix\n            writeRange r\n\n          else if event.type is \"delete\"\n            o_pos = event.position\n            fix = (cursor)->\n              if cursor < o_pos\n                cursor\n              else\n                cursor -= 1\n                cursor\n            r = createRange fix\n            writeRange r\n\n    # consume all text-insert changes.\n    textfield.onkeypress = (event)->\n      if word.is_deleted\n        # if word is deleted, do not do anything ever again\n        textfield.onkeypress = null\n        return true\n      creator_token = true\n      char = null\n      if event.keyCode is 13\n        char = '\\n'\n      else if event.key?\n        if event.charCode is 32\n          char = \" \"\n        else\n          char = event.key\n      else\n        char = window.String.fromCharCode event.keyCode\n      if char.length > 1\n        return true\n      else if char.length > 0\n        r = createRange()\n        pos = Math.min r.left, r.right\n        diff = Math.abs(r.right - r.left)\n        word.delete pos, diff\n        word.insert pos, char\n        r.left = pos + char.length\n        r.right = r.left\n        writeRange r\n\n      event.preventDefault()\n      creator_token = false\n      false\n\n    textfield.onpaste = (event)->\n      if word.is_deleted\n        # if word is deleted, do not do anything ever again\n        textfield.onpaste = null\n        return true\n      event.preventDefault()\n    textfield.oncut = (event)->\n      if word.is_deleted\n        # if word is deleted, do not do anything ever again\n        textfield.oncut = null\n        return true\n      event.preventDefault()\n\n    #\n    # consume deletes. Note that\n    #   chrome: won't consume deletions on keypress event.\n    #   keyCode is deprecated. BUT: I don't see another way.\n    #     since event.key is not implemented in the current version of chrome.\n    #     Every browser supports keyCode. Let's stick with it for now..\n    #\n    textfield.onkeydown = (event)->\n      creator_token = true\n      if word.is_deleted\n        # if word is deleted, do not do anything ever again\n        textfield.onkeydown = null\n        return true\n      r = createRange()\n      pos = Math.min(r.left, r.right, word.val().length)\n      diff = Math.abs(r.left - r.right)\n      if event.keyCode? and event.keyCode is 8 # Backspace\n        if diff > 0\n          word.delete pos, diff\n          r.left = pos\n          r.right = pos\n          writeRange r\n        else\n          if event.ctrlKey? and event.ctrlKey\n            val = word.val()\n            new_pos = pos\n            del_length = 0\n            if pos > 0\n              new_pos--\n              del_length++\n            while new_pos > 0 and val[new_pos] isnt \" \" and val[new_pos] isnt '\\n'\n              new_pos--\n              del_length++\n            word.delete new_pos, (pos-new_pos)\n            r.left = new_pos\n            r.right = new_pos\n            writeRange r\n          else\n            if pos > 0\n              word.delete (pos-1), 1\n              r.left = pos-1\n              r.right = pos-1\n              writeRange r\n        event.preventDefault()\n        creator_token = false\n        return false\n      else if event.keyCode? and event.keyCode is 46 # Delete\n        if diff > 0\n          word.delete pos, diff\n          r.left = pos\n          r.right = pos\n          writeRange r\n        else\n          word.delete pos, 1\n          r.left = pos\n          r.right = pos\n          writeRange r\n        event.preventDefault()\n        creator_token = false\n        return false\n      else\n        creator_token = false\n        true\n\n\nif window?\n  if window.Y?\n    window.Y.Text = YText\n  else\n    throw new Error \"You must first import Y!\"\n\nif module?\n  module.exports = YText\n\n\n\n\n\n\n\n","\nstructured_ops_uninitialized = require \"./Operations/Structured\"\n\nHistoryBuffer = require \"./HistoryBuffer\"\nEngine = require \"./Engine\"\nadaptConnector = require \"./ConnectorAdapter\"\n\ncreateY = (connector)->\n  user_id = null\n  if connector.user_id?\n    user_id = connector.user_id # TODO: change to getUniqueId()\n  else\n    user_id = \"_temp\"\n    connector.on_user_id_set = (id)->\n      user_id = id\n      HB.resetUserId id\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 \"./Types/Object\"\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 = '1.10.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 * 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');\nvar NOOP = function() { };\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.addChainableNoop = function(name, fn) {\n    util.addChainableMethod(this.prototype, name, NOOP, fn);\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 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   * @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,\n   * the value is truncated.\n   *\n   * Set it to zero if you want to disable truncating altogether.\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   * - 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', '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   * @name deep\n   * @api public\n   */\n\n  Assertion.addProperty('deep', function () {\n    flag(this, 'deep', true);\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 `contain` 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   * @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\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   * Can also be used as a function, which prevents some linter errors.\n   *\n   *     expect('everthing').to.be.ok();\n   *     \n   * @name ok\n   * @api public\n   */\n\n  Assertion.addChainableNoop('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   * Can also be used as a function, which prevents some linter errors.\n   *\n   *     expect(true).to.be.true();\n   *\n   * @name true\n   * @api public\n   */\n\n  Assertion.addChainableNoop('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   * Can also be used as a function, which prevents some linter errors.\n   *\n   *     expect(false).to.be.false();\n   *\n   * @name false\n   * @api public\n   */\n\n  Assertion.addChainableNoop('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   * Can also be used as a function, which prevents some linter errors.\n   *\n   *     expect(null).to.be.null();\n   *\n   * @name null\n   * @api public\n   */\n\n  Assertion.addChainableNoop('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   * Can also be used as a function, which prevents some linter errors.\n   *\n   *     expect(undefined).to.be.undefined();\n   *\n   * @name undefined\n   * @api public\n   */\n\n  Assertion.addChainableNoop('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   * Can also be used as a function, which prevents some linter errors.\n   *\n   *     expect(foo).to.exist();\n   *\n   * @name exist\n   * @api public\n   */\n\n  Assertion.addChainableNoop('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, 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   * Can also be used as a function, which prevents some linter errors.\n   *\n   *     expect([]).to.be.empty();\n   *\n   * @name empty\n   * @api public\n   */\n\n  Assertion.addChainableNoop('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   * Can also be used as a function, which prevents some linter errors.\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.addChainableNoop('arguments', checkArguments);\n  Assertion.addChainableNoop('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   * @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 descriptor = flag(this, 'deep') ? 'deep property ' : 'property '\n      , negate = flag(this, 'negate')\n      , obj = flag(this, 'object')\n      , value = flag(this, 'deep')\n        ? _.getPathValue(name, obj)\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          undefined !== value\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 has exactly the given keys, or\n   * asserts the inclusion of some keys when using the\n   * `include` or `contain` modifiers.\n   *\n   *     expect({ foo: 1, bar: 2 }).to.have.keys(['foo', 'bar']);\n   *     expect({ foo: 1, bar: 2, baz: 3 }).to.contain.keys('foo', 'bar');\n   *\n   * @name keys\n   * @alias key\n   * @param {String...|Array} keys\n   * @api public\n   */\n\n  function assertKeys (keys) {\n    var obj = flag(this, 'object')\n      , str\n      , ok = true;\n\n    keys = keys instanceof Array\n      ? keys\n      : Array.prototype.slice.call(arguments);\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\n    // Inclusion\n    ok = keys.every(function(key){\n      return ~actual.indexOf(key);\n    });\n\n    // Strict\n    if (!flag(this, 'negate') && !flag(this, 'contains')) {\n      ok = ok && keys.length == actual.length;\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      str = keys.join(', ') + ', and ' + last;\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.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 * 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.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    if (!~['==', '===', '>', '>=', '<', '<=', '!=', '!=='].indexOf(operator)) {\n      throw new Error('Invalid operator \"' + operator + '\"');\n    }\n    var test = new Assertion(eval(val + operator + val2), 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   * ### .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   * 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","/*!\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) {\n        return new Assertion(this.constructor(this), null, shouldGetter);\n      } else if (this instanceof Boolean) {\n        return new Assertion(this == true, 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    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 - getPathValue utility\n * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>\n * @see https://github.com/logicalparadox/filtr\n * MIT Licensed\n */\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 */\n\nvar getPathValue = module.exports = function (path, obj) {\n  var parsed = parsePath(path);\n  return _getPathValue(parsed, obj);\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 *\n * @param {String} path\n * @returns {Object} parsed\n * @api private\n */\n\nfunction parsePath (path) {\n  var str = path.replace(/\\[/g, '.[')\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 };\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 * @returns {Object|Undefined} value\n * @api private\n */\n\nfunction _getPathValue (parsed, obj) {\n  var tmp = obj\n    , res;\n  for (var i = 0, l = parsed.length; 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 - 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\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 * 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, fn)\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 too; usually a new assertion\n * @param {Boolean} includeAll\n * @name getAllFlags\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","/*!\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 : {})","(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 stub.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 (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        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.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        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\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            var callArgProp = behavior.callArgProp;\n\n            for (var i = 0, l = args.length; i < l; ++i) {\n                if (!callArgProp && typeof args[i] == \"function\") {\n                    return args[i];\n                }\n\n                if (callArgProp && args[i] &&\n                    typeof args[i][callArgProp] == \"function\") {\n                    return args[i][callArgProp];\n                }\n            }\n\n            return null;\n        }\n\n        return args[callArgAt];\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 = -1;\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 = -1;\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 = -1;\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 = -1;\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        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                for (var i = 0, l = arguments.length; 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                for (var i = 0, l = arguments.length; 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        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 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 ../sinon.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 ../sinon.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 ../sinon.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        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 extend.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(\"./call\");\n        require(\"./match\");\n        require(\"./spy\");\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(\"./util/fake_server\");\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    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) {\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            var method = object[property];\n            return sinon.wrapMethod(object, property, spy.create(method));\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) {\n            // Retain the function length:\n            var p;\n            if (func.length) {\n                eval(\"p = (function proxy(\" + vars.substring(0, func.length * 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\n            create: function create(func) {\n                var name;\n\n                if (typeof func != \"function\") {\n                    func = function () { };\n                } else {\n                    name = sinon.functionName(func);\n                }\n\n                var proxy = createProxy(func);\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        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\") {\n                throw new TypeError(\"Custom stub should be function\");\n            }\n\n            var wrapper;\n\n            if (func) {\n                wrapper = sinon.spy && sinon.spy.create ? sinon.spy.create(func) : func;\n            } else {\n                wrapper = stub.create();\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() {\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);\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        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 stub.js\n * @depend mock.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        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 exception, result;\n                var doneIsWrapped = false;\n                var argumentsCopy = Array.prototype.slice.call(arguments);\n                if (argumentsCopy.length > 0 && typeof argumentsCopy[arguments.length - 1] == \"function\") {\n                    var oldDone = argumentsCopy[arguments.length - 1];\n                    argumentsCopy[arguments.length - 1] = function done(result) {\n                        if (result) {\n                            sandbox.restore();\n                            throw exception;\n                        } else {\n                            sandbox.verifyAndRestore();\n                        }\n                        oldDone(result);\n                    }\n                    doneIsWrapped = true;\n                }\n\n                var args = argumentsCopy.concat(sandbox.args);\n\n                try {\n                    result = callback.apply(this, args);\n                } catch (e) {\n                    exception = e;\n                }\n\n                if (!doneIsWrapped) {\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        return;\n    } else {\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 ../sinon.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 ../sinon.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    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\") {\n                throw new TypeError(\"Method wrapper should be function\");\n            }\n\n            var wrappedMethod = object[property],\n                error;\n\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            // 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            object[property] = method;\n            method.displayName = property;\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                    delete object[property];\n                }\n                if (object[property] === method) {\n                    object[property] = wrappedMethod;\n                }\n            };\n\n            method.restore.sinon = true;\n            mirrorProperties(method, wrappedMethod);\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.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        };\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_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                this.xhr = sinon.useFakeXMLHttpRequest();\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.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_xml_http_request\");\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","(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) {\n        var sinon = require(\"./core\");\n        makeApi(sinon, require(\"lolex\"));\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}(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 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                        }\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 {\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            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(\"./event\");\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 self !== \"undefined\" ? self : this);\n","(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.7.0\n//     http://underscorejs.org\n//     (c) 2009-2014 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    concat           = ArrayProto.concat,\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\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.7.0';\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 createCallback = 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  _.iteratee = function(value, context, argCount) {\n    if (value == null) return _.identity;\n    if (_.isFunction(value)) return createCallback(value, context, argCount);\n    if (_.isObject(value)) return _.matches(value);\n    return _.property(value);\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    if (obj == null) return obj;\n    iteratee = createCallback(iteratee, context);\n    var i, length = obj.length;\n    if (length === +length) {\n      for (i = 0; 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    if (obj == null) return [];\n    iteratee = _.iteratee(iteratee, context);\n    var keys = obj.length !== +obj.length && _.keys(obj),\n        length = (keys || obj).length,\n        results = Array(length),\n        currentKey;\n    for (var index = 0; index < length; index++) {\n      currentKey = keys ? keys[index] : index;\n      results[index] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  };\n\n  var reduceError = 'Reduce of empty array with no initial value';\n\n  // **Reduce** builds up a single result from a list of values, aka `inject`,\n  // or `foldl`.\n  _.reduce = _.foldl = _.inject = function(obj, iteratee, memo, context) {\n    if (obj == null) obj = [];\n    iteratee = createCallback(iteratee, context, 4);\n    var keys = obj.length !== +obj.length && _.keys(obj),\n        length = (keys || obj).length,\n        index = 0, currentKey;\n    if (arguments.length < 3) {\n      if (!length) throw new TypeError(reduceError);\n      memo = obj[keys ? keys[index++] : index++];\n    }\n    for (; index < length; index++) {\n      currentKey = keys ? keys[index] : index;\n      memo = iteratee(memo, obj[currentKey], currentKey, obj);\n    }\n    return memo;\n  };\n\n  // The right-associative version of reduce, also known as `foldr`.\n  _.reduceRight = _.foldr = function(obj, iteratee, memo, context) {\n    if (obj == null) obj = [];\n    iteratee = createCallback(iteratee, context, 4);\n    var keys = obj.length !== + obj.length && _.keys(obj),\n        index = (keys || obj).length,\n        currentKey;\n    if (arguments.length < 3) {\n      if (!index) throw new TypeError(reduceError);\n      memo = obj[keys ? keys[--index] : --index];\n    }\n    while (index--) {\n      currentKey = keys ? keys[index] : index;\n      memo = iteratee(memo, obj[currentKey], currentKey, obj);\n    }\n    return memo;\n  };\n\n  // Return the first value which passes a truth test. Aliased as `detect`.\n  _.find = _.detect = function(obj, predicate, context) {\n    var result;\n    predicate = _.iteratee(predicate, context);\n    _.some(obj, function(value, index, list) {\n      if (predicate(value, index, list)) {\n        result = value;\n        return true;\n      }\n    });\n    return result;\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    if (obj == null) return results;\n    predicate = _.iteratee(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(_.iteratee(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    if (obj == null) return true;\n    predicate = _.iteratee(predicate, context);\n    var keys = obj.length !== +obj.length && _.keys(obj),\n        length = (keys || obj).length,\n        index, currentKey;\n    for (index = 0; index < length; index++) {\n      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    if (obj == null) return false;\n    predicate = _.iteratee(predicate, context);\n    var keys = obj.length !== +obj.length && _.keys(obj),\n        length = (keys || obj).length,\n        index, currentKey;\n    for (index = 0; index < length; index++) {\n      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 value (using `===`).\n  // Aliased as `include`.\n  _.contains = _.include = function(obj, target) {\n    if (obj == null) return false;\n    if (obj.length !== +obj.length) obj = _.values(obj);\n    return _.indexOf(obj, target) >= 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      return (isFunc ? method : value[method]).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, _.matches(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, _.matches(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 = obj.length === +obj.length ? 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 = _.iteratee(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 = obj.length === +obj.length ? 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 = _.iteratee(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 = obj && obj.length === +obj.length ? 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 (obj.length !== +obj.length) 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 = _.iteratee(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 = _.iteratee(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  // 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 = _.iteratee(iteratee, context, 1);\n    var value = iteratee(obj);\n    var low = 0, high = array.length;\n    while (low < high) {\n      var mid = low + high >>> 1;\n      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n    }\n    return low;\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 (obj.length === +obj.length) 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 obj.length === +obj.length ? 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 = _.iteratee(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    if (n < 0) return [];\n    return slice.call(array, 0, 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. The **guard** check allows it to work with\n  // `_.map`.\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. The **guard** check allows it to work with `_.map`.\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 slice.call(array, Math.max(array.length - n, 0));\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. The **guard**\n  // check allows it to work with `_.map`.\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, output) {\n    if (shallow && _.every(input, _.isArray)) {\n      return concat.apply(output, input);\n    }\n    for (var i = 0, length = input.length; i < length; i++) {\n      var value = input[i];\n      if (!_.isArray(value) && !_.isArguments(value)) {\n        if (!strict) output.push(value);\n      } else if (shallow) {\n        push.apply(output, value);\n      } else {\n        flatten(value, shallow, strict, output);\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 (array == null) return [];\n    if (!_.isBoolean(isSorted)) {\n      context = iteratee;\n      iteratee = isSorted;\n      isSorted = false;\n    }\n    if (iteratee != null) iteratee = _.iteratee(iteratee, context);\n    var result = [];\n    var seen = [];\n    for (var i = 0, length = array.length; i < length; i++) {\n      var value = array[i];\n      if (isSorted) {\n        if (!i || seen !== value) result.push(value);\n        seen = value;\n      } else if (iteratee) {\n        var computed = iteratee(value, i, array);\n        if (_.indexOf(seen, computed) < 0) {\n          seen.push(computed);\n          result.push(value);\n        }\n      } else if (_.indexOf(result, value) < 0) {\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    if (array == null) return [];\n    var result = [];\n    var argsLength = arguments.length;\n    for (var i = 0, length = array.length; 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(slice.call(arguments, 1), true, true, []);\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(array) {\n    if (array == null) return [];\n    var length = _.max(arguments, 'length').length;\n    var results = Array(length);\n    for (var i = 0; i < length; i++) {\n      results[i] = _.pluck(arguments, i);\n    }\n    return results;\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    if (list == null) return {};\n    var result = {};\n    for (var i = 0, length = list.length; 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  // 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 = function(array, item, isSorted) {\n    if (array == null) return -1;\n    var i = 0, length = array.length;\n    if (isSorted) {\n      if (typeof isSorted == 'number') {\n        i = isSorted < 0 ? Math.max(0, length + isSorted) : isSorted;\n      } else {\n        i = _.sortedIndex(array, item);\n        return array[i] === item ? i : -1;\n      }\n    }\n    for (; i < length; i++) if (array[i] === item) return i;\n    return -1;\n  };\n\n  _.lastIndexOf = function(array, item, from) {\n    if (array == null) return -1;\n    var idx = array.length;\n    if (typeof from == 'number') {\n      idx = from < 0 ? idx + from + 1 : Math.min(idx, from + 1);\n    }\n    while (--idx >= 0) if (array[idx] === item) return idx;\n    return -1;\n  };\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 (arguments.length <= 1) {\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  // Reusable constructor function for prototype setting.\n  var Ctor = function(){};\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    var args, bound;\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    args = slice.call(arguments, 2);\n    bound = function() {\n      if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));\n      Ctor.prototype = func.prototype;\n      var self = new Ctor;\n      Ctor.prototype = null;\n      var result = func.apply(self, args.concat(slice.call(arguments)));\n      if (_.isObject(result)) return result;\n      return self;\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    return function() {\n      var position = 0;\n      var args = boundArgs.slice();\n      for (var i = 0, length = args.length; i < length; i++) {\n        if (args[i] === _) args[i] = arguments[position++];\n      }\n      while (position < arguments.length) args.push(arguments[position++]);\n      return func.apply(this, args);\n    };\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 = function(func) {\n    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));\n  };\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        clearTimeout(timeout);\n        timeout = null;\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 after being called N times.\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 before being called N times.\n  _.before = function(times, func) {\n    var memo;\n    return function() {\n      if (--times > 0) {\n        memo = func.apply(this, arguments);\n      } else {\n        func = null;\n      }\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  // Retrieve the names of an object's 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    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  // 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 = function(obj) {\n    if (!_.isObject(obj)) return obj;\n    var source, prop;\n    for (var i = 1, length = arguments.length; i < length; i++) {\n      source = arguments[i];\n      for (prop in source) {\n        if (hasOwnProperty.call(source, prop)) {\n            obj[prop] = source[prop];\n        }\n      }\n    }\n    return obj;\n  };\n\n  // Return a copy of the object only containing the whitelisted properties.\n  _.pick = function(obj, iteratee, context) {\n    var result = {}, key;\n    if (obj == null) return result;\n    if (_.isFunction(iteratee)) {\n      iteratee = createCallback(iteratee, context);\n      for (key in obj) {\n        var value = obj[key];\n        if (iteratee(value, key, obj)) result[key] = value;\n      }\n    } else {\n      var keys = concat.apply([], slice.call(arguments, 1));\n      obj = new Object(obj);\n      for (var i = 0, length = keys.length; i < length; i++) {\n        key = keys[i];\n        if (key in obj) result[key] = obj[key];\n      }\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(concat.apply([], slice.call(arguments, 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 = function(obj) {\n    if (!_.isObject(obj)) return obj;\n    for (var i = 1, length = arguments.length; i < length; i++) {\n      var source = arguments[i];\n      for (var prop in source) {\n        if (obj[prop] === void 0) obj[prop] = source[prop];\n      }\n    }\n    return obj;\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  // 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    if (typeof a != 'object' || typeof b != 'object') return false;\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    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    // Objects with different constructors are not equivalent, but `Object`s\n    // from different frames are.\n    var aCtor = a.constructor, bCtor = b.constructor;\n    if (\n      aCtor !== bCtor &&\n      // Handle Object.create(x) cases\n      'constructor' in a && 'constructor' in b &&\n      !(_.isFunction(aCtor) && aCtor instanceof aCtor &&\n        _.isFunction(bCtor) && bCtor instanceof bCtor)\n    ) {\n      return false;\n    }\n    // Add the first object to the stack of traversed objects.\n    aStack.push(a);\n    bStack.push(b);\n    var size, result;\n    // Recursively compare objects and arrays.\n    if (className === '[object Array]') {\n      // Compare array lengths to determine if a deep comparison is necessary.\n      size = a.length;\n      result = size === b.length;\n      if (result) {\n        // Deep compare the contents, ignoring non-numeric properties.\n        while (size--) {\n          if (!(result = eq(a[size], b[size], aStack, bStack))) break;\n        }\n      }\n    } else {\n      // Deep compare objects.\n      var keys = _.keys(a), key;\n      size = keys.length;\n      // Ensure that both objects contain the same number of properties before comparing deep equality.\n      result = _.keys(b).length === size;\n      if (result) {\n        while (size--) {\n          // Deep compare each member\n          key = keys[size];\n          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;\n        }\n      }\n    }\n    // Remove the first object from the stack of traversed objects.\n    aStack.pop();\n    bStack.pop();\n    return result;\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 (_.isArray(obj) || _.isString(obj) || _.isArguments(obj)) return obj.length === 0;\n    for (var key in obj) if (_.has(obj, key)) return false;\n    return true;\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.\n  _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], 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), 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 an IE 11 bug.\n  if (typeof /./ !== 'function') {\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  _.constant = function(value) {\n    return function() {\n      return value;\n    };\n  };\n\n  _.noop = function(){};\n\n  _.property = function(key) {\n    return function(obj) {\n      return obj[key];\n    };\n  };\n\n  // Returns a predicate for checking whether an object has a given set of `key:value` pairs.\n  _.matches = function(attrs) {\n    var pairs = _.pairs(attrs), length = pairs.length;\n    return function(obj) {\n      if (obj == null) return !length;\n      obj = new Object(obj);\n      for (var i = 0; i < length; i++) {\n        var pair = pairs[i], key = pair[0];\n        if (pair[1] !== obj[key] || !(key in obj)) return false;\n      }\n      return true;\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 = createCallback(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) {\n    if (object == null) return void 0;\n    var value = object[property];\n    return _.isFunction(value) ? object[property]() : 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(obj) {\n    return this._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.call(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.call(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.call(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  // 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\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\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 = 4\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        f : (y)=> # INSERT TEXT\n          y\n          pos = _.random 0, (y.val().length-1)\n          y.insert pos, @getRandomText()\n          null\n        types: [Y.Text]\n      ,\n        f : (y)-> # DELETE TEXT\n          if y.val().length > 0\n            pos = _.random 0, (y.val().length-1) # TODO: put here also arbitrary number (test behaviour in error cases)\n            length = _.random 0, (y.val().length - pos)\n            ops1 = y.delete pos, length\n          undefined\n        types : [Y.Text]\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._name is \"Object\" or o1.type is \"MapManager\"\n      for name, val of o1.val()\n        @compare(val, o2.val(name), depth-1)\n    else if o1._name?\n      @compare(o1.val(), o2.val(), 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","chai      = require('chai')\nexpect    = chai.expect\nshould    = chai.should()\nsinon     = require('sinon')\nsinonChai = require('sinon-chai')\n_         = require(\"underscore\")\n\nchai.use(sinonChai)\n\nY = require \"../lib/y\"\nY.Text = require \"../lib/Types/Text\"\n\nConnector = require \"../../y-test/lib/y-test.coffee\"\n\nTest = require \"./TestSuite\"\nclass TextTest extends Test\n\n  constructor: (suffix)->\n    super suffix, Y\n\n  type: \"TextTest\"\n\n  makeNewUser: (userId)->\n    conn = new Connector userId\n    new Y conn\n\n  initUsers: (u)->\n    u.val(\"TextTest\",new Y.Text())\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 \"TextFramework\", ->\n  @timeout 500000\n\n  beforeEach (done)->\n    @yTest = new TextTest()\n    done()\n\n  it \"simple multi-char insert\", ->\n    u = @yTest.users[0].val(\"TextTest\")\n    u.insert 0, \"abc\"\n    u = @yTest.users[1].val(\"TextTest\")\n    u.insert 0, \"xyz\"\n    @yTest.compareAll()\n    u.delete 0, 1\n    @yTest.compareAll()\n    expect(u.val()).to.equal(\"bcxyz\")\n\n  it \"Observers work on shared Text (insert type observers, local and foreign)\", ->\n    u = @yTest.users[0].val(\"TextTest\",new Y.Text(\"my awesome Text\")).val(\"TextTest\")\n    @yTest.flushAll()\n    last_task = null\n    observer1 = (changes)->\n      expect(changes.length).to.equal(1)\n      change = changes[0]\n      expect(change.type).to.equal(\"insert\")\n      expect(change.object).to.equal(u)\n      expect(change.value).to.equal(\"a\")\n      expect(change.position).to.equal(1)\n      expect(change.changedBy).to.equal('0')\n      last_task = \"observer1\"\n    u.observe observer1\n    u.insert 1, \"a\"\n    expect(last_task).to.equal(\"observer1\")\n    u.unobserve observer1\n\n    observer2 = (changes)->\n      expect(changes.length).to.equal(1)\n      change = changes[0]\n      expect(change.type).to.equal(\"insert\")\n      expect(change.object).to.equal(u)\n      expect(change.value).to.equal(\"x\")\n      expect(change.position).to.equal(0)\n      expect(change.changedBy).to.equal('1')\n      last_task = \"observer2\"\n    u.observe observer2\n    v = @yTest.users[1].val(\"TextTest\")\n    v.insert 0, \"x\"\n    @yTest.flushAll()\n    expect(last_task).to.equal(\"observer2\")\n    u.unobserve observer2\n\n  it \"Observers work on shared Text (delete type observers, local and foreign)\", ->\n    u = @yTest.users[0].val(\"TextTest\",new Y.Text(\"my awesome Text\")).val(\"TextTest\")\n    @yTest.flushAll()\n    last_task = null\n    observer1 = (changes)->\n      expect(changes.length).to.equal(1)\n      change = changes[0]\n      expect(change.type).to.equal(\"delete\")\n      expect(change.object).to.equal(u)\n      expect(change.position).to.equal(1)\n      expect(change.length).to.equal(1)\n      expect(change.changedBy).to.equal('0')\n      last_task = \"observer1\"\n    u.observe observer1\n    u.delete 1, 1\n    expect(last_task).to.equal(\"observer1\")\n    u.unobserve observer1\n\n    observer2 = (changes)->\n      expect(changes.length).to.equal(1)\n      change = changes[0]\n      expect(change.type).to.equal(\"delete\")\n      expect(change.object).to.equal(u)\n      expect(change.position).to.equal(0)\n      expect(change.length).to.equal(1)\n      expect(change.changedBy).to.equal('1')\n      last_task = \"observer2\"\n    u.observe observer2\n    v = @yTest.users[1].val(\"TextTest\")\n    v.delete 0, 1\n    @yTest.flushAll()\n    expect(last_task).to.equal(\"observer2\")\n    u.unobserve observer2\n\n  it \"can handle many engines, many operations, concurrently (random)\", ->\n    console.log(\"testiy deleted this TODO:dtrn\")\n    @yTest.run()\n\n  it \"handles double-late-join\", ->\n    test = new TextTest(\"double\")\n    test.run()\n    @yTest.run()\n    u1 = test.users[0]\n    u2 = @yTest.users[1]\n    ops1 = u1._model.HB._encode()\n    ops2 = u2._model.HB._encode()\n    u1._model.engine.applyOp ops2, true\n    u2._model.engine.applyOp ops1, true\n    compare = (o1, o2)->\n      if o1._name? and o1._name isnt o2._name\n        throw new Error \"different types\"\n      else if o1._name is \"Object\"\n        for name, val of o1.val()\n          compare(val, o2.val(name))\n      else if o1._name?\n        compare(o1.val(), o2.val())\n      else if o1 isnt o2\n        throw new Error \"different values\"\n    compare u1, u2\n    expect(test.getContent(0)).to.deep.equal(@yTest.getContent(1))\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"]}
|