diff --git a/README.md b/README.md index cec53b11..b6ba731c 100644 --- a/README.md +++ b/README.md @@ -6,13 +6,14 @@ Yatta! provides similar functionality as [ShareJs](https://github.com/share/Shar but does not require you to understand how the internals work. The predefined data structures provide a simple API to access your shared data structures. Predefined data structures: -* Text -* Json - [example](./examples/IwcJson/) +* Text - [Collaborative Text Editing Example](./examples/TextEditing/) +* Json - [example](./examples/Json/) * XML (coming soon) Unlike other frameworks, Yatta! supports P2P message propagation and is not bound to a specific communication protocol. Currently supported communication protocols: +* [PeerJs](http://peerjs.com/) - WebRTC library * [IWC](http://dbis.rwth-aachen.de/cms/projects/the-xmpp-experience#interwidget-communication) - Inter-widget Communication # Use it! @@ -53,14 +54,15 @@ Yatta! means "I did it!" in Japanese. You scream it when you accomplish somethin There is also this awesome video on the Internet that will change your life [Yatta](https://www.youtube.com/watch?v=kL5DDSglM_s). # Status -Yatta! is still in an early development phase. +Yatta! is still in an early development phase. Don't expect that everything is working fine. +But I would become really motivated if you give me some feedback ([github](https://github.com/DadaMonad/Yatta/issues) or mail). # Support Please report any issues to the [Github issue page](https://github.com/DadaMonad/Yatta/issues)! # License Yatta! is licensed under the [MIT License](./LICENSE.txt). - + diff --git a/build/browser/Engine.js b/build/browser/Engine.js new file mode 100644 index 00000000..b2d6589a --- /dev/null +++ b/build/browser/Engine.js @@ -0,0 +1,110 @@ +(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;oo;o++)e=r[o],t.push(this.parseOperation(e));for(p=0,i=t.length;i>p;p++)e=t[p],this.HB.addOperation(e);for(n=0,u=t.length;u>n;n++)e=t[n],e.execute()||this.unprocessed_ops.push(e);return this.tryUnprocessed()},r.prototype.applyOpsCheckDouble=function(r){var e,t,o,p;for(p=[],t=0,o=r.length;o>t;t++)e=r[t],p.push(null==this.HB.getOperation(e.uid)?this.applyOp(e):void 0);return p},r.prototype.applyOps=function(r){var e,t,o,p;for(p=[],t=0,o=r.length;o>t;t++)e=r[t],p.push(this.applyOp(e));return p},r.prototype.applyOp=function(r){var e;return e=this.parseOperation(r),this.HB.addToCounter(e),e.execute()?this.HB.addOperation(e):this.unprocessed_ops.push(e),this.tryUnprocessed()},r.prototype.tryUnprocessed=function(){var r,e,t,o,p,n,s;for(s=[];;){for(r=this.unprocessed_ops.length,t=[],n=this.unprocessed_ops,o=0,p=n.length;p>o;o++)e=n[o],e.execute()?this.HB.addOperation(e):t.push(e);if(this.unprocessed_ops=t,this.unprocessed_ops.length===r)break;s.push(void 0)}return s},r}(),e.exports=t},{}]},{},[1]); \ No newline at end of file diff --git a/build/browser/HistoryBuffer.js b/build/browser/HistoryBuffer.js new file mode 100644 index 00000000..bc13ee6d --- /dev/null +++ b/build/browser/HistoryBuffer.js @@ -0,0 +1,128 @@ +(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 0) { + return this.engine.applyOp(this.unexecuted[user].shift()); + } + }; + + TestConnector.prototype.flushOneRandom = function() { + return this.flushOne(_.random(0, user_list.length - 1)); + }; + + TestConnector.prototype.flushAll = function() { + var n, ops, _ref; + _ref = this.unexecuted; + for (n in _ref) { + ops = _ref[n]; + this.engine.applyOps(ops); + } + return this.unexecuted = {}; + }; + + return TestConnector; + + })(); +}; + + +},{"underscore":12}],3:[function(require,module,exports){ +var Engine; + +Engine = (function() { + function Engine(HB, parser) { + this.HB = HB; + this.parser = parser; + this.unprocessed_ops = []; + } + + Engine.prototype.parseOperation = function(json) { + var typeParser; + typeParser = this.parser[json.type]; + if (typeParser != null) { + return typeParser(json); + } else { + throw new Error("You forgot to specify a parser for type " + json.type + ". The message is " + (JSON.stringify(json)) + "."); + } + }; + + Engine.prototype.applyOpsBundle = function(ops_json) { + var o, ops, _i, _j, _k, _len, _len1, _len2; + ops = []; + for (_i = 0, _len = ops_json.length; _i < _len; _i++) { + o = ops_json[_i]; + ops.push(this.parseOperation(o)); + } + for (_j = 0, _len1 = ops.length; _j < _len1; _j++) { + o = ops[_j]; + this.HB.addOperation(o); + } + for (_k = 0, _len2 = ops.length; _k < _len2; _k++) { + o = ops[_k]; + if (!o.execute()) { + this.unprocessed_ops.push(o); + } + } + return this.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) { + var o, _i, _len, _results; + _results = []; + for (_i = 0, _len = ops_json.length; _i < _len; _i++) { + o = ops_json[_i]; + _results.push(this.applyOp(o)); + } + return _results; + }; + + Engine.prototype.applyOp = function(op_json) { + var o; + o = this.parseOperation(op_json); + this.HB.addToCounter(o); + if (!o.execute()) { + this.unprocessed_ops.push(o); + } else { + this.HB.addOperation(o); + } + return this.tryUnprocessed(); + }; + + Engine.prototype.tryUnprocessed = function() { + var old_length, op, unprocessed, _i, _len, _ref, _results; + _results = []; + 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 (!op.execute()) { + unprocessed.push(op); + } else { + this.HB.addOperation(op); + } + } + this.unprocessed_ops = unprocessed; + if (this.unprocessed_ops.length === old_length) { + break; + } else { + _results.push(void 0); + } + } + return _results; + }; + + return Engine; + +})(); + +module.exports = Engine; + + +},{}],4:[function(require,module,exports){ +var Engine, HistoryBuffer, JsonYatta, json_types_uninitialized; + +json_types_uninitialized = require("../Types/JsonTypes"); + +HistoryBuffer = require("../HistoryBuffer"); + +Engine = require("../Engine"); + +JsonYatta = (function() { + function JsonYatta(user_id, Connector) { + var first_word, json_types; + this.HB = new HistoryBuffer(user_id); + json_types = json_types_uninitialized(this.HB); + this.engine = new Engine(this.HB, json_types.parser); + this.connector = new Connector(this.engine, this.HB, json_types.execution_listener, this); + first_word = new json_types.types.JsonType(this.HB.getReservedUniqueIdentifier()); + this.HB.addOperation(first_word).execute(); + this.root_element = first_word; + } + + JsonYatta.prototype.getRootElement = function() { + return this.root_element; + }; + + JsonYatta.prototype.getEngine = function() { + return this.engine; + }; + + JsonYatta.prototype.getConnector = function() { + return this.connector; + }; + + JsonYatta.prototype.getHistoryBuffer = function() { + return this.HB; + }; + + JsonYatta.prototype.setMutableDefault = function(mutable) { + return this.root_element.setMutableDefault(mutable); + }; + + JsonYatta.prototype.getUserId = function() { + return this.HB.getUserId(); + }; + + JsonYatta.prototype.val = function(name, content, mutable) { + return this.root_element.val(name, content, mutable); + }; + + Object.defineProperty(JsonYatta.prototype, 'value', { + get: function() { + return this.root_element.value; + }, + set: function(o) { + var o_name, o_obj, _results; + if (o.constructor === {}.constructor) { + _results = []; + for (o_name in o) { + o_obj = o[o_name]; + _results.push(this.val(o_name, o_obj, 'immutable')); + } + return _results; + } else { + throw new Error("You must only set Object values!"); + } + } + }); + + return JsonYatta; + +})(); + +module.exports = JsonYatta; + +if (typeof window !== "undefined" && window !== null) { + if (window.Y == null) { + window.Y = {}; + } + window.Y.JsonYatta = JsonYatta; +} + + +},{"../Engine":3,"../HistoryBuffer":6,"../Types/JsonTypes":8}],5:[function(require,module,exports){ +var Engine, HistoryBuffer, TextYatta, text_types_uninitialized; + +text_types_uninitialized = require("../Types/TextTypes"); + +HistoryBuffer = require("../HistoryBuffer"); + +Engine = require("../Engine"); + +TextYatta = (function() { + function TextYatta(user_id, Connector) { + var beginning, end, first_word, text_types, types; + this.HB = new HistoryBuffer(user_id); + text_types = text_types_uninitialized(this.HB); + types = text_types.types; + this.engine = new Engine(this.HB, text_types.parser); + this.connector = new Connector(this.engine, this.HB, text_types.execution_listener, this); + beginning = this.HB.addOperation(new types.Delimiter({ + creator: '_', + op_number: '_beginning' + }, void 0, void 0)); + end = this.HB.addOperation(new types.Delimiter({ + creator: '_', + op_number: '_end' + }, beginning, void 0)); + beginning.next_cl = end; + beginning.execute(); + end.execute(); + first_word = new text_types.types.Word({ + creator: '_', + op_number: '_' + }, beginning, end); + this.HB.addOperation(first_word).execute(); + this.root_element = first_word; + } + + TextYatta.prototype.getRootElement = function() { + return this.root_element; + }; + + TextYatta.prototype.getEngine = function() { + return this.engine; + }; + + TextYatta.prototype.getConnector = function() { + return this.connector; + }; + + TextYatta.prototype.getHistoryBuffer = function() { + return this.HB; + }; + + TextYatta.prototype.getUserId = function() { + return this.HB.getUserId(); + }; + + TextYatta.prototype.val = function() { + return this.root_element.val(); + }; + + TextYatta.prototype.insertText = function(pos, content) { + return this.root_element.insertText(pos, content); + }; + + TextYatta.prototype.deleteText = function(pos, length) { + return this.root_element.deleteText(pos, length); + }; + + TextYatta.prototype.bind = function(textarea) { + return this.root_element.bind(textarea); + }; + + TextYatta.prototype.replaceText = function(text) { + return this.root_element.replaceText(text); + }; + + return TextYatta; + +})(); + +module.exports = TextYatta; + +if (typeof window !== "undefined" && window !== null) { + if (window.Y == null) { + window.Y = {}; + } + window.Y.TextYatta = TextYatta; +} + + +},{"../Engine":3,"../HistoryBuffer":6,"../Types/TextTypes":10}],6:[function(require,module,exports){ +var HistoryBuffer; + +HistoryBuffer = (function() { + function HistoryBuffer(user_id) { + this.user_id = user_id; + this.operation_counter = {}; + this.buffer = {}; + this.change_listeners = []; + } + + HistoryBuffer.prototype.getUserId = function() { + return this.user_id; + }; + + HistoryBuffer.prototype.getReservedUniqueIdentifier = function() { + return { + creator: '_', + op_number: '_' + }; + }; + + HistoryBuffer.prototype.getOperationCounter = function() { + var ctn, res, user, _ref; + res = {}; + _ref = this.operation_counter; + for (user in _ref) { + ctn = _ref[user]; + res[user] = ctn; + } + return res; + }; + + 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]; + for (o_number in user) { + o = user[o_number]; + if ((!isNaN(parseInt(o_number))) && 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.creator, o_next.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_next.creator, o_next.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 _ref; + if (uid instanceof Object) { + return (_ref = this.buffer[uid.creator]) != null ? _ref[uid.op_number] : void 0; + } else if (uid == null) { + + } else { + throw new Error("This type of uid is not defined!"); + } + }; + + HistoryBuffer.prototype.addOperation = function(o) { + if (this.buffer[o.creator] == null) { + this.buffer[o.creator] = {}; + } + if (this.buffer[o.creator][o.op_number] != null) { + throw new Error("You must not overwrite operations!"); + } + this.buffer[o.creator][o.op_number] = o; + return o; + }; + + HistoryBuffer.prototype.addToCounter = function(o) { + if (this.operation_counter[o.creator] == null) { + this.operation_counter[o.creator] = 0; + } + if (typeof o.op_number === 'number' && o.creator !== this.getUserId()) { + return this.operation_counter[o.creator]++; + } + }; + + return HistoryBuffer; + +})(); + +module.exports = HistoryBuffer; + + +},{}],7:[function(require,module,exports){ +var __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(HB) { + var Delete, Delimiter, ImmutableObject, Insert, Operation, execution_listener, parser; + parser = {}; + execution_listener = []; + Operation = (function() { + function Operation(uid) { + if (uid == null) { + uid = HB.getNextOperationIdentifier(); + } + this.creator = uid['creator'], this.op_number = uid['op_number']; + } + + Operation.prototype.on = function(event, f) { + var _base; + if (this.event_listeners == null) { + this.event_listeners = {}; + } + if ((_base = this.event_listeners)[event] == null) { + _base[event] = []; + } + return this.event_listeners[event].push(f); + }; + + Operation.prototype.callEvent = function(event, args) { + var f, _i, _len, _ref, _ref1, _results; + if (((_ref = this.event_listeners) != null ? _ref[event] : void 0) != null) { + _ref1 = this.event_listeners[event]; + _results = []; + for (_i = 0, _len = _ref1.length; _i < _len; _i++) { + f = _ref1[_i]; + _results.push(f.call(this, event, args)); + } + return _results; + } + }; + + Operation.prototype.setParent = function(o) { + return this.parent = o; + }; + + Operation.prototype.getParent = function() { + return this.parent; + }; + + Operation.prototype.getUid = function() { + return { + 'creator': this.creator, + 'op_number': this.op_number + }; + }; + + Operation.prototype.execute = function() { + var l, _i, _len; + this.is_executed = true; + for (_i = 0, _len = execution_listener.length; _i < _len; _i++) { + l = execution_listener[_i]; + l(this._encode()); + } + return this; + }; + + Operation.prototype.saveOperation = function(name, op) { + if ((op != null ? op.execute : void 0) != null) { + return this[name] = op; + } else if (op != null) { + 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 = 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; + }; + + return Operation; + + })(); + Delete = (function(_super) { + __extends(Delete, _super); + + function Delete(uid, deletes) { + this.saveOperation('deletes', deletes); + Delete.__super__.constructor.call(this, uid); + } + + Delete.prototype._encode = function() { + return { + 'type': "Delete", + 'uid': this.getUid(), + 'deletes': this.deletes.getUid() + }; + }; + + Delete.prototype.execute = function() { + if (this.validateSavedOperations()) { + this.deletes.applyDelete(this); + return Delete.__super__.execute.apply(this, arguments); + } else { + return false; + } + }; + + return Delete; + + })(Operation); + parser['Delete'] = function(o) { + var deletes_uid, uid; + uid = o['uid'], deletes_uid = o['deletes']; + return new Delete(uid, deletes_uid); + }; + Insert = (function(_super) { + __extends(Insert, _super); + + function Insert(uid, prev_cl, next_cl, origin) { + 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, uid); + } + + Insert.prototype.applyDelete = function(o) { + if (this.deleted_by == null) { + this.deleted_by = []; + } + this.deleted_by.push(o); + if ((this.parent != null) && this.deleted_by.length === 1) { + return this.parent.callEvent("delete", this); + } + }; + + Insert.prototype.isDeleted = function() { + var _ref; + return ((_ref = this.deleted_by) != null ? _ref.length : void 0) > 0; + }; + + Insert.prototype.getDistanceToOrigin = function() { + var d, o; + d = 0; + o = this.prev_cl; + while (true) { + if (this.origin === o) { + break; + } + d++; + if (this === this.prev_cl) { + throw new Error("this should not happen ;) "); + } + o = o.prev_cl; + } + return d; + }; + + Insert.prototype.update_sl = function() { + var o; + o = this.prev_cl; + ({ + update: function(dest_cl, dest_sl) { + var _results; + _results = []; + while (true) { + if (o.isDeleted()) { + _results.push(o = o[dest_cl]); + } else { + this[dest_sl] = o; + break; + } + } + return _results; + } + }); + update("prev_cl", "prev_sl"); + return update("next_cl", "prev_sl"); + }; + + Insert.prototype.execute = function() { + var distance_to_origin, i, o, parent, _ref, _ref1, _ref2; + if (this.is_executed != null) { + return this; + } + if (!this.validateSavedOperations()) { + return false; + } else { + if (((_ref = this.prev_cl) != null ? _ref.validateSavedOperations() : void 0) && ((_ref1 = this.next_cl) != null ? _ref1.validateSavedOperations() : void 0) && this.prev_cl.next_cl !== this) { + distance_to_origin = 0; + o = this.prev_cl.next_cl; + i = 0; + while (true) { + if (o == null) { + console.log(JSON.stringify(this.prev_cl.getUid())); + console.log(JSON.stringify(this.next_cl.getUid())); + } + if (o !== this.next_cl) { + if (o.getDistanceToOrigin() === i) { + if (o.creator < this.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; + } + parent = (_ref2 = this.prev_cl) != null ? _ref2.getParent() : void 0; + if (parent != null) { + this.setParent(parent); + this.parent.callEvent("insert", this); + } + return Insert.__super__.execute.apply(this, arguments); + } + }; + + Insert.prototype.getPosition = function() { + var position, prev; + position = 0; + prev = this.prev_cl; + while (true) { + if (prev instanceof Delimiter) { + break; + } + if ((prev.isDeleted != null) && !prev.isDeleted()) { + position++; + } + prev = prev.prev_cl; + } + return position; + }; + + return Insert; + + })(Operation); + ImmutableObject = (function(_super) { + __extends(ImmutableObject, _super); + + function ImmutableObject(uid, content, prev, next, origin) { + this.content = content; + ImmutableObject.__super__.constructor.call(this, uid, prev, next, origin); + } + + ImmutableObject.prototype.val = function() { + return this.content; + }; + + ImmutableObject.prototype._encode = function() { + var json; + json = { + 'type': "ImmutableObject", + 'uid': this.getUid(), + 'content': this.content + }; + if (this.prev_cl != null) { + json['prev'] = this.prev_cl.getUid(); + } + if (this.next_cl != null) { + json['next'] = this.next_cl.getUid(); + } + if ((this.origin != null) && this.origin !== this.prev_cl) { + json["origin"] = this.origin.getUid(); + } + return json; + }; + + return ImmutableObject; + + })(Insert); + parser['ImmutableObject'] = function(json) { + var content, next, origin, prev, uid; + uid = json['uid'], content = json['content'], prev = json['prev'], next = json['next'], origin = json['origin']; + return new ImmutableObject(uid, content, prev, next, origin); + }; + Delimiter = (function(_super) { + __extends(Delimiter, _super); + + function Delimiter(uid, 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, uid); + } + + Delimiter.prototype.isDeleted = function() { + return false; + }; + + 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; + delete this.prev_cl.unchecked.next_cl; + 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; + return this.prev_cl.next_cl = this; + } else if ((this.prev_cl != null) || (this.next_cl != null)) { + return Delimiter.__super__.execute.apply(this, arguments); + } else { + throw new Error("Delimiter is unsufficient defined!"); + } + }; + + Delimiter.prototype._encode = function() { + var _ref, _ref1; + return { + 'type': "Delimiter", + '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; + + })(Operation); + parser['Delimiter'] = function(json) { + var next, prev, uid; + uid = json['uid'], prev = json['prev'], next = json['next']; + return new Delimiter(uid, prev, next); + }; + return { + 'types': { + 'Delete': Delete, + 'Insert': Insert, + 'Delimiter': Delimiter, + 'Operation': Operation, + 'ImmutableObject': ImmutableObject + }, + 'parser': parser, + 'execution_listener': execution_listener + }; +}; + + +},{}],8:[function(require,module,exports){ +var text_types_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; }; + +text_types_uninitialized = require("./TextTypes"); + +module.exports = function(HB) { + var JsonType, createJsonWrapper, parser, text_types, types; + text_types = text_types_uninitialized(HB); + types = text_types.types; + parser = text_types.parser; + createJsonWrapper = function(_jsonType) { + var JsonWrapper; + JsonWrapper = (function() { + function JsonWrapper(jsonType) { + var name, obj, _fn, _ref; + _ref = jsonType.map; + _fn = function(name, obj) { + return Object.defineProperty(JsonWrapper.prototype, name, { + get: function() { + var x; + x = obj.val(); + if (x instanceof JsonType) { + return createJsonWrapper(x); + } else if (x instanceof types.ImmutableObject) { + return x.val(); + } else { + return x; + } + }, + set: function(o) { + var o_name, o_obj, overwrite, _results; + if (o.constructor === {}.constructor) { + overwrite = jsonType.val(name); + _results = []; + for (o_name in o) { + o_obj = o[o_name]; + _results.push(overwrite.val(o_name, o_obj, 'immutable')); + } + return _results; + } else { + return jsonType.val(name, o, 'immutable'); + } + }, + enumerable: true, + configurable: false + }); + }; + for (name in _ref) { + obj = _ref[name]; + _fn(name, obj); + } + } + + return JsonWrapper; + + })(); + return new JsonWrapper(_jsonType); + }; + JsonType = (function(_super) { + __extends(JsonType, _super); + + function JsonType(uid, initial_value, mutable) { + var name, o; + JsonType.__super__.constructor.call(this, uid); + if (initial_value != null) { + if (typeof initial_value !== "object") { + throw new Error("The initial value of JsonTypes must be of type Object! (current type: " + (typeof initial_value) + ")"); + } + for (name in initial_value) { + o = initial_value[name]; + this.val(name, o, mutable); + } + } + } + + JsonType.prototype.mutable_default = true; + + JsonType.prototype.setMutableDefault = function(mutable) { + if (mutable === true || mutable === 'mutable') { + JsonType.prototype.mutable_default = true; + } else if (mutable === false || mutable === 'immutable') { + JsonType.prototype.mutable_default = false; + } else { + throw new Error('Set mutable either "mutable" or "immutable"!'); + } + return 'OK'; + }; + + JsonType.prototype.val = function(name, content, mutable) { + var json, o, o_name, obj, word; + if (typeof name === 'object') { + for (o_name in name) { + o = name[o_name]; + this.val(o_name, o, content); + } + return this; + } else if ((name != null) && (content != null)) { + if (mutable != null) { + if (mutable === true || mutable === 'mutable') { + mutable = true; + } else { + mutable = false; + } + } else { + mutable = this.mutable_default; + } + if (typeof content === 'function') { + return this; + } else if (((!mutable) || typeof content === 'number') && content.constructor !== Object) { + obj = HB.addOperation(new types.ImmutableObject(void 0, content)).execute(); + return JsonType.__super__.val.call(this, name, obj); + } else { + if (typeof content === 'string') { + word = HB.addOperation(new types.Word(void 0)).execute(); + word.insertText(0, content); + return JsonType.__super__.val.call(this, name, word); + } else if (content.constructor === Object) { + json = HB.addOperation(new JsonType(void 0, content, mutable)).execute(); + return JsonType.__super__.val.call(this, name, json); + } else { + throw new Error("You must not set " + (typeof content) + "-types in collaborative Json-objects!"); + } + } + } else { + return JsonType.__super__.val.call(this, name, content); + } + }; + + Object.defineProperty(JsonType.prototype, 'value', { + get: function() { + return createJsonWrapper(this); + }, + set: function(o) { + var o_name, o_obj, _results; + if (o.constructor === {}.constructor) { + _results = []; + for (o_name in o) { + o_obj = o[o_name]; + _results.push(this.val(o_name, o_obj, 'immutable')); + } + return _results; + } else { + throw new Error("You must only set Object values!"); + } + } + }); + + JsonType.prototype._encode = function() { + return { + 'type': "JsonType", + 'uid': this.getUid() + }; + }; + + return JsonType; + + })(types.MapManager); + parser['JsonType'] = function(json) { + var uid; + uid = json['uid']; + return new JsonType(uid); + }; + types['JsonType'] = JsonType; + return text_types; +}; + + +},{"./TextTypes":10}],9:[function(require,module,exports){ +var basic_types_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_types_uninitialized = require("./BasicTypes"); + +module.exports = function(HB) { + var AddName, ListManager, MapManager, ReplaceManager, Replaceable, basic_types, parser, types; + basic_types = basic_types_uninitialized(HB); + types = basic_types.types; + parser = basic_types.parser; + MapManager = (function(_super) { + __extends(MapManager, _super); + + function MapManager(uid) { + this.map = {}; + MapManager.__super__.constructor.call(this, uid); + } + + MapManager.prototype.val = function(name, content) { + var o, obj, result, _ref, _ref1; + if (content != null) { + if (this.map[name] == null) { + HB.addOperation(new AddName(void 0, this, name)).execute(); + } + this.map[name].replace(content); + return this; + } else if (name != null) { + obj = (_ref = this.map[name]) != null ? _ref.val() : void 0; + if (obj instanceof types.ImmutableObject) { + return obj.val(); + } else { + return obj; + } + } else { + result = {}; + _ref1 = this.map; + for (name in _ref1) { + o = _ref1[name]; + obj = o.val(); + if (obj instanceof types.ImmutableObject || obj instanceof MapManager) { + obj = obj.val(); + } + result[name] = obj; + } + return result; + } + }; + + return MapManager; + + })(types.Operation); + AddName = (function(_super) { + __extends(AddName, _super); + + function AddName(uid, map_manager, name) { + this.name = name; + this.saveOperation('map_manager', map_manager); + AddName.__super__.constructor.call(this, uid); + } + + AddName.prototype.execute = function() { + var beg, end, uid_beg, uid_end, uid_r; + if (!this.validateSavedOperations()) { + return false; + } else { + uid_r = this.map_manager.getUid(); + uid_r.op_number = "_" + uid_r.op_number + "_RM_" + this.name; + if (HB.getOperation(uid_r) == null) { + uid_beg = this.map_manager.getUid(); + uid_beg.op_number = "_" + uid_beg.op_number + "_RM_" + this.name + "_beginning"; + uid_end = this.map_manager.getUid(); + uid_end.op_number = "_" + uid_end.op_number + "_RM_" + this.name + "_end"; + beg = HB.addOperation(new types.Delimiter(uid_beg, void 0, uid_end)).execute(); + end = HB.addOperation(new types.Delimiter(uid_end, beg, void 0)).execute(); + this.map_manager.map[this.name] = HB.addOperation(new ReplaceManager(void 0, uid_r, beg, end)).execute(); + } + return AddName.__super__.execute.apply(this, arguments); + } + }; + + AddName.prototype._encode = function() { + return { + 'type': "AddName", + 'uid': this.getUid(), + 'map_manager': this.map_manager.getUid(), + 'name': this.name + }; + }; + + return AddName; + + })(types.Operation); + parser['AddName'] = function(json) { + var map_manager, name, uid; + map_manager = json['map_manager'], uid = json['uid'], name = json['name']; + return new AddName(uid, map_manager, name); + }; + ListManager = (function(_super) { + __extends(ListManager, _super); + + function ListManager(uid, beginning, end, prev, next, origin) { + if ((beginning != null) && (end != null)) { + this.saveOperation('beginning', beginning); + this.saveOperation('end', end); + } else { + this.beginning = HB.addOperation(new types.Delimiter(void 0, void 0, void 0)); + this.end = HB.addOperation(new types.Delimiter(void 0, this.beginning, void 0)); + this.beginning.next_cl = this.end; + this.beginning.execute(); + this.end.execute(); + } + ListManager.__super__.constructor.call(this, uid, prev, next, origin); + } + + 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) { + result.push(o); + o = o.next_cl; + } + return result; + }; + + ListManager.prototype.getOperationByPosition = function(position) { + var o; + o = this.beginning.next_cl; + if (position > 0) { + while (true) { + o = o.next_cl; + if (!o.isDeleted()) { + position -= 1; + } + if (position === 0) { + break; + } + if (o instanceof types.Delimiter) { + console.log("position parameter exceeded the length of the document!"); + o = null; + break; + } + } + } + return o; + }; + + return ListManager; + + })(types.Insert); + ReplaceManager = (function(_super) { + __extends(ReplaceManager, _super); + + function ReplaceManager(initial_content, uid, beginning, end, prev, next, origin) { + ReplaceManager.__super__.constructor.call(this, uid, beginning, end, prev, next, origin); + if (initial_content != null) { + this.replace(initial_content); + } + } + + ReplaceManager.prototype.replace = function(content) { + var o, op; + o = this.getLastOperation(); + op = new Replaceable(content, this, void 0, o, o.next_cl); + return HB.addOperation(op).execute(); + }; + + ReplaceManager.prototype.val = function() { + var o; + o = this.getLastOperation(); + if (o instanceof types.Delimiter) { + throw new Error("dtrn"); + } + return o.val(); + }; + + ReplaceManager.prototype._encode = function() { + var json; + json = { + 'type': "ReplaceManager", + 'uid': this.getUid(), + 'beginning': this.beginning.getUid(), + 'end': this.end.getUid() + }; + if ((this.prev_cl != null) && (this.next_cl != null)) { + json['prev'] = this.prev_cl.getUid(); + json['next'] = this.next_cl.getUid(); + } + if ((this.origin != null) && this.origin !== this.prev_cl) { + json["origin"] = this.origin.getUid(); + } + return json; + }; + + return ReplaceManager; + + })(ListManager); + parser["ReplaceManager"] = function(json) { + var beginning, content, end, next, origin, prev, uid; + content = json['content'], uid = json['uid'], prev = json['prev'], next = json['next'], origin = json['origin'], beginning = json['beginning'], end = json['end']; + return new ReplaceManager(content, uid, beginning, end, prev, next, origin); + }; + Replaceable = (function(_super) { + __extends(Replaceable, _super); + + function Replaceable(content, parent, uid, prev, next, origin) { + this.saveOperation('content', content); + this.saveOperation('parent', parent); + if (!((prev != null) && (next != null) && (content != null))) { + throw new Error("You must define content, prev, and next for Replaceable-types!"); + } + Replaceable.__super__.constructor.call(this, uid, prev, next, origin); + } + + Replaceable.prototype.val = function() { + return this.content; + }; + + Replaceable.prototype.replace = function(content) { + return this.parent.replace(content); + }; + + Replaceable.prototype.execute = function() { + var _base; + if (!this.validateSavedOperations()) { + return false; + } else { + if (typeof (_base = this.content).setReplaceManager === "function") { + _base.setReplaceManager(this.parent); + } + return Replaceable.__super__.execute.apply(this, arguments); + } + }; + + Replaceable.prototype._encode = function() { + var json; + json = { + 'type': "Replaceable", + 'content': this.content.getUid(), + 'ReplaceManager': this.parent.getUid(), + 'prev': this.prev_cl.getUid(), + 'next': this.next_cl.getUid(), + 'uid': this.getUid() + }; + if ((this.origin != null) && this.origin !== this.prev_cl) { + json["origin"] = this.origin.getUid(); + } + return json; + }; + + return Replaceable; + + })(types.Insert); + parser["Replaceable"] = function(json) { + var content, next, origin, parent, prev, uid; + content = json['content'], parent = json['ReplaceManager'], uid = json['uid'], prev = json['prev'], next = json['next'], origin = json['origin']; + return new Replaceable(content, parent, uid, prev, next, origin); + }; + types['ListManager'] = ListManager; + types['MapManager'] = MapManager; + types['ReplaceManager'] = ReplaceManager; + types['Replaceable'] = Replaceable; + return basic_types; +}; + + +},{"./BasicTypes":7}],10:[function(require,module,exports){ +var structured_types_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; }; + +structured_types_uninitialized = require("./StructuredTypes"); + +module.exports = function(HB) { + var TextDelete, TextInsert, Word, parser, structured_types, types; + structured_types = structured_types_uninitialized(HB); + types = structured_types.types; + parser = structured_types.parser; + TextDelete = (function(_super) { + __extends(TextDelete, _super); + + function TextDelete() { + return TextDelete.__super__.constructor.apply(this, arguments); + } + + return TextDelete; + + })(types.Delete); + parser["TextDelete"] = parser["Delete"]; + TextInsert = (function(_super) { + __extends(TextInsert, _super); + + function TextInsert(content, uid, prev, next, origin) { + this.content = content; + if (!((prev != null) && (next != null))) { + throw new Error("You must define prev, and next for TextInsert-types!"); + } + TextInsert.__super__.constructor.call(this, uid, prev, next, origin); + } + + TextInsert.prototype.getLength = function() { + if (this.isDeleted()) { + return 0; + } else { + return this.content.length; + } + }; + + TextInsert.prototype.val = function(current_position) { + if (this.isDeleted()) { + return ""; + } else { + return this.content; + } + }; + + TextInsert.prototype._encode = function() { + var json; + json = { + 'type': "TextInsert", + 'content': this.content, + 'uid': this.getUid(), + 'prev': this.prev_cl.getUid(), + 'next': this.next_cl.getUid() + }; + if ((this.origin != null) && this.origin !== this.prev_cl) { + json["origin"] = this.origin.getUid(); + } + return json; + }; + + return TextInsert; + + })(types.Insert); + parser["TextInsert"] = function(json) { + var content, next, origin, prev, uid; + content = json['content'], uid = json['uid'], prev = json['prev'], next = json['next'], origin = json['origin']; + return new TextInsert(content, uid, prev, next, origin); + }; + Word = (function(_super) { + __extends(Word, _super); + + function Word(uid, beginning, end, prev, next, origin) { + Word.__super__.constructor.call(this, uid, beginning, end, prev, next, origin); + } + + Word.prototype.insertText = function(position, content) { + var c, o, op, _i, _len, _results; + o = this.getOperationByPosition(position); + _results = []; + for (_i = 0, _len = content.length; _i < _len; _i++) { + c = content[_i]; + op = new TextInsert(c, void 0, o.prev_cl, o); + _results.push(HB.addOperation(op).execute()); + } + return _results; + }; + + Word.prototype.deleteText = function(position, length) { + var d, delete_ops, i, o, _i, _results; + o = this.getOperationByPosition(position); + delete_ops = []; + _results = []; + for (i = _i = 0; 0 <= length ? _i < length : _i > length; i = 0 <= length ? ++_i : --_i) { + d = HB.addOperation(new TextDelete(void 0, o)).execute(); + o = o.next_cl; + while (o.isDeleted() && !(o instanceof types.Delimiter)) { + if (o instanceof types.Delimiter) { + throw new Error("You can't delete more than there is.."); + } + o = o.next_cl; + } + delete_ops.push(d._encode()); + if (o instanceof types.Delimiter) { + break; + } else { + _results.push(void 0); + } + } + return _results; + }; + + Word.prototype.replaceText = function(text) { + var word; + if (this.replace_manager != null) { + word = HB.addOperation(new Word(void 0)).execute(); + word.insertText(0, text); + return this.replace_manager.replace(word); + } else { + throw new Error("This type is currently not maintained by a ReplaceManager!"); + } + }; + + Word.prototype.val = function() { + var c, o; + c = (function() { + var _i, _len, _ref, _results; + _ref = this.toArray(); + _results = []; + for (_i = 0, _len = _ref.length; _i < _len; _i++) { + o = _ref[_i]; + if (o.val != null) { + _results.push(o.val()); + } else { + _results.push(""); + } + } + return _results; + }).call(this); + return c.join(''); + }; + + Word.prototype.setReplaceManager = function(op) { + this.saveOperation('replace_manager', op); + return this.validateSavedOperations; + }; + + Word.prototype.bind = function(textfield) { + var word; + word = this; + textfield.value = this.val(); + this.on("insert", function(event, op) { + var fix, left, o_pos, right; + if (op.creator !== HB.getUserId()) { + o_pos = op.getPosition(); + fix = function(cursor) { + if (cursor <= o_pos) { + return cursor; + } else { + cursor += 1; + return cursor; + } + }; + left = fix(textfield.selectionStart); + right = fix(textfield.selectionEnd); + textfield.value = word.val(); + return textfield.setSelectionRange(left, right); + } + }); + this.on("delete", function(event, op) { + var fix, left, o_pos, right; + o_pos = op.getPosition(); + fix = function(cursor) { + if (cursor < o_pos) { + return cursor; + } else { + cursor -= 1; + return cursor; + } + }; + left = fix(textfield.selectionStart); + right = fix(textfield.selectionEnd); + textfield.value = word.val(); + return textfield.setSelectionRange(left, right); + }); + textfield.onkeypress = function(event) { + var char, diff, pos; + char = String.fromCharCode(event.keyCode); + if (char.length > 0) { + pos = Math.min(textfield.selectionStart, textfield.selectionEnd); + diff = Math.abs(textfield.selectionEnd - textfield.selectionStart); + word.deleteText(pos, diff); + return word.insertText(pos, char); + } else { + return event.preventDefault(); + } + }; + return textfield.onkeydown = function(event) { + var del_length, diff, new_pos, pos, val; + pos = Math.min(textfield.selectionStart, textfield.selectionEnd); + diff = Math.abs(textfield.selectionEnd - textfield.selectionStart); + if ((event.keyCode != null) && event.keyCode === 8) { + if (diff > 0) { + word.deleteText(pos, diff); + } else { + if ((event.ctrlKey != null) && event.ctrlKey) { + val = textfield.value; + 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.deleteText(new_pos, pos - new_pos); + textfield.setSelectionRange(new_pos, new_pos); + } else { + word.deleteText(pos - 1, 1); + } + } + return event.preventDefault(); + } else if ((event.keyCode != null) && event.keyCode === 46) { + if (diff > 0) { + word.deleteText(pos, diff); + } else { + word.deleteText(pos, 1); + } + return event.preventDefault(); + } + }; + }; + + Word.prototype._encode = function() { + var json; + json = { + 'type': "Word", + 'uid': this.getUid(), + 'beginning': this.beginning.getUid(), + 'end': this.end.getUid() + }; + if (this.prev_cl != null) { + json['prev'] = this.prev_cl.getUid(); + } + if (this.next_cl != null) { + json['next'] = this.next_cl.getUid(); + } + if ((this.origin != null) && this.origin !== this.prev_cl) { + json["origin"] = this.origin.getUid(); + } + return json; + }; + + return Word; + + })(types.ListManager); + parser['Word'] = function(json) { + var beginning, end, next, origin, prev, uid; + uid = json['uid'], beginning = json['beginning'], end = json['end'], prev = json['prev'], next = json['next'], origin = json['origin']; + return new Word(uid, beginning, end, prev, next, origin); + }; + types['TextInsert'] = TextInsert; + types['TextDelete'] = TextDelete; + types['Word'] = Word; + return structured_types; +}; + + +},{"./StructuredTypes":9}],11:[function(require,module,exports){ +exports['IwcConnector'] = require('./Connectors/IwcConnector'); + +exports['TestConnector'] = require('./Connectors/TestConnector'); + +exports['JsonYatta'] = require('./Frameworks/JsonYatta'); + +exports['TextYatta'] = require('./Frameworks/TextYatta'); + + +},{"./Connectors/IwcConnector":1,"./Connectors/TestConnector":2,"./Frameworks/JsonYatta":4,"./Frameworks/TextYatta":5}],12:[function(require,module,exports){ +// Underscore.js 1.6.0 +// http://underscorejs.org +// (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors +// Underscore may be freely distributed under the MIT license. + +(function() { + + // Baseline setup + // -------------- + + // Establish the root object, `window` in the browser, or `exports` on the server. + var root = this; + + // Save the previous value of the `_` variable. + var previousUnderscore = root._; + + // Establish the object that gets returned to break out of a loop iteration. + var breaker = {}; + + // Save bytes in the minified (but not gzipped) version: + var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype; + + // Create quick reference variables for speed access to core prototypes. + var + push = ArrayProto.push, + slice = ArrayProto.slice, + concat = ArrayProto.concat, + toString = ObjProto.toString, + hasOwnProperty = ObjProto.hasOwnProperty; + + // All **ECMAScript 5** native function implementations that we hope to use + // are declared here. + var + nativeForEach = ArrayProto.forEach, + nativeMap = ArrayProto.map, + nativeReduce = ArrayProto.reduce, + nativeReduceRight = ArrayProto.reduceRight, + nativeFilter = ArrayProto.filter, + nativeEvery = ArrayProto.every, + nativeSome = ArrayProto.some, + nativeIndexOf = ArrayProto.indexOf, + nativeLastIndexOf = ArrayProto.lastIndexOf, + nativeIsArray = Array.isArray, + nativeKeys = Object.keys, + nativeBind = FuncProto.bind; + + // Create a safe reference to the Underscore object for use below. + var _ = function(obj) { + if (obj instanceof _) return obj; + if (!(this instanceof _)) return new _(obj); + this._wrapped = obj; + }; + + // Export the Underscore object for **Node.js**, with + // backwards-compatibility for the old `require()` API. If we're in + // the browser, add `_` as a global object via a string identifier, + // for Closure Compiler "advanced" mode. + if (typeof exports !== 'undefined') { + if (typeof module !== 'undefined' && module.exports) { + exports = module.exports = _; + } + exports._ = _; + } else { + root._ = _; + } + + // Current version. + _.VERSION = '1.6.0'; + + // Collection Functions + // -------------------- + + // The cornerstone, an `each` implementation, aka `forEach`. + // Handles objects with the built-in `forEach`, arrays, and raw objects. + // Delegates to **ECMAScript 5**'s native `forEach` if available. + var each = _.each = _.forEach = function(obj, iterator, context) { + if (obj == null) return obj; + if (nativeForEach && obj.forEach === nativeForEach) { + obj.forEach(iterator, context); + } else if (obj.length === +obj.length) { + for (var i = 0, length = obj.length; i < length; i++) { + if (iterator.call(context, obj[i], i, obj) === breaker) return; + } + } else { + var keys = _.keys(obj); + for (var i = 0, length = keys.length; i < length; i++) { + if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) return; + } + } + return obj; + }; + + // Return the results of applying the iterator to each element. + // Delegates to **ECMAScript 5**'s native `map` if available. + _.map = _.collect = function(obj, iterator, context) { + var results = []; + if (obj == null) return results; + if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context); + each(obj, function(value, index, list) { + results.push(iterator.call(context, value, index, list)); + }); + return results; + }; + + var reduceError = 'Reduce of empty array with no initial value'; + + // **Reduce** builds up a single result from a list of values, aka `inject`, + // or `foldl`. Delegates to **ECMAScript 5**'s native `reduce` if available. + _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) { + var initial = arguments.length > 2; + if (obj == null) obj = []; + if (nativeReduce && obj.reduce === nativeReduce) { + if (context) iterator = _.bind(iterator, context); + return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator); + } + each(obj, function(value, index, list) { + if (!initial) { + memo = value; + initial = true; + } else { + memo = iterator.call(context, memo, value, index, list); + } + }); + if (!initial) throw new TypeError(reduceError); + return memo; + }; + + // The right-associative version of reduce, also known as `foldr`. + // Delegates to **ECMAScript 5**'s native `reduceRight` if available. + _.reduceRight = _.foldr = function(obj, iterator, memo, context) { + var initial = arguments.length > 2; + if (obj == null) obj = []; + if (nativeReduceRight && obj.reduceRight === nativeReduceRight) { + if (context) iterator = _.bind(iterator, context); + return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator); + } + var length = obj.length; + if (length !== +length) { + var keys = _.keys(obj); + length = keys.length; + } + each(obj, function(value, index, list) { + index = keys ? keys[--length] : --length; + if (!initial) { + memo = obj[index]; + initial = true; + } else { + memo = iterator.call(context, memo, obj[index], index, list); + } + }); + if (!initial) throw new TypeError(reduceError); + return memo; + }; + + // Return the first value which passes a truth test. Aliased as `detect`. + _.find = _.detect = function(obj, predicate, context) { + var result; + any(obj, function(value, index, list) { + if (predicate.call(context, value, index, list)) { + result = value; + return true; + } + }); + return result; + }; + + // Return all the elements that pass a truth test. + // Delegates to **ECMAScript 5**'s native `filter` if available. + // Aliased as `select`. + _.filter = _.select = function(obj, predicate, context) { + var results = []; + if (obj == null) return results; + if (nativeFilter && obj.filter === nativeFilter) return obj.filter(predicate, context); + each(obj, function(value, index, list) { + if (predicate.call(context, value, index, list)) results.push(value); + }); + return results; + }; + + // Return all the elements for which a truth test fails. + _.reject = function(obj, predicate, context) { + return _.filter(obj, function(value, index, list) { + return !predicate.call(context, value, index, list); + }, context); + }; + + // Determine whether all of the elements match a truth test. + // Delegates to **ECMAScript 5**'s native `every` if available. + // Aliased as `all`. + _.every = _.all = function(obj, predicate, context) { + predicate || (predicate = _.identity); + var result = true; + if (obj == null) return result; + if (nativeEvery && obj.every === nativeEvery) return obj.every(predicate, context); + each(obj, function(value, index, list) { + if (!(result = result && predicate.call(context, value, index, list))) return breaker; + }); + return !!result; + }; + + // Determine if at least one element in the object matches a truth test. + // Delegates to **ECMAScript 5**'s native `some` if available. + // Aliased as `any`. + var any = _.some = _.any = function(obj, predicate, context) { + predicate || (predicate = _.identity); + var result = false; + if (obj == null) return result; + if (nativeSome && obj.some === nativeSome) return obj.some(predicate, context); + each(obj, function(value, index, list) { + if (result || (result = predicate.call(context, value, index, list))) return breaker; + }); + return !!result; + }; + + // Determine if the array or object contains a given value (using `===`). + // Aliased as `include`. + _.contains = _.include = function(obj, target) { + if (obj == null) return false; + if (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1; + return any(obj, function(value) { + return value === target; + }); + }; + + // Invoke a method (with arguments) on every item in a collection. + _.invoke = function(obj, method) { + var args = slice.call(arguments, 2); + var isFunc = _.isFunction(method); + return _.map(obj, function(value) { + return (isFunc ? method : value[method]).apply(value, args); + }); + }; + + // Convenience version of a common use case of `map`: fetching a property. + _.pluck = function(obj, key) { + return _.map(obj, _.property(key)); + }; + + // Convenience version of a common use case of `filter`: selecting only objects + // containing specific `key:value` pairs. + _.where = function(obj, attrs) { + return _.filter(obj, _.matches(attrs)); + }; + + // Convenience version of a common use case of `find`: getting the first object + // containing specific `key:value` pairs. + _.findWhere = function(obj, attrs) { + return _.find(obj, _.matches(attrs)); + }; + + // Return the maximum element or (element-based computation). + // Can't optimize arrays of integers longer than 65,535 elements. + // See [WebKit Bug 80797](https://bugs.webkit.org/show_bug.cgi?id=80797) + _.max = function(obj, iterator, context) { + if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) { + return Math.max.apply(Math, obj); + } + var result = -Infinity, lastComputed = -Infinity; + each(obj, function(value, index, list) { + var computed = iterator ? iterator.call(context, value, index, list) : value; + if (computed > lastComputed) { + result = value; + lastComputed = computed; + } + }); + return result; + }; + + // Return the minimum element (or element-based computation). + _.min = function(obj, iterator, context) { + if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) { + return Math.min.apply(Math, obj); + } + var result = Infinity, lastComputed = Infinity; + each(obj, function(value, index, list) { + var computed = iterator ? iterator.call(context, value, index, list) : value; + if (computed < lastComputed) { + result = value; + lastComputed = computed; + } + }); + return result; + }; + + // Shuffle an array, using the modern version of the + // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle). + _.shuffle = function(obj) { + var rand; + var index = 0; + var shuffled = []; + each(obj, function(value) { + rand = _.random(index++); + shuffled[index - 1] = shuffled[rand]; + shuffled[rand] = value; + }); + return shuffled; + }; + + // Sample **n** random values from a collection. + // If **n** is not specified, returns a single random element. + // The internal `guard` argument allows it to work with `map`. + _.sample = function(obj, n, guard) { + if (n == null || guard) { + if (obj.length !== +obj.length) obj = _.values(obj); + return obj[_.random(obj.length - 1)]; + } + return _.shuffle(obj).slice(0, Math.max(0, n)); + }; + + // An internal function to generate lookup iterators. + var lookupIterator = function(value) { + if (value == null) return _.identity; + if (_.isFunction(value)) return value; + return _.property(value); + }; + + // Sort the object's values by a criterion produced by an iterator. + _.sortBy = function(obj, iterator, context) { + iterator = lookupIterator(iterator); + return _.pluck(_.map(obj, function(value, index, list) { + return { + value: value, + index: index, + criteria: iterator.call(context, value, index, list) + }; + }).sort(function(left, right) { + var a = left.criteria; + var b = right.criteria; + if (a !== b) { + if (a > b || a === void 0) return 1; + if (a < b || b === void 0) return -1; + } + return left.index - right.index; + }), 'value'); + }; + + // An internal function used for aggregate "group by" operations. + var group = function(behavior) { + return function(obj, iterator, context) { + var result = {}; + iterator = lookupIterator(iterator); + each(obj, function(value, index) { + var key = iterator.call(context, value, index, obj); + behavior(result, key, value); + }); + return result; + }; + }; + + // Groups the object's values by a criterion. Pass either a string attribute + // to group by, or a function that returns the criterion. + _.groupBy = group(function(result, key, value) { + _.has(result, key) ? result[key].push(value) : result[key] = [value]; + }); + + // Indexes the object's values by a criterion, similar to `groupBy`, but for + // when you know that your index values will be unique. + _.indexBy = group(function(result, key, value) { + result[key] = value; + }); + + // Counts instances of an object that group by a certain criterion. Pass + // either a string attribute to count by, or a function that returns the + // criterion. + _.countBy = group(function(result, key) { + _.has(result, key) ? result[key]++ : result[key] = 1; + }); + + // Use a comparator function to figure out the smallest index at which + // an object should be inserted so as to maintain order. Uses binary search. + _.sortedIndex = function(array, obj, iterator, context) { + iterator = lookupIterator(iterator); + var value = iterator.call(context, obj); + var low = 0, high = array.length; + while (low < high) { + var mid = (low + high) >>> 1; + iterator.call(context, array[mid]) < value ? low = mid + 1 : high = mid; + } + return low; + }; + + // Safely create a real, live array from anything iterable. + _.toArray = function(obj) { + if (!obj) return []; + if (_.isArray(obj)) return slice.call(obj); + if (obj.length === +obj.length) return _.map(obj, _.identity); + return _.values(obj); + }; + + // Return the number of elements in an object. + _.size = function(obj) { + if (obj == null) return 0; + return (obj.length === +obj.length) ? obj.length : _.keys(obj).length; + }; + + // Array Functions + // --------------- + + // Get the first element of an array. Passing **n** will return the first N + // values in the array. Aliased as `head` and `take`. The **guard** check + // allows it to work with `_.map`. + _.first = _.head = _.take = function(array, n, guard) { + if (array == null) return void 0; + if ((n == null) || guard) return array[0]; + if (n < 0) return []; + return slice.call(array, 0, n); + }; + + // Returns everything but the last entry of the array. Especially useful on + // the arguments object. Passing **n** will return all the values in + // the array, excluding the last N. The **guard** check allows it to work with + // `_.map`. + _.initial = function(array, n, guard) { + return slice.call(array, 0, array.length - ((n == null) || guard ? 1 : n)); + }; + + // Get the last element of an array. Passing **n** will return the last N + // values in the array. The **guard** check allows it to work with `_.map`. + _.last = function(array, n, guard) { + if (array == null) return void 0; + if ((n == null) || guard) return array[array.length - 1]; + return slice.call(array, Math.max(array.length - n, 0)); + }; + + // Returns everything but the first entry of the array. Aliased as `tail` and `drop`. + // Especially useful on the arguments object. Passing an **n** will return + // the rest N values in the array. The **guard** + // check allows it to work with `_.map`. + _.rest = _.tail = _.drop = function(array, n, guard) { + return slice.call(array, (n == null) || guard ? 1 : n); + }; + + // Trim out all falsy values from an array. + _.compact = function(array) { + return _.filter(array, _.identity); + }; + + // Internal implementation of a recursive `flatten` function. + var flatten = function(input, shallow, output) { + if (shallow && _.every(input, _.isArray)) { + return concat.apply(output, input); + } + each(input, function(value) { + if (_.isArray(value) || _.isArguments(value)) { + shallow ? push.apply(output, value) : flatten(value, shallow, output); + } else { + output.push(value); + } + }); + return output; + }; + + // Flatten out an array, either recursively (by default), or just one level. + _.flatten = function(array, shallow) { + return flatten(array, shallow, []); + }; + + // Return a version of the array that does not contain the specified value(s). + _.without = function(array) { + return _.difference(array, slice.call(arguments, 1)); + }; + + // Split an array into two arrays: one whose elements all satisfy the given + // predicate, and one whose elements all do not satisfy the predicate. + _.partition = function(array, predicate) { + var pass = [], fail = []; + each(array, function(elem) { + (predicate(elem) ? pass : fail).push(elem); + }); + return [pass, fail]; + }; + + // Produce a duplicate-free version of the array. If the array has already + // been sorted, you have the option of using a faster algorithm. + // Aliased as `unique`. + _.uniq = _.unique = function(array, isSorted, iterator, context) { + if (_.isFunction(isSorted)) { + context = iterator; + iterator = isSorted; + isSorted = false; + } + var initial = iterator ? _.map(array, iterator, context) : array; + var results = []; + var seen = []; + each(initial, function(value, index) { + if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) { + seen.push(value); + results.push(array[index]); + } + }); + return results; + }; + + // Produce an array that contains the union: each distinct element from all of + // the passed-in arrays. + _.union = function() { + return _.uniq(_.flatten(arguments, true)); + }; + + // Produce an array that contains every item shared between all the + // passed-in arrays. + _.intersection = function(array) { + var rest = slice.call(arguments, 1); + return _.filter(_.uniq(array), function(item) { + return _.every(rest, function(other) { + return _.contains(other, item); + }); + }); + }; + + // Take the difference between one array and a number of other arrays. + // Only the elements present in just the first array will remain. + _.difference = function(array) { + var rest = concat.apply(ArrayProto, slice.call(arguments, 1)); + return _.filter(array, function(value){ return !_.contains(rest, value); }); + }; + + // Zip together multiple lists into a single array -- elements that share + // an index go together. + _.zip = function() { + var length = _.max(_.pluck(arguments, 'length').concat(0)); + var results = new Array(length); + for (var i = 0; i < length; i++) { + results[i] = _.pluck(arguments, '' + i); + } + return results; + }; + + // Converts lists into objects. Pass either a single array of `[key, value]` + // pairs, or two parallel arrays of the same length -- one of keys, and one of + // the corresponding values. + _.object = function(list, values) { + if (list == null) return {}; + var result = {}; + for (var i = 0, length = list.length; i < length; i++) { + if (values) { + result[list[i]] = values[i]; + } else { + result[list[i][0]] = list[i][1]; + } + } + return result; + }; + + // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**), + // we need this function. Return the position of the first occurrence of an + // item in an array, or -1 if the item is not included in the array. + // Delegates to **ECMAScript 5**'s native `indexOf` if available. + // If the array is large and already in sort order, pass `true` + // for **isSorted** to use binary search. + _.indexOf = function(array, item, isSorted) { + if (array == null) return -1; + var i = 0, length = array.length; + if (isSorted) { + if (typeof isSorted == 'number') { + i = (isSorted < 0 ? Math.max(0, length + isSorted) : isSorted); + } else { + i = _.sortedIndex(array, item); + return array[i] === item ? i : -1; + } + } + if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted); + for (; i < length; i++) if (array[i] === item) return i; + return -1; + }; + + // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available. + _.lastIndexOf = function(array, item, from) { + if (array == null) return -1; + var hasIndex = from != null; + if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) { + return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item); + } + var i = (hasIndex ? from : array.length); + while (i--) if (array[i] === item) return i; + return -1; + }; + + // Generate an integer Array containing an arithmetic progression. A port of + // the native Python `range()` function. See + // [the Python documentation](http://docs.python.org/library/functions.html#range). + _.range = function(start, stop, step) { + if (arguments.length <= 1) { + stop = start || 0; + start = 0; + } + step = arguments[2] || 1; + + var length = Math.max(Math.ceil((stop - start) / step), 0); + var idx = 0; + var range = new Array(length); + + while(idx < length) { + range[idx++] = start; + start += step; + } + + return range; + }; + + // Function (ahem) Functions + // ------------------ + + // Reusable constructor function for prototype setting. + var ctor = function(){}; + + // Create a function bound to a given object (assigning `this`, and arguments, + // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if + // available. + _.bind = function(func, context) { + var args, bound; + if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1)); + if (!_.isFunction(func)) throw new TypeError; + args = slice.call(arguments, 2); + return bound = function() { + if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments))); + ctor.prototype = func.prototype; + var self = new ctor; + ctor.prototype = null; + var result = func.apply(self, args.concat(slice.call(arguments))); + if (Object(result) === result) return result; + return self; + }; + }; + + // Partially apply a function by creating a version that has had some of its + // arguments pre-filled, without changing its dynamic `this` context. _ acts + // as a placeholder, allowing any combination of arguments to be pre-filled. + _.partial = function(func) { + var boundArgs = slice.call(arguments, 1); + return function() { + var position = 0; + var args = boundArgs.slice(); + for (var i = 0, length = args.length; i < length; i++) { + if (args[i] === _) args[i] = arguments[position++]; + } + while (position < arguments.length) args.push(arguments[position++]); + return func.apply(this, args); + }; + }; + + // Bind a number of an object's methods to that object. Remaining arguments + // are the method names to be bound. Useful for ensuring that all callbacks + // defined on an object belong to it. + _.bindAll = function(obj) { + var funcs = slice.call(arguments, 1); + if (funcs.length === 0) throw new Error('bindAll must be passed function names'); + each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); }); + return obj; + }; + + // Memoize an expensive function by storing its results. + _.memoize = function(func, hasher) { + var memo = {}; + hasher || (hasher = _.identity); + return function() { + var key = hasher.apply(this, arguments); + return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments)); + }; + }; + + // Delays a function for the given number of milliseconds, and then calls + // it with the arguments supplied. + _.delay = function(func, wait) { + var args = slice.call(arguments, 2); + return setTimeout(function(){ return func.apply(null, args); }, wait); + }; + + // Defers a function, scheduling it to run after the current call stack has + // cleared. + _.defer = function(func) { + return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1))); + }; + + // Returns a function, that, when invoked, will only be triggered at most once + // during a given window of time. Normally, the throttled function will run + // as much as it can, without ever going more than once per `wait` duration; + // but if you'd like to disable the execution on the leading edge, pass + // `{leading: false}`. To disable execution on the trailing edge, ditto. + _.throttle = function(func, wait, options) { + var context, args, result; + var timeout = null; + var previous = 0; + options || (options = {}); + var later = function() { + previous = options.leading === false ? 0 : _.now(); + timeout = null; + result = func.apply(context, args); + context = args = null; + }; + return function() { + var now = _.now(); + if (!previous && options.leading === false) previous = now; + var remaining = wait - (now - previous); + context = this; + args = arguments; + if (remaining <= 0) { + clearTimeout(timeout); + timeout = null; + previous = now; + result = func.apply(context, args); + context = args = null; + } else if (!timeout && options.trailing !== false) { + timeout = setTimeout(later, remaining); + } + return result; + }; + }; + + // Returns a function, that, as long as it continues to be invoked, will not + // be triggered. The function will be called after it stops being called for + // N milliseconds. If `immediate` is passed, trigger the function on the + // leading edge, instead of the trailing. + _.debounce = function(func, wait, immediate) { + var timeout, args, context, timestamp, result; + + var later = function() { + var last = _.now() - timestamp; + if (last < wait) { + timeout = setTimeout(later, wait - last); + } else { + timeout = null; + if (!immediate) { + result = func.apply(context, args); + context = args = null; + } + } + }; + + return function() { + context = this; + args = arguments; + timestamp = _.now(); + var callNow = immediate && !timeout; + if (!timeout) { + timeout = setTimeout(later, wait); + } + if (callNow) { + result = func.apply(context, args); + context = args = null; + } + + return result; + }; + }; + + // Returns a function that will be executed at most one time, no matter how + // often you call it. Useful for lazy initialization. + _.once = function(func) { + var ran = false, memo; + return function() { + if (ran) return memo; + ran = true; + memo = func.apply(this, arguments); + func = null; + return memo; + }; + }; + + // Returns the first function passed as an argument to the second, + // allowing you to adjust arguments, run code before and after, and + // conditionally execute the original function. + _.wrap = function(func, wrapper) { + return _.partial(wrapper, func); + }; + + // Returns a function that is the composition of a list of functions, each + // consuming the return value of the function that follows. + _.compose = function() { + var funcs = arguments; + return function() { + var args = arguments; + for (var i = funcs.length - 1; i >= 0; i--) { + args = [funcs[i].apply(this, args)]; + } + return args[0]; + }; + }; + + // Returns a function that will only be executed after being called N times. + _.after = function(times, func) { + return function() { + if (--times < 1) { + return func.apply(this, arguments); + } + }; + }; + + // Object Functions + // ---------------- + + // Retrieve the names of an object's properties. + // Delegates to **ECMAScript 5**'s native `Object.keys` + _.keys = function(obj) { + if (!_.isObject(obj)) return []; + if (nativeKeys) return nativeKeys(obj); + var keys = []; + for (var key in obj) if (_.has(obj, key)) keys.push(key); + return keys; + }; + + // Retrieve the values of an object's properties. + _.values = function(obj) { + var keys = _.keys(obj); + var length = keys.length; + var values = new Array(length); + for (var i = 0; i < length; i++) { + values[i] = obj[keys[i]]; + } + return values; + }; + + // Convert an object into a list of `[key, value]` pairs. + _.pairs = function(obj) { + var keys = _.keys(obj); + var length = keys.length; + var pairs = new Array(length); + for (var i = 0; i < length; i++) { + pairs[i] = [keys[i], obj[keys[i]]]; + } + return pairs; + }; + + // Invert the keys and values of an object. The values must be serializable. + _.invert = function(obj) { + var result = {}; + var keys = _.keys(obj); + for (var i = 0, length = keys.length; i < length; i++) { + result[obj[keys[i]]] = keys[i]; + } + return result; + }; + + // Return a sorted list of the function names available on the object. + // Aliased as `methods` + _.functions = _.methods = function(obj) { + var names = []; + for (var key in obj) { + if (_.isFunction(obj[key])) names.push(key); + } + return names.sort(); + }; + + // Extend a given object with all the properties in passed-in object(s). + _.extend = function(obj) { + each(slice.call(arguments, 1), function(source) { + if (source) { + for (var prop in source) { + obj[prop] = source[prop]; + } + } + }); + return obj; + }; + + // Return a copy of the object only containing the whitelisted properties. + _.pick = function(obj) { + var copy = {}; + var keys = concat.apply(ArrayProto, slice.call(arguments, 1)); + each(keys, function(key) { + if (key in obj) copy[key] = obj[key]; + }); + return copy; + }; + + // Return a copy of the object without the blacklisted properties. + _.omit = function(obj) { + var copy = {}; + var keys = concat.apply(ArrayProto, slice.call(arguments, 1)); + for (var key in obj) { + if (!_.contains(keys, key)) copy[key] = obj[key]; + } + return copy; + }; + + // Fill in a given object with default properties. + _.defaults = function(obj) { + each(slice.call(arguments, 1), function(source) { + if (source) { + for (var prop in source) { + if (obj[prop] === void 0) obj[prop] = source[prop]; + } + } + }); + return obj; + }; + + // Create a (shallow-cloned) duplicate of an object. + _.clone = function(obj) { + if (!_.isObject(obj)) return obj; + return _.isArray(obj) ? obj.slice() : _.extend({}, obj); + }; + + // Invokes interceptor with the obj, and then returns obj. + // The primary purpose of this method is to "tap into" a method chain, in + // order to perform operations on intermediate results within the chain. + _.tap = function(obj, interceptor) { + interceptor(obj); + return obj; + }; + + // Internal recursive comparison function for `isEqual`. + var eq = function(a, b, aStack, bStack) { + // Identical objects are equal. `0 === -0`, but they aren't identical. + // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal). + if (a === b) return a !== 0 || 1 / a == 1 / b; + // A strict comparison is necessary because `null == undefined`. + if (a == null || b == null) return a === b; + // Unwrap any wrapped objects. + if (a instanceof _) a = a._wrapped; + if (b instanceof _) b = b._wrapped; + // Compare `[[Class]]` names. + var className = toString.call(a); + if (className != toString.call(b)) return false; + switch (className) { + // Strings, numbers, dates, and booleans are compared by value. + case '[object String]': + // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is + // equivalent to `new String("5")`. + return a == String(b); + case '[object Number]': + // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for + // other numeric values. + return a != +a ? b != +b : (a == 0 ? 1 / a == 1 / b : a == +b); + case '[object Date]': + case '[object Boolean]': + // Coerce dates and booleans to numeric primitive values. Dates are compared by their + // millisecond representations. Note that invalid dates with millisecond representations + // of `NaN` are not equivalent. + return +a == +b; + // RegExps are compared by their source patterns and flags. + case '[object RegExp]': + return a.source == b.source && + a.global == b.global && + a.multiline == b.multiline && + a.ignoreCase == b.ignoreCase; + } + if (typeof a != 'object' || typeof b != 'object') return false; + // Assume equality for cyclic structures. The algorithm for detecting cyclic + // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`. + var length = aStack.length; + while (length--) { + // Linear search. Performance is inversely proportional to the number of + // unique nested structures. + if (aStack[length] == a) return bStack[length] == b; + } + // Objects with different constructors are not equivalent, but `Object`s + // from different frames are. + var aCtor = a.constructor, bCtor = b.constructor; + if (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) && + _.isFunction(bCtor) && (bCtor instanceof bCtor)) + && ('constructor' in a && 'constructor' in b)) { + return false; + } + // Add the first object to the stack of traversed objects. + aStack.push(a); + bStack.push(b); + var size = 0, result = true; + // Recursively compare objects and arrays. + if (className == '[object Array]') { + // Compare array lengths to determine if a deep comparison is necessary. + size = a.length; + result = size == b.length; + if (result) { + // Deep compare the contents, ignoring non-numeric properties. + while (size--) { + if (!(result = eq(a[size], b[size], aStack, bStack))) break; + } + } + } else { + // Deep compare objects. + for (var key in a) { + if (_.has(a, key)) { + // Count the expected number of properties. + size++; + // Deep compare each member. + if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break; + } + } + // Ensure that both objects contain the same number of properties. + if (result) { + for (key in b) { + if (_.has(b, key) && !(size--)) break; + } + result = !size; + } + } + // Remove the first object from the stack of traversed objects. + aStack.pop(); + bStack.pop(); + return result; + }; + + // Perform a deep comparison to check if two objects are equal. + _.isEqual = function(a, b) { + return eq(a, b, [], []); + }; + + // Is a given array, string, or object empty? + // An "empty" object has no enumerable own-properties. + _.isEmpty = function(obj) { + if (obj == null) return true; + if (_.isArray(obj) || _.isString(obj)) return obj.length === 0; + for (var key in obj) if (_.has(obj, key)) return false; + return true; + }; + + // Is a given value a DOM element? + _.isElement = function(obj) { + return !!(obj && obj.nodeType === 1); + }; + + // Is a given value an array? + // Delegates to ECMA5's native Array.isArray + _.isArray = nativeIsArray || function(obj) { + return toString.call(obj) == '[object Array]'; + }; + + // Is a given variable an object? + _.isObject = function(obj) { + return obj === Object(obj); + }; + + // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp. + each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) { + _['is' + name] = function(obj) { + return toString.call(obj) == '[object ' + name + ']'; + }; + }); + + // Define a fallback version of the method in browsers (ahem, IE), where + // there isn't any inspectable "Arguments" type. + if (!_.isArguments(arguments)) { + _.isArguments = function(obj) { + return !!(obj && _.has(obj, 'callee')); + }; + } + + // Optimize `isFunction` if appropriate. + if (typeof (/./) !== 'function') { + _.isFunction = function(obj) { + return typeof obj === 'function'; + }; + } + + // Is a given object a finite number? + _.isFinite = function(obj) { + return isFinite(obj) && !isNaN(parseFloat(obj)); + }; + + // Is the given value `NaN`? (NaN is the only number which does not equal itself). + _.isNaN = function(obj) { + return _.isNumber(obj) && obj != +obj; + }; + + // Is a given value a boolean? + _.isBoolean = function(obj) { + return obj === true || obj === false || toString.call(obj) == '[object Boolean]'; + }; + + // Is a given value equal to null? + _.isNull = function(obj) { + return obj === null; + }; + + // Is a given variable undefined? + _.isUndefined = function(obj) { + return obj === void 0; + }; + + // Shortcut function for checking if an object has a given property directly + // on itself (in other words, not on a prototype). + _.has = function(obj, key) { + return hasOwnProperty.call(obj, key); + }; + + // Utility Functions + // ----------------- + + // Run Underscore.js in *noConflict* mode, returning the `_` variable to its + // previous owner. Returns a reference to the Underscore object. + _.noConflict = function() { + root._ = previousUnderscore; + return this; + }; + + // Keep the identity function around for default iterators. + _.identity = function(value) { + return value; + }; + + _.constant = function(value) { + return function () { + return value; + }; + }; + + _.property = function(key) { + return function(obj) { + return obj[key]; + }; + }; + + // Returns a predicate for checking whether an object has a given set of `key:value` pairs. + _.matches = function(attrs) { + return function(obj) { + if (obj === attrs) return true; //avoid comparing an object to itself. + for (var key in attrs) { + if (attrs[key] !== obj[key]) + return false; + } + return true; + } + }; + + // Run a function **n** times. + _.times = function(n, iterator, context) { + var accum = Array(Math.max(0, n)); + for (var i = 0; i < n; i++) accum[i] = iterator.call(context, i); + return accum; + }; + + // Return a random integer between min and max (inclusive). + _.random = function(min, max) { + if (max == null) { + max = min; + min = 0; + } + return min + Math.floor(Math.random() * (max - min + 1)); + }; + + // A (possibly faster) way to get the current timestamp as an integer. + _.now = Date.now || function() { return new Date().getTime(); }; + + // List of HTML entities for escaping. + var entityMap = { + escape: { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''' + } + }; + entityMap.unescape = _.invert(entityMap.escape); + + // Regexes containing the keys and values listed immediately above. + var entityRegexes = { + escape: new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'), + unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g') + }; + + // Functions for escaping and unescaping strings to/from HTML interpolation. + _.each(['escape', 'unescape'], function(method) { + _[method] = function(string) { + if (string == null) return ''; + return ('' + string).replace(entityRegexes[method], function(match) { + return entityMap[method][match]; + }); + }; + }); + + // If the value of the named `property` is a function then invoke it with the + // `object` as context; otherwise, return it. + _.result = function(object, property) { + if (object == null) return void 0; + var value = object[property]; + return _.isFunction(value) ? value.call(object) : value; + }; + + // Add your own custom functions to the Underscore object. + _.mixin = function(obj) { + each(_.functions(obj), function(name) { + var func = _[name] = obj[name]; + _.prototype[name] = function() { + var args = [this._wrapped]; + push.apply(args, arguments); + return result.call(this, func.apply(_, args)); + }; + }); + }; + + // Generate a unique integer id (unique within the entire client session). + // Useful for temporary DOM ids. + var idCounter = 0; + _.uniqueId = function(prefix) { + var id = ++idCounter + ''; + return prefix ? prefix + id : id; + }; + + // By default, Underscore uses ERB-style template delimiters, change the + // following template settings to use alternative delimiters. + _.templateSettings = { + evaluate : /<%([\s\S]+?)%>/g, + interpolate : /<%=([\s\S]+?)%>/g, + escape : /<%-([\s\S]+?)%>/g + }; + + // When customizing `templateSettings`, if you don't want to define an + // interpolation, evaluation or escaping regex, we need one that is + // guaranteed not to match. + var noMatch = /(.)^/; + + // Certain characters need to be escaped so that they can be put into a + // string literal. + var escapes = { + "'": "'", + '\\': '\\', + '\r': 'r', + '\n': 'n', + '\t': 't', + '\u2028': 'u2028', + '\u2029': 'u2029' + }; + + var escaper = /\\|'|\r|\n|\t|\u2028|\u2029/g; + + // JavaScript micro-templating, similar to John Resig's implementation. + // Underscore templating handles arbitrary delimiters, preserves whitespace, + // and correctly escapes quotes within interpolated code. + _.template = function(text, data, settings) { + var render; + settings = _.defaults({}, settings, _.templateSettings); + + // Combine delimiters into one regular expression via alternation. + var matcher = new RegExp([ + (settings.escape || noMatch).source, + (settings.interpolate || noMatch).source, + (settings.evaluate || noMatch).source + ].join('|') + '|$', 'g'); + + // Compile the template source, escaping string literals appropriately. + var index = 0; + var source = "__p+='"; + text.replace(matcher, function(match, escape, interpolate, evaluate, offset) { + source += text.slice(index, offset) + .replace(escaper, function(match) { return '\\' + escapes[match]; }); + + if (escape) { + source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'"; + } + if (interpolate) { + source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'"; + } + if (evaluate) { + source += "';\n" + evaluate + "\n__p+='"; + } + index = offset + match.length; + return match; + }); + source += "';\n"; + + // If a variable is not specified, place data values in local scope. + if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n'; + + source = "var __t,__p='',__j=Array.prototype.join," + + "print=function(){__p+=__j.call(arguments,'');};\n" + + source + "return __p;\n"; + + try { + render = new Function(settings.variable || 'obj', '_', source); + } catch (e) { + e.source = source; + throw e; + } + + if (data) return render(data, _); + var template = function(data) { + return render.call(this, data, _); + }; + + // Provide the compiled function source as a convenience for precompilation. + template.source = 'function(' + (settings.variable || 'obj') + '){\n' + source + '}'; + + return template; + }; + + // Add a "chain" function, which will delegate to the wrapper. + _.chain = function(obj) { + return _(obj).chain(); + }; + + // OOP + // --------------- + // If Underscore is called as a function, it returns a wrapped object that + // can be used OO-style. This wrapper holds altered versions of all the + // underscore functions. Wrapped objects may be chained. + + // Helper function to continue chaining intermediate results. + var result = function(obj) { + return this._chain ? _(obj).chain() : obj; + }; + + // Add all of the Underscore functions to the wrapper object. + _.mixin(_); + + // Add all mutator Array functions to the wrapper. + each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) { + var method = ArrayProto[name]; + _.prototype[name] = function() { + var obj = this._wrapped; + method.apply(obj, arguments); + if ((name == 'shift' || name == 'splice') && obj.length === 0) delete obj[0]; + return result.call(this, obj); + }; + }); + + // Add all accessor Array functions to the wrapper. + each(['concat', 'join', 'slice'], function(name) { + var method = ArrayProto[name]; + _.prototype[name] = function() { + return result.call(this, method.apply(this._wrapped, arguments)); + }; + }); + + _.extend(_.prototype, { + + // Start chaining a wrapped Underscore object. + chain: function() { + this._chain = true; + return this; + }, + + // Extracts the result from a wrapped and chained object. + value: function() { + return this._wrapped; + } + + }); + + // AMD registration happens at the end for compatibility with AMD loaders + // that may not enforce next-turn semantics on modules. Even though general + // practice for AMD registration is to be anonymous, underscore registers + // as a named module because, like jQuery, it is a base library that is + // popular enough to be bundled in a third party lib, but not be part of + // an AMD load request. Those cases could generate an error when an + // anonymous define() is called outside of a loader request. + if (typeof define === 'function' && define.amd) { + define('underscore', [], function() { + return _; + }); + } +}).call(this); + +},{}]},{},[11]) +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/dmonad/Dropbox/Yatta!/node_modules/gulp-browserify/node_modules/browserify/node_modules/browser-pack/_prelude.js","/home/dmonad/Dropbox/Yatta!/lib/Connectors/IwcConnector.coffee","/home/dmonad/Dropbox/Yatta!/lib/Connectors/TestConnector.coffee","/home/dmonad/Dropbox/Yatta!/lib/Engine.coffee","/home/dmonad/Dropbox/Yatta!/lib/Frameworks/JsonYatta.coffee","/home/dmonad/Dropbox/Yatta!/lib/Frameworks/TextYatta.coffee","/home/dmonad/Dropbox/Yatta!/lib/HistoryBuffer.coffee","/home/dmonad/Dropbox/Yatta!/lib/Types/BasicTypes.coffee","/home/dmonad/Dropbox/Yatta!/lib/Types/JsonTypes.coffee","/home/dmonad/Dropbox/Yatta!/lib/Types/StructuredTypes.coffee","/home/dmonad/Dropbox/Yatta!/lib/Types/TextTypes.coffee","/home/dmonad/Dropbox/Yatta!/lib/index.coffee","/home/dmonad/Dropbox/Yatta!/node_modules/underscore/underscore.js"],"names":[],"mappings":"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ACE,OAAA,CAAQ,2BAAR,CADF,CAAA;;AAAA,OAEQ,CAAA,eAAA,CAAR,GACE,OAAA,CAAQ,4BAAR,CAHF,CAAA;;AAAA,OAIQ,CAAA,WAAA,CAAR,GACE,OAAA,CAAQ,wBAAR,CALF,CAAA;;AAAA,OAMQ,CAAA,WAAA,CAAR,GACE,OAAA,CAAQ,wBAAR,CAPF,CAAA;;;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","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# @param {Function} callback The callback is called when the connector is initialized.\n# @param {String} initial_user_id Optional. You can set you own user_id (since the ids of duiclient are not always unique)\n#\ncreateIwcConnector = (callback, initial_user_id)->\n  iwcHandler = {}\n  duiClient = new DUIClient()\n  #@duiClient = new iwc.Client()\n  duiClient.connect (intent)->\n    iwcHandler[intent.action]?.map (f)->\n      setTimeout ()->\n        f intent\n      , 0\n\n  duiClient.initOK()\n\n  received_HB = null\n\n  #\n  # The Iwc Connector adds support for the Inter-Widget-Communication protocol that is used in the Role-SDK.\n  # @see http://dbis.rwth-aachen.de/cms/projects/the-xmpp-experience#interwidget-communication\n  # @see http://dbis.rwth-aachen.de/cms/projects/ROLE\n  #\n  class IwcConnector\n\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    # @param {Yatta} yatta The Yatta framework.\n    #\n    constructor: (@engine, @HB, @execution_listener, @yatta)->\n      @duiClient = duiClient\n      @iwcHandler = iwcHandler\n\n      send_ = (o)=>\n        if Object.getOwnPropertyNames(@initialized).length isnt 0\n          @send o\n      @execution_listener.push send_\n\n      @initialized = {}\n      receiveHB = (json)=>\n        HB = json.extras.HB\n        him = json.extras.user\n        this.engine.applyOpsCheckDouble HB\n        @initialized[him] = true\n      iwcHandler[\"Yatta_push_HB_element\"] = [receiveHB]\n\n      @sendIwcIntent \"Yatta_get_HB_element\", {}\n\n      receive_ = (intent)=>\n        o = intent.extras\n        if @initialized[o.uid.creator]? # initialize first\n          @receive o\n\n      @iwcHandler[\"Yatta_new_operation\"] = [receive_]\n\n      if received_HB?\n        @engine.applyOpsCheckDouble received_HB\n\n      sendHistoryBuffer = ()=>\n        json =\n          HB : @yatta.getHistoryBuffer()._encode()\n          user : @yatta.getUserId()\n        @sendIwcIntent \"Yatta_push_HB_element\", json\n      @iwcHandler[\"Yatta_get_HB_element\"] = [sendHistoryBuffer]\n\n    #\n    # This function is called whenever an operation was executed.\n    # @param {Operation} o The operation that was executed.\n    #\n    send: (o)->\n      if o.uid.creator is @HB.getUserId() and (typeof o.uid.op_number isnt \"string\")\n        @sendIwcIntent \"Yatta_new_operation\", o\n\n    #\n    # This function is called whenever an operation was received from another peer.\n    # @param {Operation} o The operation that was received.\n    #\n    receive: (o)->\n      if o.uid.creator isnt @HB.getUserId()\n        @engine.applyOp o\n\n    #\n    # Helper for sending iwc intents.\n    # @param {String} action_name The name of the action that is going to be send.\n    # @param {String} content The content that is atteched to the intent.\n    #\n    sendIwcIntent: (action_name, content)->\n      intent =\n        action: action_name\n        component: \"\"\n        data: \"\"\n        dataType: \"\"\n        flags: [\"PUBLISH_GLOBAL\"]\n        extras: content\n\n      @duiClient.sendIntent(intent)\n\n\n\n  init = ()->\n    proposed_user_id = null\n    if initial_user_id?\n      proposed_user_id = initial_user_id\n    else\n      # proposed_user_id = duiClient.getIwcClient()._componentName #TODO: This is stupid! why can't i use this?\n      proposed_user_id = Math.floor(Math.random()*1000000)\n    callback IwcConnector, proposed_user_id\n\n  setTimeout init, 5000\n\n  undefined\n\n\nmodule.exports = createIwcConnector\nif window?\n  if not window.Y?\n    window.Y = {}\n  window.Y.createIwcConnector = createIwcConnector\n\n","\n_ = require \"underscore\"\n\nmodule.exports = (user_list)->\n\n  #\n  # A trivial Connector that simulates network delay.\n  #\n  class TestConnector\n\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    # @param {Yatta} yatta The Yatta framework.\n    #\n    constructor: (@engine, @HB, @execution_listener)->\n      send_ = (o)=>\n        @send o\n      @execution_listener.push send_\n\n      @applied_operations = []\n      appliedOperationsListener = (o)=>\n        @applied_operations.push o\n      @execution_listener.push appliedOperationsListener\n      if not (user_list?.length is 0)\n        @engine.applyOps user_list[0].getHistoryBuffer()._encode()\n\n      @unexecuted = {}\n\n    #\n    # This engine applied operations in a specific order.\n    # Get the ops in the right order.\n    #\n    getOpsInExecutionOrder: ()->\n      @applied_operations\n\n    #\n    # This function is called whenever an operation was executed.\n    # @param {Operation} o The operation that was executed.\n    #\n    send: (o)->\n      if (o.uid.creator is @HB.getUserId()) and (typeof o.uid.op_number isnt \"string\")\n        for user in user_list\n          if user.getUserId() isnt @HB.getUserId()\n            user.getConnector().receive(o)\n\n    #\n    # This function is called whenever an operation was received from another peer.\n    # @param {Operation} o The operation that was received.\n    #\n    receive: (o)->\n      @unexecuted[o.uid.creator] ?= []\n      @unexecuted[o.uid.creator].push o\n\n    #\n    # Flush one operation from the line of a specific user.\n    #\n    flushOne: (user)->\n      if @unexecuted[user]?.length > 0\n        @engine.applyOp @unexecuted[user].shift()\n\n    #\n    # Flush one operation on a random line.\n    #\n    flushOneRandom: ()->\n      @flushOne (_.random 0, (user_list.length-1))\n\n    #\n    # Flush all operations on every line.\n    #\n    flushAll: ()->\n      for n,ops of @unexecuted\n        @engine.applyOps ops\n      @unexecuted = {}\n\n","\r\n#\r\n# The Engine handles how and in which order to execute operations and add operations to the HistoryBuffer.\r\n#\r\nclass Engine\r\n\r\n  #\r\n  # @param {HistoryBuffer} HB\r\n  # @param {Array} parser Defines how to parse encoded messages.\r\n  #\r\n  constructor: (@HB, @parser)->\r\n    @unprocessed_ops = []\r\n\r\n  #\r\n  # Parses an operatio from the json format. It uses the specified parser in your OperationType module.\r\n  #\r\n  parseOperation: (json)->\r\n    typeParser = @parser[json.type]\r\n    if typeParser?\r\n      typeParser json\r\n    else\r\n      throw new Error \"You forgot to specify a parser for type #{json.type}. The message is #{JSON.stringify json}.\"\r\n\r\n  #\r\n  # Apply a set of operations. E.g. the operations you received from another users HB.toJson().\r\n  # @note You must not use this method when you already have ops in your HB!\r\n  #\r\n  applyOpsBundle: (ops_json)->\r\n    ops = []\r\n    for o in ops_json\r\n      ops.push @parseOperation o\r\n    for o in ops\r\n      @HB.addOperation o\r\n    for o in ops\r\n      if not o.execute()\r\n        @unprocessed_ops.push o\r\n    @tryUnprocessed()\r\n\r\n  #\r\n  # Same as applyOps but operations that are already in the HB are not applied.\r\n  # @see Engine.applyOps\r\n  #\r\n  applyOpsCheckDouble: (ops_json)->\r\n    for o in ops_json\r\n      if not @HB.getOperation(o.uid)?\r\n        @applyOp o\r\n\r\n  #\r\n  # Apply a set of operations. (Helper for using applyOp on Arrays)\r\n  # @see Engine.applyOp\r\n  applyOps: (ops_json)->\r\n    for o in ops_json\r\n      @applyOp o\r\n\r\n  #\r\n  # Apply an operation that you received from another peer.\r\n  #\r\n  applyOp: (op_json)->\r\n    # $parse_and_execute will return false if $o_json was parsed and executed, otherwise the parsed operadion\r\n    o = @parseOperation op_json\r\n    @HB.addToCounter o\r\n    # @HB.addOperation o\r\n    if not o.execute()\r\n      @unprocessed_ops.push o\r\n    else\r\n      @HB.addOperation o\r\n    @tryUnprocessed()\r\n\r\n  #\r\n  # Call this method when you applied a new operation.\r\n  # It checks if operations that were previously not executable are now executable.\r\n  #\r\n  tryUnprocessed: ()->\r\n    while true\r\n      old_length = @unprocessed_ops.length\r\n      unprocessed = []\r\n      for op in @unprocessed_ops\r\n        if not op.execute()\r\n          unprocessed.push op\r\n        else\r\n          @HB.addOperation op\r\n      @unprocessed_ops = unprocessed\r\n      if @unprocessed_ops.length is old_length\r\n        break\r\n\r\n\r\n\r\n\r\nmodule.exports = Engine\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n","\njson_types_uninitialized = require \"../Types/JsonTypes\"\nHistoryBuffer = require \"../HistoryBuffer\"\nEngine = require \"../Engine\"\n\n#\n# Framework for Json data-structures.\n# Known values that are supported:\n# * String\n# * Integer\n# * Array\n#\nclass JsonYatta\n\n  #\n  # @param {String} user_id Unique id of the peer.\n  # @param {Connector} Connector the connector class.\n  #\n  constructor: (user_id, Connector)->\n    @HB = new HistoryBuffer user_id\n    json_types = json_types_uninitialized @HB\n    @engine = new Engine @HB, json_types.parser\n    @connector = new Connector @engine, @HB, json_types.execution_listener, @\n\n    first_word = new json_types.types.JsonType @HB.getReservedUniqueIdentifier()\n    @HB.addOperation(first_word).execute()\n    @root_element = first_word\n\n  #\n  # @result JsonType\n  #\n  getRootElement: ()->\n    @root_element\n\n  #\n  # @see Engine\n  #\n  getEngine: ()->\n    @engine\n\n  #\n  # Get the initialized connector.\n  #\n  getConnector: ()->\n    @connector\n\n  #\n  # @see HistoryBuffer\n  #\n  getHistoryBuffer: ()->\n    @HB\n\n  #\n  # @see JsonType.setMutableDefault\n  #\n  setMutableDefault: (mutable)->\n    @root_element.setMutableDefault(mutable)\n\n  #\n  # Get the UserId from the HistoryBuffer object.\n  # In most cases this will be the same as the user_id value with which\n  # JsonYatta was initialized (Depending on the HistoryBuffer implementation).\n  #\n  getUserId: ()->\n    @HB.getUserId()\n\n  #\n  # @see JsonType.val\n  #\n  val : (name, content, mutable)->\n    @root_element.val(name, content, mutable)\n\n  #\n  # @see JsonType.value\n  #\n  Object.defineProperty JsonYatta.prototype, 'value',\n    get : -> @root_element.value\n    set : (o)->\n      if o.constructor is {}.constructor\n        for o_name,o_obj of o\n          @val(o_name, o_obj, 'immutable')\n      else\n        throw new Error \"You must only set Object values!\"\n\nmodule.exports = JsonYatta\nif window?\n  if not window.Y?\n    window.Y = {}\n  window.Y.JsonYatta = JsonYatta\n","\ntext_types_uninitialized = require \"../Types/TextTypes\"\nHistoryBuffer = require \"../HistoryBuffer\"\nEngine = require \"../Engine\"\n\n#\n# Framework for Text Datastructures.\n#\nclass TextYatta\n\n  #\n  # @param {String} user_id Uniqe user id that defines this peer.\n  # @param {Connector} Connector The connector defines how you connect to the other peers.\n  #\n  constructor: (user_id, Connector)->\n    @HB = new HistoryBuffer user_id\n    text_types = text_types_uninitialized @HB\n    types = text_types.types\n    @engine = new Engine @HB, text_types.parser\n    @connector = new Connector @engine, @HB, text_types.execution_listener, @\n\n    beginning = @HB.addOperation new types.Delimiter {creator: '_', op_number: '_beginning'} , undefined, undefined\n    end =       @HB.addOperation new types.Delimiter {creator: '_', op_number: '_end'}       , beginning, undefined\n    beginning.next_cl = end\n    beginning.execute()\n    end.execute()\n    first_word = new text_types.types.Word {creator: '_', op_number: '_'}, beginning, end\n    @HB.addOperation(first_word).execute()\n    @root_element = first_word\n\n  #\n  # @result Word\n  #\n  getRootElement: ()->\n    @root_element\n\n  #\n  # @see Engine\n  #\n  getEngine: ()->\n    @engine\n\n  #\n  # Get the initialized connector.\n  #\n  getConnector: ()->\n    @connector\n\n  #\n  # @see HistoryBuffer\n  #\n  getHistoryBuffer: ()->\n    @HB\n\n  #\n  # Get the UserId from the HistoryBuffer object.\n  # In most cases this will be the same as the user_id value with which\n  # JsonYatta was initialized (Depending on the HistoryBuffer implementation).\n  #\n  getUserId: ()->\n    @HB.getUserId()\n\n  #\n  # @see JsonType.val\n  #\n  val: ()->\n    @root_element.val()\n\n  #\n  # @see Word.insertText\n  #\n  insertText: (pos, content)->\n    @root_element.insertText pos, content\n\n  #\n  # @see Word.deleteText\n  #\n  deleteText: (pos, length)->\n    @root_element.deleteText pos, length\n\n  #\n  # @see Word.bind\n  #\n  bind: (textarea)->\n    @root_element.bind textarea\n\n  #\n  # @see Word.replaceText\n  #\n  replaceText: (text)->\n    @root_element.replaceText text\n\n\nmodule.exports = TextYatta\nif window?\n  if not window.Y?\n    window.Y = {}\n  window.Y.TextYatta = TextYatta\n","\n#\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\n  #\n  # Get the user id with wich the History Buffer was initialized.\n  #\n  getUserId: ()->\n    @user_id\n\n  #\n  # There is only one reserved unique identifier (uid), so use it wisely.\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 : '_'\n    }\n\n  #\n  # Get the operation counter that describes the current state of the document.\n  #\n  getOperationCounter: ()->\n    res = {}\n    for user,ctn of @operation_counter\n      res[user] = ctn\n    res\n\n  #\n  # Encode this operation in such a way that it can be parsed by remote peers.\n  #\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      for o_number,o of user\n        if (not isNaN(parseInt(o_number))) and unknown(u_name, o_number)\n          o_json = o._encode()\n          if o.next_cl?\n            o_next = o.next_cl\n            while o_next.next_cl? and unknown(o_next.creator, o_next.op_number)\n              o_next = o_next.next_cl\n            o_json.next = o_next.getUid()\n          else if o.prev_cl?\n            o_prev = o.prev_cl\n            while o_prev.prev_cl? and unknown(o_next.creator, o_next.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  getOperation: (uid)->\n    if uid instanceof Object\n      @buffer[uid.creator]?[uid.op_number]\n    else if not uid?\n    else\n      throw new Error \"This type of uid is not defined!\"\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.creator]?\n      @buffer[o.creator] = {}\n    if @buffer[o.creator][o.op_number]?\n      throw new Error \"You must not overwrite operations!\"\n    @buffer[o.creator][o.op_number] = o\n    o\n\n  #\n  # Increment the operation_counter that defines the current state of the Engine.\n  #\n  addToCounter: (o)->\n    if not @operation_counter[o.creator]?\n      @operation_counter[o.creator] = 0\n    if typeof o.op_number is 'number' and o.creator isnt @getUserId()\n      @operation_counter[o.creator]++\n    #if @operation_counter[o.creator] isnt (o.op_number + 1)\n      #console.log (@operation_counter[o.creator] - (o.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 = (HB)->\n  # @see Engine.parse\n  parser = {}\n  execution_listener = []\n\n  #\n  # A generic interface to operations.\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.\n  #\n  class Operation\n\n    #\n    # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n    # @see HistoryBuffer.getNextOperationIdentifier\n    #\n    constructor: (uid)->\n      if not uid?\n        uid = HB.getNextOperationIdentifier()\n      {\n        'creator': @creator\n        'op_number' : @op_number\n      } = uid\n\n    #\n    # Add an event listener. It depends on the operation which events are supported.\n    # @param {String} event Name of the event.\n    # @param {Function} f f is executed in case the event fires.\n    #\n    on: (event, f)->\n      @event_listeners ?= {}\n      @event_listeners[event] ?= []\n      @event_listeners[event].push f\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    #\n    callEvent: (event, args)->\n      if @event_listeners?[event]?\n        for f in @event_listeners[event]\n          f.call @, event, args\n\n    #\n    # Set the parent of this operation.\n    #\n    setParent: (o)->\n      @parent = o\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      { 'creator': @creator, 'op_number': @op_number }\n\n    #\n    # @private\n    # Notify the all the listeners.\n    #\n    execute: ()->\n      @is_executed = true\n      for l in execution_listener\n        l @_encode()\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 op?.execute?\n        # is instantiated\n        @[name] = op\n      else if op?\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\n\n  #\n  # A simple Delete-type operation that deletes an Insert-type operation.\n  #\n  class Delete extends 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: (uid, deletes)->\n      @saveOperation 'deletes', deletes\n      super uid\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        @deletes.applyDelete @\n        super\n      else\n        false\n\n  #\n  # Define how to parse Delete operations.\n  #\n  parser['Delete'] = (o)->\n    {\n      'uid' : uid\n      'deletes': deletes_uid\n    } = o\n    new Delete uid, deletes_uid\n\n  #\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 Insert extends 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    # @see HistoryBuffer.getNextOperationIdentifier\n    #\n    constructor: (uid, prev_cl, next_cl, origin)->\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 uid\n\n    #\n    # @private\n    #\n    applyDelete: (o)->\n      @deleted_by ?= []\n      @deleted_by.push o\n      if @parent? and @deleted_by.length is 1\n        # call iff wasn't deleted earlyer\n        @parent.callEvent \"delete\", @\n\n    #\n    # If isDeleted() is true this operation won't be maintained in the sl\n    #\n    isDeleted: ()->\n      @deleted_by?.length > 0\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        #TODO: delete this\n        if @ is @prev_cl\n          throw new Error \"this should not happen ;) \"\n        o = o.prev_cl\n      d\n\n    #\n    # @private\n    # Update the short list\n    # TODO (Unused)\n    update_sl: ()->\n      o = @prev_cl\n      update: (dest_cl,dest_sl)->\n        while true\n          if o.isDeleted()\n            o = o[dest_cl]\n          else\n            @[dest_sl] = o\n\n            break\n      update \"prev_cl\", \"prev_sl\"\n      update \"next_cl\", \"prev_sl\"\n\n\n\n    #\n    # @private\n    # Include this operation in the associative lists.\n    #\n    execute: ()->\n      if @is_executed?\n        return @\n      if not @validateSavedOperations()\n        return false\n      else\n        if @prev_cl?.validateSavedOperations() and @next_cl?.validateSavedOperations() and @prev_cl.next_cl isnt @\n          distance_to_origin = 0\n          o = @prev_cl.next_cl\n          i = 0\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 (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 not o?\n              # TODO: Debugging\n              console.log JSON.stringify @prev_cl.getUid()\n              console.log JSON.stringify @next_cl.getUid()\n            if o isnt @next_cl\n              # $o happened concurrently\n              if o.getDistanceToOrigin() is i\n                # case 1\n                if o.creator < @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        parent = @prev_cl?.getParent()\n        if parent?\n          @setParent parent\n          @parent.callEvent \"insert\", @\n        super # notify the execution_listeners\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 Delimiter\n          break\n        if prev.isDeleted? and not prev.isDeleted()\n          position++\n        prev = prev.prev_cl\n      position\n  #\n  # Defines an object that is cannot be changed. You can use this to set an immutable string, or a number.\n  #\n  class ImmutableObject extends Insert\n\n    #\n    # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n    # @param {Object} content\n    #\n    constructor: (uid, @content, prev, next, origin)->\n      super uid, prev, next, origin\n\n    #\n    # @return [String] The content of this operation.\n    #\n    val : ()->\n      @content\n\n    #\n    # Encode this operation in such a way that it can be parsed by remote peers.\n    #\n    _encode: ()->\n      json = {\n        'type': \"ImmutableObject\"\n        'uid' : @getUid()\n        'content' : @content\n      }\n      if @prev_cl?\n        json['prev'] = @prev_cl.getUid()\n      if @next_cl?\n        json['next'] = @next_cl.getUid()\n      if @origin? and @origin isnt @prev_cl\n        json[\"origin\"] = @origin.getUid()\n      json\n\n  parser['ImmutableObject'] = (json)->\n    {\n      'uid' : uid\n      'content' : content\n      'prev': prev\n      'next': next\n      'origin' : origin\n    } = json\n    new ImmutableObject uid, content, prev, next, origin\n\n  #\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 Delimiter extends 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    # @see HistoryBuffer.getNextOperationIdentifier\n    #\n    constructor: (uid, prev_cl, next_cl, origin)->\n      @saveOperation 'prev_cl', prev_cl\n      @saveOperation 'next_cl', next_cl\n      @saveOperation 'origin', prev_cl\n      super uid\n\n    #\n    # If isDeleted() is true this operation won't be maintained in the sl\n    #\n    isDeleted: ()->\n      false\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          delete @prev_cl.unchecked.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      else if @prev_cl? or @next_cl?\n        super\n      else\n        throw new Error \"Delimiter is unsufficient defined!\"\n\n    #\n    # @private\n    #\n    _encode: ()->\n      {\n        'type' : \"Delimiter\"\n        'uid' : @getUid()\n        'prev' : @prev_cl?.getUid()\n        'next' : @next_cl?.getUid()\n      }\n\n  parser['Delimiter'] = (json)->\n    {\n    'uid' : uid\n    'prev' : prev\n    'next' : next\n    } = json\n    new Delimiter uid, prev, next\n\n  # This is what this module exports after initializing it with the HistoryBuffer\n  {\n    'types' :\n      'Delete' : Delete\n      'Insert' : Insert\n      'Delimiter': Delimiter\n      'Operation': Operation\n      'ImmutableObject' : ImmutableObject\n    'parser' : parser\n    'execution_listener' : execution_listener\n  }\n\n\n\n\n","text_types_uninitialized = require \"./TextTypes\"\n\nmodule.exports = (HB)->\n  text_types = text_types_uninitialized HB\n  types = text_types.types\n  parser = text_types.parser\n\n  createJsonWrapper = (_jsonType)->\n\n    #\n    # A JsonWrapper was intended to be a convenient wrapper for the JsonType.\n    # But it can make things more difficult than they are.\n    # @see JsonType\n    #\n    # @example create a JsonWrapper\n    #   # You get a JsonWrapper from a JsonType by calling\n    #   w = yatta.value\n    #\n    # It creates Javascripts -getter and -setter methods for each property that JsonType maintains.\n    # @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty\n    #\n    # @example Getter Example\n    #   # you can access the x property of yatta by calling\n    #   w.x\n    #   # instead of\n    #   yatta.val('x')\n    #\n    # @note You can only overwrite existing values! Setting a new property won't have any effect!\n    #\n    # @example Setter Example\n    #   # you can set an existing x property of yatta by calling\n    #   w.x = \"text\"\n    #   # instead of\n    #   yatta.val('x', \"text\")\n    #\n    # In order to set a new property you have to overwrite an existing property.\n    # Therefore the JsonWrapper supports a special feature that should make things more convenient\n    # (we can argue about that, use the JsonType if you don't like it ;).\n    # If you overwrite an object property of the JsonWrapper with a new object, it will result in a merged version of the objects.\n    # Let w.p the property that is to be overwritten and o the new value. E.g. w.p = o\n    # * The result has all properties of o\n    # * The result has all properties of w.p if they don't occur under the same property-name in o.\n    #\n    # @example Conflict Example\n    #   yatta.value = {a : \"string\"}\n    #   w = yatta.value\n    #   console.log(w) # {a : \"string\"}\n    #   w.a = {a : {b : \"string\"}}\n    #   console.log(w) # {a : {b : \"String\"}}\n    #   w.a = {a : {c : 4}}\n    #   console.log(w) # {a : {b : \"String\", c : 4}}\n    #\n    # @example Common Pitfalls\n    #   w = yatta.value\n    #   # Setting a new property\n    #   w.newProperty = \"Awesome\"\n    #   console.log(w.newProperty == \"Awesome\") # false, w.newProperty is undefined\n    #   # overwrite the w object\n    #   w = {newProperty : \"Awesome\"}\n    #   console.log(w.newProperty == \"Awesome\") # true!, but ..\n    #   console.log(yatta.value.newProperty == \"Awesome\") # false, you are only allowed to set properties!\n    #   # The solution\n    #   yatta.value = {newProperty : \"Awesome\"}\n    #   console.log(w.newProperty == \"Awesome\") # true!\n    #\n    class JsonWrapper\n\n      #\n      # @param {JsonType} jsonType Instance of the JsonType that this class wrappes.\n      #\n      constructor: (jsonType)->\n        for name, obj of jsonType.map\n          do (name, obj)->\n            Object.defineProperty JsonWrapper.prototype, name,\n              get : ->\n                x = obj.val()\n                if x instanceof JsonType\n                  createJsonWrapper x\n                else if x instanceof types.ImmutableObject\n                  x.val()\n                else\n                  x\n              set : (o)->\n                if o.constructor is {}.constructor\n                  overwrite = jsonType.val(name)\n                  for o_name,o_obj of o\n                    overwrite.val(o_name, o_obj, 'immutable')\n                else\n                  jsonType.val(name, o, 'immutable')\n              enumerable: true\n              configurable: false\n    new JsonWrapper _jsonType\n\n  #\n  # Manages Object-like values.\n  #\n  class JsonType extends types.MapManager\n\n    #\n    # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n    # @param {Object} initial_value Create this operation with an initial value.\n    # @param {String|Boolean} Whether the initial_value should be created as mutable. (Optional - see setMutableDefault)\n    #\n    constructor: (uid, initial_value, mutable)->\n      super uid\n      if initial_value?\n        if typeof initial_value isnt \"object\"\n          throw new Error \"The initial value of JsonTypes must be of type Object! (current type: #{typeof initial_value})\"\n        for name,o of initial_value\n          @val name, o, mutable\n\n    #\n    # Whether the default is 'mutable' (true) or 'immutable' (false)\n    #\n    mutable_default:\n      true\n\n    #\n    # Set if the default is 'mutable' or 'immutable'\n    # @param {String|Boolean} mutable Set either 'mutable' / true or 'immutable' / false\n    setMutableDefault: (mutable)->\n      if mutable is true or mutable is 'mutable'\n        JsonType.prototype.mutable_default = true\n      else if mutable is false or mutable is 'immutable'\n        JsonType.prototype.mutable_default = false\n      else\n        throw new Error 'Set mutable either \"mutable\" or \"immutable\"!'\n      'OK'\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 [JsonType|Word|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 [JsonType] This object. (supports chaining)\n    #\n    val: (name, content, mutable)->\n      if typeof name is 'object'\n        # Special case. First argument is an object. Then the second arg is mutable.\n        # Keep that in mind when reading the following..\n        for o_name,o of name\n          @val(o_name,o,content)\n        @\n      else if name? and content?\n        if mutable?\n          if mutable is true or mutable is 'mutable'\n            mutable = true\n          else\n            mutable = false\n        else\n          mutable = @mutable_default\n        if typeof content is 'function'\n          @ # Just do nothing\n        else if ((not mutable) or typeof content is 'number') and content.constructor isnt Object\n          obj = HB.addOperation(new types.ImmutableObject undefined, content).execute()\n          super name, obj\n        else\n          if typeof content is 'string'\n            word = HB.addOperation(new types.Word undefined).execute()\n            word.insertText 0, content\n            super name, word\n          else if content.constructor is Object\n            json = HB.addOperation(new JsonType undefined, content, mutable).execute()\n            super name, json\n          else\n            throw new Error \"You must not set #{typeof content}-types in collaborative Json-objects!\"\n      else\n        super name, content\n\n    Object.defineProperty JsonType.prototype, 'value',\n      get : -> createJsonWrapper @\n      set : (o)->\n        if o.constructor is {}.constructor\n          for o_name,o_obj of o\n            @val(o_name, o_obj, 'immutable')\n        else\n          throw new Error \"You must only set Object values!\"\n\n    #\n    # @private\n    #\n    _encode: ()->\n      {\n        'type' : \"JsonType\"\n        'uid' : @getUid()\n      }\n\n  parser['JsonType'] = (json)->\n    {\n      'uid' : uid\n    } = json\n    new JsonType uid\n\n\n\n\n  types['JsonType'] = JsonType\n\n  text_types\n\n\n","basic_types_uninitialized = require \"./BasicTypes\"\n\nmodule.exports = (HB)->\n  basic_types = basic_types_uninitialized HB\n  types = basic_types.types\n  parser = basic_types.parser\n\n  #\n  # Manages map like objects. E.g. Json-Type and XML attributes.\n  #\n  class MapManager extends types.Operation\n\n    #\n    # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n    #\n    constructor: (uid)->\n      @map = {}\n      super uid\n\n    #\n    # @see JsonTypes.val\n    #\n    val: (name, content)->\n      if content?\n        if not @map[name]?\n          HB.addOperation(new AddName undefined, @, name).execute()\n        @map[name].replace content\n        @\n      else if name?\n        obj = @map[name]?.val()\n        if obj instanceof types.ImmutableObject\n          obj.val()\n        else\n          obj\n      else\n        result = {}\n        for name,o of @map\n          obj = o.val()\n          if obj instanceof types.ImmutableObject or obj instanceof MapManager\n            obj = obj.val()\n          result[name] = obj\n        result\n\n  #\n  # When a new property in a map manager is created, then the uids of the inserted Operations\n  # must be unique (think about concurrent operations). Therefore only an AddName operation is allowed to\n  # add a property in a MapManager. If two AddName operations on the same MapManager name happen concurrently\n  # only one will AddName operation will be executed.\n  #\n  class AddName extends types.Operation\n\n    #\n    # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n    # @param {Object} map_manager Uid or reference to the MapManager.\n    # @param {String} name Name of the property that will be added.\n    #\n    constructor: (uid, map_manager, @name)->\n      @saveOperation 'map_manager', map_manager\n      super uid\n\n    #\n    # If map_manager doesn't have the property name, then add it.\n    # The ReplaceManager that is being written on the property is unique\n    # in such a way that if AddName is executed (from another peer) it will\n    # always have the same result (ReplaceManager, and its beginning and end are the same)\n    #\n    execute: ()->\n      if not @validateSavedOperations()\n        return false\n      else\n        uid_r = @map_manager.getUid()\n        uid_r.op_number = \"_#{uid_r.op_number}_RM_#{@name}\"\n        if not HB.getOperation(uid_r)?\n          uid_beg = @map_manager.getUid()\n          uid_beg.op_number = \"_#{uid_beg.op_number}_RM_#{@name}_beginning\"\n          uid_end = @map_manager.getUid()\n          uid_end.op_number = \"_#{uid_end.op_number}_RM_#{@name}_end\"\n          beg = HB.addOperation(new types.Delimiter uid_beg, undefined, uid_end).execute()\n          end = HB.addOperation(new types.Delimiter uid_end, beg, undefined).execute()\n          #beg.execute()\n          @map_manager.map[@name] = HB.addOperation(new ReplaceManager undefined, uid_r, beg, end).execute()\n        super\n\n    #\n    # Encode this operation in such a way that it can be parsed by remote peers.\n    #\n    _encode: ()->\n      {\n        'type' : \"AddName\"\n        'uid' : @getUid()\n        'map_manager' : @map_manager.getUid()\n        'name' : @name\n      }\n\n  parser['AddName'] = (json)->\n    {\n      'map_manager' : map_manager\n      'uid' : uid\n      'name' : name\n    } = json\n    new AddName uid, map_manager, name\n\n  #\n  # Manages a list of Insert-type operations.\n  #\n  class ListManager extends types.Insert\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: (uid, beginning, end, prev, next, origin)->\n      if beginning? and end?\n        @saveOperation 'beginning', beginning\n        @saveOperation 'end', end\n      else\n        @beginning = HB.addOperation new types.Delimiter undefined, undefined, undefined\n        @end =       HB.addOperation new types.Delimiter undefined, @beginning, undefined\n        @beginning.next_cl = @end\n        @beginning.execute()\n        @end.execute()\n      super uid, prev, next, origin\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        result.push o\n        o = o.next_cl\n      result\n\n    #\n    # Retrieves the x-th not deleted element.\n    #\n    getOperationByPosition: (position)->\n      o = @beginning.next_cl\n      if position > 0\n        while true\n          o = o.next_cl\n          if not o.isDeleted()\n            position -= 1\n          if position is 0\n            break\n          if o instanceof types.Delimiter\n            console.log \"position parameter exceeded the length of the document!\"\n            o = null\n            break\n      o\n\n  #\n  # Adds support for replace. The ReplaceManager manages Replaceable operations.\n  # Each Replaceable holds a value that is now replaceable.\n  #\n  # The Word-type has implemented support for replace\n  # @see Word\n  #\n  class ReplaceManager extends ListManager\n    #\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: (initial_content, uid, beginning, end, prev, next, origin)->\n      super uid, beginning, end, prev, next, origin\n      if initial_content?\n        @replace initial_content\n\n    #\n    # Replace the existing word with a new word.\n    #\n    replace: (content)->\n      o = @getLastOperation()\n      op = new Replaceable content, @, undefined, o, o.next_cl\n      HB.addOperation(op).execute()\n\n    #\n    # Get the value of this Word\n    # @return {String}\n    #\n    val: ()->\n      o = @getLastOperation()\n      if o instanceof types.Delimiter\n        throw new Error \"dtrn\"\n      o.val()\n\n    #\n    # Encode this operation in such a way that it can be parsed by remote peers.\n    #\n    _encode: ()->\n      json =\n        {\n          'type': \"ReplaceManager\"\n          'uid' : @getUid()\n          'beginning' : @beginning.getUid()\n          'end' : @end.getUid()\n        }\n      if @prev_cl? and @next_cl?\n        json['prev'] = @prev_cl.getUid()\n        json['next'] = @next_cl.getUid()\n      if @origin? and @origin isnt @prev_cl\n        json[\"origin\"] = @origin.getUid()\n      json\n\n  parser[\"ReplaceManager\"] = (json)->\n    {\n      'content' : content\n      'uid' : uid\n      'prev': prev\n      'next': next\n      'origin' : origin\n      'beginning' : beginning\n      'end' : end\n    } = json\n    new ReplaceManager content, uid, beginning, end, prev, next, origin\n\n\n  #\n  # The ReplaceManager manages Replaceables.\n  # @see ReplaceManager\n  #\n  class Replaceable extends types.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: (content, parent, uid, prev, next, origin)->\n      @saveOperation 'content', content\n      @saveOperation 'parent', parent\n      if not (prev? and next? and content?)\n        throw new Error \"You must define content, prev, and next for Replaceable-types!\"\n      super uid, prev, next, origin\n\n    #\n    # Return the content that this operation holds.\n    #\n    val: ()->\n      @content\n\n    #\n    # Replace the content of this replaceable with new content.\n    #\n    replace: (content)->\n      @parent.replace content\n\n    #\n    # If possible set the replace manager in the content.\n    # @see Word.setReplaceManager\n    #\n    execute: ()->\n      if not @validateSavedOperations()\n        return false\n      else\n        @content.setReplaceManager?(@parent)\n        super\n\n    #\n    # Encode this operation in such a way that it can be parsed by remote peers.\n    #\n    _encode: ()->\n      json =\n        {\n          'type': \"Replaceable\"\n          'content': @content.getUid()\n          'ReplaceManager' : @parent.getUid()\n          'prev': @prev_cl.getUid()\n          'next': @next_cl.getUid()\n          'uid' : @getUid()\n        }\n      if @origin? and @origin isnt @prev_cl\n        json[\"origin\"] = @origin.getUid()\n      json\n\n  parser[\"Replaceable\"] = (json)->\n    {\n      'content' : content\n      'ReplaceManager' : parent\n      'uid' : uid\n      'prev': prev\n      'next': next\n      'origin' : origin\n    } = json\n    new Replaceable content, parent, uid, prev, next, origin\n\n\n\n  types['ListManager'] = ListManager\n  types['MapManager'] = MapManager\n  types['ReplaceManager'] = ReplaceManager\n  types['Replaceable'] = Replaceable\n\n  basic_types\n\n\n\n\n\n\n","structured_types_uninitialized = require \"./StructuredTypes\"\n\nmodule.exports = (HB)->\n  structured_types = structured_types_uninitialized HB\n  types = structured_types.types\n  parser = structured_types.parser\n\n  #\n  # At the moment TextDelete type equals the Delete type in BasicTypes.\n  # @see BasicTypes.Delete\n  #\n  class TextDelete extends types.Delete\n  parser[\"TextDelete\"] = parser[\"Delete\"]\n\n  #\n  #  Extends the basic Insert type to an operation that holds a text value\n  #\n  class TextInsert extends types.Insert\n    #\n    # @param {String} content The content of this Insert-type Operation. Usually you restrict the length of content to size 1\n    # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n    #\n    constructor: (@content, uid, prev, next, origin)->\n      if not (prev? and next?)\n        throw new Error \"You must define prev, and next for TextInsert-types!\"\n      super uid, prev, next, origin\n    #\n    # Retrieve the effective length of the $content of this operation.\n    #\n    getLength: ()->\n      if @isDeleted()\n        0\n      else\n        @content.length\n\n    #\n    # The result will be concatenated with the results from the other insert operations\n    # in order to retrieve the content of the engine.\n    # @see HistoryBuffer.toExecutedArray\n    #\n    val: (current_position)->\n      if @isDeleted()\n        \"\"\n      else\n        @content\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: ()->\n      json =\n        {\n          'type': \"TextInsert\"\n          'content': @content\n          'uid' : @getUid()\n          'prev': @prev_cl.getUid()\n          'next': @next_cl.getUid()\n        }\n      if @origin? and @origin isnt @prev_cl\n        json[\"origin\"] = @origin.getUid()\n      json\n\n  parser[\"TextInsert\"] = (json)->\n    {\n      'content' : content\n      'uid' : uid\n      'prev': prev\n      'next': next\n      'origin' : origin\n    } = json\n    new TextInsert content, uid, prev, next, origin\n\n  #\n  # Handles a Text-like data structures with support for insertText/deleteText at a word-position.\n  #\n  class Word extends types.ListManager\n\n    #\n    # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n    #\n    constructor: (uid, beginning, end, prev, next, origin)->\n      super uid, beginning, end, prev, next, origin\n\n    #\n    # Inserts a string into the word\n    #\n    insertText: (position, content)->\n      o = @getOperationByPosition position\n      for c in content\n        op = new TextInsert c, undefined, o.prev_cl, o\n        HB.addOperation(op).execute()\n\n    #\n    # Deletes a part of the word.\n    #\n    deleteText: (position, length)->\n      o = @getOperationByPosition position\n\n      delete_ops = []\n      for i in [0...length]\n        d = HB.addOperation(new TextDelete undefined, o).execute()\n        o = o.next_cl\n        while o.isDeleted() and not (o instanceof types.Delimiter)\n          if o instanceof types.Delimiter\n            throw new Error \"You can't delete more than there is..\"\n          o = o.next_cl\n        delete_ops.push d._encode()\n        if o instanceof types.Delimiter\n          break\n\n\n    #\n    # Replace the content of this word with another one. Concurrent replacements are not merged!\n    # Only one of the replacements will be used.\n    #\n    # Can only be used if the ReplaceManager was set!\n    # @see Word.setReplaceManager\n    #\n    replaceText: (text)->\n      if @replace_manager?\n        word = HB.addOperation(new Word undefined).execute()\n        word.insertText 0, text\n        @replace_manager.replace(word)\n      else\n        throw new Error \"This type is currently not maintained by a ReplaceManager!\"\n\n    #\n    # @returns [Json] A Json object.\n    #\n    val: ()->\n      c = for o in @toArray()\n        if o.val?\n          o.val()\n        else\n          \"\"\n      c.join('')\n\n    #\n    # In most cases you would embed a Word in a Replaceable, wich is handled by the ReplaceManager in order\n    # to provide replace functionality.\n    #\n    setReplaceManager: (op)->\n      @saveOperation 'replace_manager', op\n      @validateSavedOperations\n\n    #\n    # Bind this Word to a textfield.\n    #\n    bind: (textfield)->\n      word = @\n      textfield.value = @val()\n\n      @on \"insert\", (event, op)->\n        if op.creator isnt HB.getUserId()\n          o_pos = op.getPosition()\n          fix = (cursor)->\n            if cursor <= o_pos\n              cursor\n            else\n              cursor += 1\n              cursor\n          left = fix textfield.selectionStart\n          right = fix textfield.selectionEnd\n\n          textfield.value = word.val()\n          textfield.setSelectionRange left, right\n\n\n      @on \"delete\", (event, op)->\n        o_pos = op.getPosition()\n        fix = (cursor)->\n          if cursor < o_pos\n            cursor\n          else\n            cursor -= 1\n            cursor\n        left = fix textfield.selectionStart\n        right = fix textfield.selectionEnd\n\n        textfield.value = word.val()\n        textfield.setSelectionRange left, right\n\n      # consume all text-insert changes.\n      textfield.onkeypress = (event)->\n        char = String.fromCharCode event.keyCode\n        if char.length > 0\n          pos = Math.min textfield.selectionStart, textfield.selectionEnd\n          diff = Math.abs(textfield.selectionEnd - textfield.selectionStart)\n          word.deleteText pos, diff\n          word.insertText pos, char\n        else\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        pos = Math.min textfield.selectionStart, textfield.selectionEnd\n        diff = Math.abs(textfield.selectionEnd - textfield.selectionStart)\n        if event.keyCode? and event.keyCode is 8\n          if diff > 0\n            word.deleteText pos, diff\n          else\n            if event.ctrlKey? and event.ctrlKey\n              val = textfield.value\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.deleteText new_pos, (pos-new_pos)\n              textfield.setSelectionRange new_pos, new_pos\n            else\n              word.deleteText (pos-1), 1\n          event.preventDefault()\n        else if event.keyCode? and event.keyCode is 46\n          if diff > 0\n            word.deleteText pos, diff\n          else\n            word.deleteText pos, 1\n          event.preventDefault()\n\n\n\n    #\n    # Encode this operation in such a way that it can be parsed by remote peers.\n    #\n    _encode: ()->\n      json = {\n        'type': \"Word\"\n        'uid' : @getUid()\n        'beginning' : @beginning.getUid()\n        'end' : @end.getUid()\n      }\n      if @prev_cl?\n        json['prev'] = @prev_cl.getUid()\n      if @next_cl?\n        json['next'] = @next_cl.getUid()\n      if @origin? and @origin isnt @prev_cl\n        json[\"origin\"] = @origin.getUid()\n      json\n\n  parser['Word'] = (json)->\n    {\n      'uid' : uid\n      'beginning' : beginning\n      'end' : end\n      'prev': prev\n      'next': next\n      'origin' : origin\n    } = json\n    new Word uid, beginning, end, prev, next, origin\n\n  types['TextInsert'] = TextInsert\n  types['TextDelete'] = TextDelete\n  types['Word'] = Word\n  structured_types\n\n\n","\nexports['IwcConnector'] =\n  require './Connectors/IwcConnector'\nexports['TestConnector'] =\n  require './Connectors/TestConnector'\nexports['JsonYatta'] =\n  require './Frameworks/JsonYatta'\nexports['TextYatta'] =\n  require './Frameworks/TextYatta'\n\n","//     Underscore.js 1.6.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  // Establish the object that gets returned to break out of a loop iteration.\n  var breaker = {};\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    nativeForEach      = ArrayProto.forEach,\n    nativeMap          = ArrayProto.map,\n    nativeReduce       = ArrayProto.reduce,\n    nativeReduceRight  = ArrayProto.reduceRight,\n    nativeFilter       = ArrayProto.filter,\n    nativeEvery        = ArrayProto.every,\n    nativeSome         = ArrayProto.some,\n    nativeIndexOf      = ArrayProto.indexOf,\n    nativeLastIndexOf  = ArrayProto.lastIndexOf,\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 via a string identifier,\n  // for Closure Compiler \"advanced\" mode.\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.6.0';\n\n  // Collection Functions\n  // --------------------\n\n  // The cornerstone, an `each` implementation, aka `forEach`.\n  // Handles objects with the built-in `forEach`, arrays, and raw objects.\n  // Delegates to **ECMAScript 5**'s native `forEach` if available.\n  var each = _.each = _.forEach = function(obj, iterator, context) {\n    if (obj == null) return obj;\n    if (nativeForEach && obj.forEach === nativeForEach) {\n      obj.forEach(iterator, context);\n    } else if (obj.length === +obj.length) {\n      for (var i = 0, length = obj.length; i < length; i++) {\n        if (iterator.call(context, obj[i], i, obj) === breaker) return;\n      }\n    } else {\n      var keys = _.keys(obj);\n      for (var i = 0, length = keys.length; i < length; i++) {\n        if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) return;\n      }\n    }\n    return obj;\n  };\n\n  // Return the results of applying the iterator to each element.\n  // Delegates to **ECMAScript 5**'s native `map` if available.\n  _.map = _.collect = function(obj, iterator, context) {\n    var results = [];\n    if (obj == null) return results;\n    if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);\n    each(obj, function(value, index, list) {\n      results.push(iterator.call(context, value, index, list));\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`. Delegates to **ECMAScript 5**'s native `reduce` if available.\n  _.reduce = _.foldl = _.inject = function(obj, iterator, memo, context) {\n    var initial = arguments.length > 2;\n    if (obj == null) obj = [];\n    if (nativeReduce && obj.reduce === nativeReduce) {\n      if (context) iterator = _.bind(iterator, context);\n      return initial ? obj.reduce(iterator, memo) : obj.reduce(iterator);\n    }\n    each(obj, function(value, index, list) {\n      if (!initial) {\n        memo = value;\n        initial = true;\n      } else {\n        memo = iterator.call(context, memo, value, index, list);\n      }\n    });\n    if (!initial) throw new TypeError(reduceError);\n    return memo;\n  };\n\n  // The right-associative version of reduce, also known as `foldr`.\n  // Delegates to **ECMAScript 5**'s native `reduceRight` if available.\n  _.reduceRight = _.foldr = function(obj, iterator, memo, context) {\n    var initial = arguments.length > 2;\n    if (obj == null) obj = [];\n    if (nativeReduceRight && obj.reduceRight === nativeReduceRight) {\n      if (context) iterator = _.bind(iterator, context);\n      return initial ? obj.reduceRight(iterator, memo) : obj.reduceRight(iterator);\n    }\n    var length = obj.length;\n    if (length !== +length) {\n      var keys = _.keys(obj);\n      length = keys.length;\n    }\n    each(obj, function(value, index, list) {\n      index = keys ? keys[--length] : --length;\n      if (!initial) {\n        memo = obj[index];\n        initial = true;\n      } else {\n        memo = iterator.call(context, memo, obj[index], index, list);\n      }\n    });\n    if (!initial) throw new TypeError(reduceError);\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    any(obj, function(value, index, list) {\n      if (predicate.call(context, 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  // Delegates to **ECMAScript 5**'s native `filter` if available.\n  // Aliased as `select`.\n  _.filter = _.select = function(obj, predicate, context) {\n    var results = [];\n    if (obj == null) return results;\n    if (nativeFilter && obj.filter === nativeFilter) return obj.filter(predicate, context);\n    each(obj, function(value, index, list) {\n      if (predicate.call(context, 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, function(value, index, list) {\n      return !predicate.call(context, value, index, list);\n    }, context);\n  };\n\n  // Determine whether all of the elements match a truth test.\n  // Delegates to **ECMAScript 5**'s native `every` if available.\n  // Aliased as `all`.\n  _.every = _.all = function(obj, predicate, context) {\n    predicate || (predicate = _.identity);\n    var result = true;\n    if (obj == null) return result;\n    if (nativeEvery && obj.every === nativeEvery) return obj.every(predicate, context);\n    each(obj, function(value, index, list) {\n      if (!(result = result && predicate.call(context, value, index, list))) return breaker;\n    });\n    return !!result;\n  };\n\n  // Determine if at least one element in the object matches a truth test.\n  // Delegates to **ECMAScript 5**'s native `some` if available.\n  // Aliased as `any`.\n  var any = _.some = _.any = function(obj, predicate, context) {\n    predicate || (predicate = _.identity);\n    var result = false;\n    if (obj == null) return result;\n    if (nativeSome && obj.some === nativeSome) return obj.some(predicate, context);\n    each(obj, function(value, index, list) {\n      if (result || (result = predicate.call(context, value, index, list))) return breaker;\n    });\n    return !!result;\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 (nativeIndexOf && obj.indexOf === nativeIndexOf) return obj.indexOf(target) != -1;\n    return any(obj, function(value) {\n      return value === target;\n    });\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  // Can't optimize arrays of integers longer than 65,535 elements.\n  // See [WebKit Bug 80797](https://bugs.webkit.org/show_bug.cgi?id=80797)\n  _.max = function(obj, iterator, context) {\n    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {\n      return Math.max.apply(Math, obj);\n    }\n    var result = -Infinity, lastComputed = -Infinity;\n    each(obj, function(value, index, list) {\n      var computed = iterator ? iterator.call(context, value, index, list) : value;\n      if (computed > lastComputed) {\n        result = value;\n        lastComputed = computed;\n      }\n    });\n    return result;\n  };\n\n  // Return the minimum element (or element-based computation).\n  _.min = function(obj, iterator, context) {\n    if (!iterator && _.isArray(obj) && obj[0] === +obj[0] && obj.length < 65535) {\n      return Math.min.apply(Math, obj);\n    }\n    var result = Infinity, lastComputed = Infinity;\n    each(obj, function(value, index, list) {\n      var computed = iterator ? iterator.call(context, value, index, list) : value;\n      if (computed < lastComputed) {\n        result = value;\n        lastComputed = computed;\n      }\n    });\n    return result;\n  };\n\n  // Shuffle an array, using the modern version of the\n  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n  _.shuffle = function(obj) {\n    var rand;\n    var index = 0;\n    var shuffled = [];\n    each(obj, function(value) {\n      rand = _.random(index++);\n      shuffled[index - 1] = shuffled[rand];\n      shuffled[rand] = value;\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  // An internal function to generate lookup iterators.\n  var lookupIterator = function(value) {\n    if (value == null) return _.identity;\n    if (_.isFunction(value)) return value;\n    return _.property(value);\n  };\n\n  // Sort the object's values by a criterion produced by an iterator.\n  _.sortBy = function(obj, iterator, context) {\n    iterator = lookupIterator(iterator);\n    return _.pluck(_.map(obj, function(value, index, list) {\n      return {\n        value: value,\n        index: index,\n        criteria: iterator.call(context, 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, iterator, context) {\n      var result = {};\n      iterator = lookupIterator(iterator);\n      each(obj, function(value, index) {\n        var key = iterator.call(context, value, index, obj);\n        behavior(result, key, value);\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, key, value) {\n    _.has(result, key) ? result[key].push(value) : 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, key, value) {\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, key) {\n    _.has(result, key) ? result[key]++ : 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, iterator, context) {\n    iterator = lookupIterator(iterator);\n    var value = iterator.call(context, obj);\n    var low = 0, high = array.length;\n    while (low < high) {\n      var mid = (low + high) >>> 1;\n      iterator.call(context, array[mid]) < value ? low = mid + 1 : 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  // 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, 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, output) {\n    if (shallow && _.every(input, _.isArray)) {\n      return concat.apply(output, input);\n    }\n    each(input, function(value) {\n      if (_.isArray(value) || _.isArguments(value)) {\n        shallow ? push.apply(output, value) : flatten(value, shallow, output);\n      } else {\n        output.push(value);\n      }\n    });\n    return output;\n  };\n\n  // Flatten out an array, either recursively (by default), or just one level.\n  _.flatten = function(array, shallow) {\n    return flatten(array, shallow, []);\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  // Split an array 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(array, predicate) {\n    var pass = [], fail = [];\n    each(array, function(elem) {\n      (predicate(elem) ? pass : fail).push(elem);\n    });\n    return [pass, fail];\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, iterator, context) {\n    if (_.isFunction(isSorted)) {\n      context = iterator;\n      iterator = isSorted;\n      isSorted = false;\n    }\n    var initial = iterator ? _.map(array, iterator, context) : array;\n    var results = [];\n    var seen = [];\n    each(initial, function(value, index) {\n      if (isSorted ? (!index || seen[seen.length - 1] !== value) : !_.contains(seen, value)) {\n        seen.push(value);\n        results.push(array[index]);\n      }\n    });\n    return results;\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));\n  };\n\n  // Produce an array that contains every item shared between all the\n  // passed-in arrays.\n  _.intersection = function(array) {\n    var rest = slice.call(arguments, 1);\n    return _.filter(_.uniq(array), function(item) {\n      return _.every(rest, function(other) {\n        return _.contains(other, item);\n      });\n    });\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 = concat.apply(ArrayProto, slice.call(arguments, 1));\n    return _.filter(array, function(value){ return !_.contains(rest, value); });\n  };\n\n  // Zip together multiple lists into a single array -- elements that share\n  // an index go together.\n  _.zip = function() {\n    var length = _.max(_.pluck(arguments, 'length').concat(0));\n    var results = new 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  // If the browser doesn't supply us with indexOf (I'm looking at you, **MSIE**),\n  // we need this function. Return the position of the first occurrence of an\n  // item in an array, or -1 if the item is not included in the array.\n  // Delegates to **ECMAScript 5**'s native `indexOf` if available.\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    if (nativeIndexOf && array.indexOf === nativeIndexOf) return array.indexOf(item, isSorted);\n    for (; i < length; i++) if (array[i] === item) return i;\n    return -1;\n  };\n\n  // Delegates to **ECMAScript 5**'s native `lastIndexOf` if available.\n  _.lastIndexOf = function(array, item, from) {\n    if (array == null) return -1;\n    var hasIndex = from != null;\n    if (nativeLastIndexOf && array.lastIndexOf === nativeLastIndexOf) {\n      return hasIndex ? array.lastIndexOf(item, from) : array.lastIndexOf(item);\n    }\n    var i = (hasIndex ? from : array.length);\n    while (i--) if (array[i] === item) return i;\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 = arguments[2] || 1;\n\n    var length = Math.max(Math.ceil((stop - start) / step), 0);\n    var idx = 0;\n    var range = new Array(length);\n\n    while(idx < length) {\n      range[idx++] = start;\n      start += step;\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;\n    args = slice.call(arguments, 2);\n    return 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 (Object(result) === result) return result;\n      return self;\n    };\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 funcs = slice.call(arguments, 1);\n    if (funcs.length === 0) throw new Error('bindAll must be passed function names');\n    each(funcs, function(f) { obj[f] = _.bind(obj[f], obj); });\n    return obj;\n  };\n\n  // Memoize an expensive function by storing its results.\n  _.memoize = function(func, hasher) {\n    var memo = {};\n    hasher || (hasher = _.identity);\n    return function() {\n      var key = hasher.apply(this, arguments);\n      return _.has(memo, key) ? memo[key] : (memo[key] = func.apply(this, arguments));\n    };\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(){ return func.apply(null, args); }, 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    options || (options = {});\n    var later = function() {\n      previous = options.leading === false ? 0 : _.now();\n      timeout = null;\n      result = func.apply(context, args);\n      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) {\n        clearTimeout(timeout);\n        timeout = null;\n        previous = now;\n        result = func.apply(context, args);\n        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      if (last < wait) {\n        timeout = setTimeout(later, wait - last);\n      } else {\n        timeout = null;\n        if (!immediate) {\n          result = func.apply(context, args);\n          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) {\n        timeout = setTimeout(later, wait);\n      }\n      if (callNow) {\n        result = func.apply(context, args);\n        context = args = null;\n      }\n\n      return result;\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 = function(func) {\n    var ran = false, memo;\n    return function() {\n      if (ran) return memo;\n      ran = true;\n      memo = func.apply(this, arguments);\n      func = null;\n      return memo;\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 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 funcs = arguments;\n    return function() {\n      var args = arguments;\n      for (var i = funcs.length - 1; i >= 0; i--) {\n        args = [funcs[i].apply(this, args)];\n      }\n      return args[0];\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  // 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 = new 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 = new 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    each(slice.call(arguments, 1), function(source) {\n      if (source) {\n        for (var prop in source) {\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) {\n    var copy = {};\n    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));\n    each(keys, function(key) {\n      if (key in obj) copy[key] = obj[key];\n    });\n    return copy;\n  };\n\n   // Return a copy of the object without the blacklisted properties.\n  _.omit = function(obj) {\n    var copy = {};\n    var keys = concat.apply(ArrayProto, slice.call(arguments, 1));\n    for (var key in obj) {\n      if (!_.contains(keys, key)) copy[key] = obj[key];\n    }\n    return copy;\n  };\n\n  // Fill in a given object with default properties.\n  _.defaults = function(obj) {\n    each(slice.call(arguments, 1), function(source) {\n      if (source) {\n        for (var prop in source) {\n          if (obj[prop] === void 0) obj[prop] = source[prop];\n        }\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, dates, and booleans are compared by value.\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 == String(b);\n      case '[object Number]':\n        // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for\n        // other numeric values.\n        return a != +a ? b != +b : (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      // RegExps are compared by their source patterns and flags.\n      case '[object RegExp]':\n        return a.source == b.source &&\n               a.global == b.global &&\n               a.multiline == b.multiline &&\n               a.ignoreCase == b.ignoreCase;\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 (aCtor !== bCtor && !(_.isFunction(aCtor) && (aCtor instanceof aCtor) &&\n                             _.isFunction(bCtor) && (bCtor instanceof bCtor))\n                        && ('constructor' in a && 'constructor' in b)) {\n      return false;\n    }\n    // Add the first object to the stack of traversed objects.\n    aStack.push(a);\n    bStack.push(b);\n    var size = 0, result = true;\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      for (var key in a) {\n        if (_.has(a, key)) {\n          // Count the expected number of properties.\n          size++;\n          // Deep compare each member.\n          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;\n        }\n      }\n      // Ensure that both objects contain the same number of properties.\n      if (result) {\n        for (key in b) {\n          if (_.has(b, key) && !(size--)) break;\n        }\n        result = !size;\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)) 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    return obj === 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 !!(obj && _.has(obj, 'callee'));\n    };\n  }\n\n  // Optimize `isFunction` if appropriate.\n  if (typeof (/./) !== 'function') {\n    _.isFunction = function(obj) {\n      return typeof obj === 'function';\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 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 iterators.\n  _.identity = function(value) {\n    return value;\n  };\n\n  _.constant = function(value) {\n    return function () {\n      return value;\n    };\n  };\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    return function(obj) {\n      if (obj === attrs) return true; //avoid comparing an object to itself.\n      for (var key in attrs) {\n        if (attrs[key] !== obj[key])\n          return false;\n      }\n      return true;\n    }\n  };\n\n  // Run a function **n** times.\n  _.times = function(n, iterator, context) {\n    var accum = Array(Math.max(0, n));\n    for (var i = 0; i < n; i++) accum[i] = iterator.call(context, 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() { return new Date().getTime(); };\n\n  // List of HTML entities for escaping.\n  var entityMap = {\n    escape: {\n      '&': '&amp;',\n      '<': '&lt;',\n      '>': '&gt;',\n      '\"': '&quot;',\n      \"'\": '&#x27;'\n    }\n  };\n  entityMap.unescape = _.invert(entityMap.escape);\n\n  // Regexes containing the keys and values listed immediately above.\n  var entityRegexes = {\n    escape:   new RegExp('[' + _.keys(entityMap.escape).join('') + ']', 'g'),\n    unescape: new RegExp('(' + _.keys(entityMap.unescape).join('|') + ')', 'g')\n  };\n\n  // Functions for escaping and unescaping strings to/from HTML interpolation.\n  _.each(['escape', 'unescape'], function(method) {\n    _[method] = function(string) {\n      if (string == null) return '';\n      return ('' + string).replace(entityRegexes[method], function(match) {\n        return entityMap[method][match];\n      });\n    };\n  });\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) ? value.call(object) : value;\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  // 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    '\\t':     't',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  var escaper = /\\\\|'|\\r|\\n|\\t|\\u2028|\\u2029/g;\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  _.template = function(text, data, settings) {\n    var render;\n    settings = _.defaults({}, settings, _.templateSettings);\n\n    // Combine delimiters into one regular expression via alternation.\n    var matcher = new 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)\n        .replace(escaper, function(match) { return '\\\\' + escapes[match]; });\n\n      if (escape) {\n        source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n      }\n      if (interpolate) {\n        source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n      }\n      if (evaluate) {\n        source += \"';\\n\" + evaluate + \"\\n__p+='\";\n      }\n      index = offset + match.length;\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      render = new Function(settings.variable || 'obj', '_', source);\n    } catch (e) {\n      e.source = source;\n      throw e;\n    }\n\n    if (data) return render(data, _);\n    var template = function(data) {\n      return render.call(this, data, _);\n    };\n\n    // Provide the compiled function source as a convenience for precompilation.\n    template.source = 'function(' + (settings.variable || 'obj') + '){\\n' + source + '}';\n\n    return template;\n  };\n\n  // Add a \"chain\" function, which will delegate to the wrapper.\n  _.chain = function(obj) {\n    return _(obj).chain();\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 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  _.extend(_.prototype, {\n\n    // Start chaining a wrapped Underscore object.\n    chain: function() {\n      this._chain = true;\n      return this;\n    },\n\n    // Extracts the result from a wrapped and chained object.\n    value: function() {\n      return this._wrapped;\n    }\n\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"]} diff --git a/build/browser/index.min.js b/build/browser/index.min.js new file mode 100644 index 00000000..3d581dda --- /dev/null +++ b/build/browser/index.min.js @@ -0,0 +1,2 @@ +!function t(e,n,r){function i(u,a){if(!n[u]){if(!e[u]){var s="function"==typeof require&&require;if(!a&&s)return s(u,!0);if(o)return o(u,!0);throw new Error("Cannot find module '"+u+"'")}var c=n[u]={exports:{}};e[u][0].call(c.exports,function(t){var n=e[u][1][t];return i(n?n:t)},c,c.exports,t,e,n,r)}return n[u].exports}for(var o="function"==typeof require&&require,u=0;ur;r++)n=t[r],o.push(n.getUserId()!==this.HB.getUserId()?n.getConnector().receive(e):void 0);return o}},e.prototype.receive=function(t){var e,n;return null==(e=this.unexecuted)[n=t.uid.creator]&&(e[n]=[]),this.unexecuted[t.uid.creator].push(t)},e.prototype.flushOne=function(t){var e;return(null!=(e=this.unexecuted[t])?e.length:void 0)>0?this.engine.applyOp(this.unexecuted[t].shift()):void 0},e.prototype.flushOneRandom=function(){return this.flushOne(n.random(0,t.length-1))},e.prototype.flushAll=function(){var t,e,n;n=this.unexecuted;for(t in n)e=n[t],this.engine.applyOps(e);return this.unexecuted={}},e}()}},{underscore:12}],3:[function(t,e){var n;n=function(){function t(t,e){this.HB=t,this.parser=e,this.unprocessed_ops=[]}return t.prototype.parseOperation=function(t){var e;if(e=this.parser[t.type],null!=e)return e(t);throw new Error("You forgot to specify a parser for type "+t.type+". The message is "+JSON.stringify(t)+".")},t.prototype.applyOpsBundle=function(t){var e,n,r,i,o,u,a,s;for(n=[],r=0,u=t.length;u>r;r++)e=t[r],n.push(this.parseOperation(e));for(i=0,a=n.length;a>i;i++)e=n[i],this.HB.addOperation(e);for(o=0,s=n.length;s>o;o++)e=n[o],e.execute()||this.unprocessed_ops.push(e);return this.tryUnprocessed()},t.prototype.applyOpsCheckDouble=function(t){var e,n,r,i;for(i=[],n=0,r=t.length;r>n;n++)e=t[n],i.push(null==this.HB.getOperation(e.uid)?this.applyOp(e):void 0);return i},t.prototype.applyOps=function(t){var e,n,r,i;for(i=[],n=0,r=t.length;r>n;n++)e=t[n],i.push(this.applyOp(e));return i},t.prototype.applyOp=function(t){var e;return e=this.parseOperation(t),this.HB.addToCounter(e),e.execute()?this.HB.addOperation(e):this.unprocessed_ops.push(e),this.tryUnprocessed()},t.prototype.tryUnprocessed=function(){var t,e,n,r,i,o,u;for(u=[];;){for(t=this.unprocessed_ops.length,n=[],o=this.unprocessed_ops,r=0,i=o.length;i>r;r++)e=o[r],e.execute()?this.HB.addOperation(e):n.push(e);if(this.unprocessed_ops=n,this.unprocessed_ops.length===t)break;u.push(void 0)}return u},t}(),e.exports=n},{}],4:[function(t,e){var n,r,i,o;o=t("../Types/JsonTypes"),r=t("../HistoryBuffer"),n=t("../Engine"),i=function(){function t(t,e){var i,u;this.HB=new r(t),u=o(this.HB),this.engine=new n(this.HB,u.parser),this.connector=new e(this.engine,this.HB,u.execution_listener,this),i=new u.types.JsonType(this.HB.getReservedUniqueIdentifier()),this.HB.addOperation(i).execute(),this.root_element=i}return t.prototype.getRootElement=function(){return this.root_element},t.prototype.getEngine=function(){return this.engine},t.prototype.getConnector=function(){return this.connector},t.prototype.getHistoryBuffer=function(){return this.HB},t.prototype.setMutableDefault=function(t){return this.root_element.setMutableDefault(t)},t.prototype.getUserId=function(){return this.HB.getUserId()},t.prototype.val=function(t,e,n){return this.root_element.val(t,e,n)},Object.defineProperty(t.prototype,"value",{get:function(){return this.root_element.value},set:function(t){var e,n,r;if(t.constructor==={}.constructor){r=[];for(e in t)n=t[e],r.push(this.val(e,n,"immutable"));return r}throw new Error("You must only set Object values!")}}),t}(),e.exports=i,"undefined"!=typeof window&&null!==window&&(null==window.Y&&(window.Y={}),window.Y.JsonYatta=i)},{"../Engine":3,"../HistoryBuffer":6,"../Types/JsonTypes":8}],5:[function(t,e){var n,r,i,o;o=t("../Types/TextTypes"),r=t("../HistoryBuffer"),n=t("../Engine"),i=function(){function t(t,e){var i,u,a,s,c;this.HB=new r(t),s=o(this.HB),c=s.types,this.engine=new n(this.HB,s.parser),this.connector=new e(this.engine,this.HB,s.execution_listener,this),i=this.HB.addOperation(new c.Delimiter({creator:"_",op_number:"_beginning"},void 0,void 0)),u=this.HB.addOperation(new c.Delimiter({creator:"_",op_number:"_end"},i,void 0)),i.next_cl=u,i.execute(),u.execute(),a=new s.types.Word({creator:"_",op_number:"_"},i,u),this.HB.addOperation(a).execute(),this.root_element=a}return t.prototype.getRootElement=function(){return this.root_element},t.prototype.getEngine=function(){return this.engine},t.prototype.getConnector=function(){return this.connector},t.prototype.getHistoryBuffer=function(){return this.HB},t.prototype.getUserId=function(){return this.HB.getUserId()},t.prototype.val=function(){return this.root_element.val()},t.prototype.insertText=function(t,e){return this.root_element.insertText(t,e)},t.prototype.deleteText=function(t,e){return this.root_element.deleteText(t,e)},t.prototype.bind=function(t){return this.root_element.bind(t)},t.prototype.replaceText=function(t){return this.root_element.replaceText(t)},t}(),e.exports=i,"undefined"!=typeof window&&null!==window&&(null==window.Y&&(window.Y={}),window.Y.TextYatta=i)},{"../Engine":3,"../HistoryBuffer":6,"../Types/TextTypes":10}],6:[function(t,e){var n;n=function(){function t(t){this.user_id=t,this.operation_counter={},this.buffer={},this.change_listeners=[]}return t.prototype.getUserId=function(){return this.user_id},t.prototype.getReservedUniqueIdentifier=function(){return{creator:"_",op_number:"_"}},t.prototype.getOperationCounter=function(){var t,e,n,r;e={},r=this.operation_counter;for(n in r)t=r[n],e[n]=t;return e},t.prototype._encode=function(t){var e,n,r,i,o,u,a,s,c,l;null==t&&(t={}),e=[],s=function(e,n){if(null==e||null==n)throw new Error("dah!");return null==t[e]||t[e]<=n},l=this.buffer;for(a in l){c=l[a];for(o in c)if(n=c[o],!isNaN(parseInt(o))&&s(a,o)){if(r=n._encode(),null!=n.next_cl){for(i=n.next_cl;null!=i.next_cl&&s(i.creator,i.op_number);)i=i.next_cl;r.next=i.getUid()}else if(null!=n.prev_cl){for(u=n.prev_cl;null!=u.prev_cl&&s(i.creator,i.op_number);)u=u.prev_cl;r.prev=u.getUid()}e.push(r)}}return e},t.prototype.getNextOperationIdentifier=function(t){var e;return null==t&&(t=this.user_id),null==this.operation_counter[t]&&(this.operation_counter[t]=0),e={creator:t,op_number:this.operation_counter[t]},this.operation_counter[t]++,e},t.prototype.getOperation=function(t){var e;if(t instanceof Object)return null!=(e=this.buffer[t.creator])?e[t.op_number]:void 0;if(null!=t)throw new Error("This type of uid is not defined!")},t.prototype.addOperation=function(t){if(null==this.buffer[t.creator]&&(this.buffer[t.creator]={}),null!=this.buffer[t.creator][t.op_number])throw new Error("You must not overwrite operations!");return this.buffer[t.creator][t.op_number]=t,t},t.prototype.addToCounter=function(t){return null==this.operation_counter[t.creator]&&(this.operation_counter[t.creator]=0),"number"==typeof t.op_number&&t.creator!==this.getUserId()?this.operation_counter[t.creator]++:void 0},t}(),e.exports=n},{}],7:[function(t,e){var n={}.hasOwnProperty,r=function(t,e){function r(){this.constructor=t}for(var i in e)n.call(e,i)&&(t[i]=e[i]);return r.prototype=e.prototype,t.prototype=new r,t.__super__=e.prototype,t};e.exports=function(t){var e,n,i,o,u,a,s;return s={},a=[],u=function(){function e(e){null==e&&(e=t.getNextOperationIdentifier()),this.creator=e.creator,this.op_number=e.op_number}return e.prototype.on=function(t,e){var n;return null==this.event_listeners&&(this.event_listeners={}),null==(n=this.event_listeners)[t]&&(n[t]=[]),this.event_listeners[t].push(e)},e.prototype.callEvent=function(t,e){var n,r,i,o,u,a;if(null!=(null!=(o=this.event_listeners)?o[t]:void 0)){for(u=this.event_listeners[t],a=[],r=0,i=u.length;i>r;r++)n=u[r],a.push(n.call(this,t,e));return a}},e.prototype.setParent=function(t){return this.parent=t},e.prototype.getParent=function(){return this.parent},e.prototype.getUid=function(){return{creator:this.creator,op_number:this.op_number}},e.prototype.execute=function(){var t,e,n;for(this.is_executed=!0,e=0,n=a.length;n>e;e++)(t=a[e])(this._encode());return this},e.prototype.saveOperation=function(t,e){return null!=(null!=e?e.execute:void 0)?this[t]=e:null!=e?(null==this.unchecked&&(this.unchecked={}),this.unchecked[t]=e):void 0},e.prototype.validateSavedOperations=function(){var e,n,r,i,o,u;o={},i=this,u=this.unchecked;for(e in u)r=u[e],n=t.getOperation(r),n?this[e]=n:(o[e]=r,i=!1);return delete this.unchecked,i||(this.unchecked=o),i},e}(),e=function(t){function e(t,n){this.saveOperation("deletes",n),e.__super__.constructor.call(this,t)}return r(e,t),e.prototype._encode=function(){return{type:"Delete",uid:this.getUid(),deletes:this.deletes.getUid()}},e.prototype.execute=function(){return this.validateSavedOperations()?(this.deletes.applyDelete(this),e.__super__.execute.apply(this,arguments)):!1},e}(u),s.Delete=function(t){var n,r;return r=t.uid,n=t.deletes,new e(r,n)},o=function(t){function e(t,n,r,i){this.saveOperation("prev_cl",n),this.saveOperation("next_cl",r),null!=i?this.saveOperation("origin",i):this.saveOperation("origin",n),e.__super__.constructor.call(this,t)}return r(e,t),e.prototype.applyDelete=function(t){return null==this.deleted_by&&(this.deleted_by=[]),this.deleted_by.push(t),null!=this.parent&&1===this.deleted_by.length?this.parent.callEvent("delete",this):void 0},e.prototype.isDeleted=function(){var t;return(null!=(t=this.deleted_by)?t.length:void 0)>0},e.prototype.getDistanceToOrigin=function(){var t,e;for(t=0,e=this.prev_cl;;){if(this.origin===e)break;if(t++,this===this.prev_cl)throw new Error("this should not happen ;) ");e=e.prev_cl}return t},e.prototype.update_sl=function(){var t;return t=this.prev_cl,update("prev_cl","prev_sl"),update("next_cl","prev_sl")},e.prototype.execute=function(){var t,n,r,i,o,u,a;if(null!=this.is_executed)return this;if(this.validateSavedOperations()){if((null!=(o=this.prev_cl)?o.validateSavedOperations():void 0)&&(null!=(u=this.next_cl)?u.validateSavedOperations():void 0)&&this.prev_cl.next_cl!==this){for(t=0,r=this.prev_cl.next_cl,n=0;;){if(null==r&&(console.log(JSON.stringify(this.prev_cl.getUid())),console.log(JSON.stringify(this.next_cl.getUid()))),r===this.next_cl)break;if(r.getDistanceToOrigin()===n)r.creator0)for(;;){if(e=e.next_cl,e.isDeleted()||(t-=1),0===t)break;if(e instanceof l.Delimiter){console.log("position parameter exceeded the length of the document!"),e=null;break}}return e},n}(l.Insert),u=function(e){function n(t,e,r,i,o,u,a){n.__super__.constructor.call(this,e,r,i,o,u,a),null!=t&&this.replace(t)}return i(n,e),n.prototype.replace=function(e){var n,r;return n=this.getLastOperation(),r=new a(e,this,void 0,n,n.next_cl),t.addOperation(r).execute()},n.prototype.val=function(){var t;if(t=this.getLastOperation(),t instanceof l.Delimiter)throw new Error("dtrn");return t.val()},n.prototype._encode=function(){var t;return t={type:"ReplaceManager",uid:this.getUid(),beginning:this.beginning.getUid(),end:this.end.getUid()},null!=this.prev_cl&&null!=this.next_cl&&(t.prev=this.prev_cl.getUid(),t.next=this.next_cl.getUid()),null!=this.origin&&this.origin!==this.prev_cl&&(t.origin=this.origin.getUid()),t},n}(r),c.ReplaceManager=function(t){var e,n,r,i,o,a,s;return n=t.content,s=t.uid,a=t.prev,i=t.next,o=t.origin,e=t.beginning,r=t.end,new u(n,s,e,r,a,i,o)},a=function(t){function e(t,n,r,i,o,u){if(this.saveOperation("content",t),this.saveOperation("parent",n),null==i||null==o||null==t)throw new Error("You must define content, prev, and next for Replaceable-types!");e.__super__.constructor.call(this,r,i,o,u)}return i(e,t),e.prototype.val=function(){return this.content},e.prototype.replace=function(t){return this.parent.replace(t)},e.prototype.execute=function(){var t;return this.validateSavedOperations()?("function"==typeof(t=this.content).setReplaceManager&&t.setReplaceManager(this.parent),e.__super__.execute.apply(this,arguments)):!1},e.prototype._encode=function(){var t;return t={type:"Replaceable",content:this.content.getUid(),ReplaceManager:this.parent.getUid(),prev:this.prev_cl.getUid(),next:this.next_cl.getUid(),uid:this.getUid()},null!=this.origin&&this.origin!==this.prev_cl&&(t.origin=this.origin.getUid()),t},e}(l.Insert),c.Replaceable=function(t){var e,n,r,i,o,u;return e=t.content,i=t.ReplaceManager,u=t.uid,o=t.prev,n=t.next,r=t.origin,new a(e,i,u,o,n,r)},l.ListManager=r,l.MapManager=o,l.ReplaceManager=u,l.Replaceable=a,s}},{"./BasicTypes":7}],10:[function(t,e){var n,r={}.hasOwnProperty,i=function(t,e){function n(){this.constructor=t}for(var i in e)r.call(e,i)&&(t[i]=e[i]);return n.prototype=e.prototype,t.prototype=new n,t.__super__=e.prototype,t};n=t("./StructuredTypes"),e.exports=function(t){var e,r,o,u,a,s;return a=n(t),s=a.types,u=a.parser,e=function(t){function e(){return e.__super__.constructor.apply(this,arguments)}return i(e,t),e}(s.Delete),u.TextDelete=u.Delete,r=function(t){function e(t,n,r,i,o){if(this.content=t,null==r||null==i)throw new Error("You must define prev, and next for TextInsert-types!");e.__super__.constructor.call(this,n,r,i,o)}return i(e,t),e.prototype.getLength=function(){return this.isDeleted()?0:this.content.length},e.prototype.val=function(){return this.isDeleted()?"":this.content},e.prototype._encode=function(){var t;return t={type:"TextInsert",content:this.content,uid:this.getUid(),prev:this.prev_cl.getUid(),next:this.next_cl.getUid()},null!=this.origin&&this.origin!==this.prev_cl&&(t.origin=this.origin.getUid()),t},e}(s.Insert),u.TextInsert=function(t){var e,n,i,o,u;return e=t.content,u=t.uid,o=t.prev,n=t.next,i=t.origin,new r(e,u,o,n,i)},o=function(n){function o(t,e,n,r,i,u){o.__super__.constructor.call(this,t,e,n,r,i,u)}return i(o,n),o.prototype.insertText=function(e,n){var i,o,u,a,s,c;for(o=this.getOperationByPosition(e),c=[],a=0,s=n.length;s>a;a++)i=n[a],u=new r(i,void 0,o.prev_cl,o),c.push(t.addOperation(u).execute());return c},o.prototype.deleteText=function(n,r){var i,o,u,a,c,l;for(a=this.getOperationByPosition(n),o=[],l=[],u=c=0;r>=0?r>c:c>r;u=r>=0?++c:--c){for(i=t.addOperation(new e(void 0,a)).execute(),a=a.next_cl;a.isDeleted()&&!(a instanceof s.Delimiter);){if(a instanceof s.Delimiter)throw new Error("You can't delete more than there is..");a=a.next_cl}if(o.push(i._encode()),a instanceof s.Delimiter)break;l.push(void 0)}return l},o.prototype.replaceText=function(e){var n;if(null!=this.replace_manager)return n=t.addOperation(new o(void 0)).execute(),n.insertText(0,e),this.replace_manager.replace(n);throw new Error("This type is currently not maintained by a ReplaceManager!")},o.prototype.val=function(){var t,e;return t=function(){var t,n,r,i;for(r=this.toArray(),i=[],t=0,n=r.length;n>t;t++)e=r[t],i.push(null!=e.val?e.val():"");return i}.call(this),t.join("")},o.prototype.setReplaceManager=function(t){return this.saveOperation("replace_manager",t),this.validateSavedOperations},o.prototype.bind=function(e){var n;return n=this,e.value=this.val(),this.on("insert",function(r,i){var o,u,a,s;return i.creator!==t.getUserId()?(a=i.getPosition(),o=function(t){return a>=t?t:t+=1},u=o(e.selectionStart),s=o(e.selectionEnd),e.value=n.val(),e.setSelectionRange(u,s)):void 0}),this.on("delete",function(t,r){var i,o,u,a;return u=r.getPosition(),i=function(t){return u>t?t:t-=1},o=i(e.selectionStart),a=i(e.selectionEnd),e.value=n.val(),e.setSelectionRange(o,a)}),e.onkeypress=function(t){var r,i,o;return r=String.fromCharCode(t.keyCode),r.length>0?(o=Math.min(e.selectionStart,e.selectionEnd),i=Math.abs(e.selectionEnd-e.selectionStart),n.deleteText(o,i),n.insertText(o,r)):t.preventDefault()},e.onkeydown=function(t){var r,i,o,u,a;if(u=Math.min(e.selectionStart,e.selectionEnd),i=Math.abs(e.selectionEnd-e.selectionStart),null!=t.keyCode&&8===t.keyCode){if(i>0)n.deleteText(u,i);else if(null!=t.ctrlKey&&t.ctrlKey){for(a=e.value,o=u,r=0,u>0&&(o--,r++);o>0&&" "!==a[o]&&"\n"!==a[o];)o--,r++;n.deleteText(o,u-o),e.setSelectionRange(o,o)}else n.deleteText(u-1,1);return t.preventDefault()}return null!=t.keyCode&&46===t.keyCode?(i>0?n.deleteText(u,i):n.deleteText(u,1),t.preventDefault()):void 0}},o.prototype._encode=function(){var t;return t={type:"Word",uid:this.getUid(),beginning:this.beginning.getUid(),end:this.end.getUid()},null!=this.prev_cl&&(t.prev=this.prev_cl.getUid()),null!=this.next_cl&&(t.next=this.next_cl.getUid()),null!=this.origin&&this.origin!==this.prev_cl&&(t.origin=this.origin.getUid()),t},o}(s.ListManager),u.Word=function(t){var e,n,r,i,u,a;return a=t.uid,e=t.beginning,n=t.end,u=t.prev,r=t.next,i=t.origin,new o(a,e,n,u,r,i)},s.TextInsert=r,s.TextDelete=e,s.Word=o,a}},{"./StructuredTypes":9}],11:[function(t,e,n){n.IwcConnector=t("./Connectors/IwcConnector"),n.TestConnector=t("./Connectors/TestConnector"),n.JsonYatta=t("./Frameworks/JsonYatta"),n.TextYatta=t("./Frameworks/TextYatta")},{"./Connectors/IwcConnector":1,"./Connectors/TestConnector":2,"./Frameworks/JsonYatta":4,"./Frameworks/TextYatta":5}],12:[function(t,e,n){(function(){var t=this,r=t._,i={},o=Array.prototype,u=Object.prototype,a=Function.prototype,s=o.push,c=o.slice,l=o.concat,p=u.toString,f=u.hasOwnProperty,h=o.forEach,d=o.map,v=o.reduce,_=o.reduceRight,g=o.filter,y=o.every,m=o.some,x=o.indexOf,b=o.lastIndexOf,w=Array.isArray,O=Object.keys,T=a.bind,U=function(t){return t instanceof U?t:this instanceof U?void(this._wrapped=t):new U(t)};"undefined"!=typeof n?("undefined"!=typeof e&&e.exports&&(n=e.exports=U),n._=U):t._=U,U.VERSION="1.6.0";var B=U.each=U.forEach=function(t,e,n){if(null==t)return t;if(h&&t.forEach===h)t.forEach(e,n);else if(t.length===+t.length){for(var r=0,o=t.length;o>r;r++)if(e.call(n,t[r],r,t)===i)return}else for(var u=U.keys(t),r=0,o=u.length;o>r;r++)if(e.call(n,t[u[r]],u[r],t)===i)return;return t};U.map=U.collect=function(t,e,n){var r=[];return null==t?r:d&&t.map===d?t.map(e,n):(B(t,function(t,i,o){r.push(e.call(n,t,i,o))}),r)};var I="Reduce of empty array with no initial value";U.reduce=U.foldl=U.inject=function(t,e,n,r){var i=arguments.length>2;if(null==t&&(t=[]),v&&t.reduce===v)return r&&(e=U.bind(e,r)),i?t.reduce(e,n):t.reduce(e);if(B(t,function(t,o,u){i?n=e.call(r,n,t,o,u):(n=t,i=!0)}),!i)throw new TypeError(I);return n},U.reduceRight=U.foldr=function(t,e,n,r){var i=arguments.length>2;if(null==t&&(t=[]),_&&t.reduceRight===_)return r&&(e=U.bind(e,r)),i?t.reduceRight(e,n):t.reduceRight(e);var o=t.length;if(o!==+o){var u=U.keys(t);o=u.length}if(B(t,function(a,s,c){s=u?u[--o]:--o,i?n=e.call(r,n,t[s],s,c):(n=t[s],i=!0)}),!i)throw new TypeError(I);return n},U.find=U.detect=function(t,e,n){var r;return E(t,function(t,i,o){return e.call(n,t,i,o)?(r=t,!0):void 0}),r},U.filter=U.select=function(t,e,n){var r=[];return null==t?r:g&&t.filter===g?t.filter(e,n):(B(t,function(t,i,o){e.call(n,t,i,o)&&r.push(t)}),r)},U.reject=function(t,e,n){return U.filter(t,function(t,r,i){return!e.call(n,t,r,i)},n)},U.every=U.all=function(t,e,n){e||(e=U.identity);var r=!0;return null==t?r:y&&t.every===y?t.every(e,n):(B(t,function(t,o,u){return(r=r&&e.call(n,t,o,u))?void 0:i}),!!r)};var E=U.some=U.any=function(t,e,n){e||(e=U.identity);var r=!1;return null==t?r:m&&t.some===m?t.some(e,n):(B(t,function(t,o,u){return r||(r=e.call(n,t,o,u))?i:void 0}),!!r)};U.contains=U.include=function(t,e){return null==t?!1:x&&t.indexOf===x?-1!=t.indexOf(e):E(t,function(t){return t===e})},U.invoke=function(t,e){var n=c.call(arguments,2),r=U.isFunction(e);return U.map(t,function(t){return(r?e:t[e]).apply(t,n)})},U.pluck=function(t,e){return U.map(t,U.property(e))},U.where=function(t,e){return U.filter(t,U.matches(e))},U.findWhere=function(t,e){return U.find(t,U.matches(e))},U.max=function(t,e,n){if(!e&&U.isArray(t)&&t[0]===+t[0]&&t.length<65535)return Math.max.apply(Math,t);var r=-1/0,i=-1/0;return B(t,function(t,o,u){var a=e?e.call(n,t,o,u):t;a>i&&(r=t,i=a)}),r},U.min=function(t,e,n){if(!e&&U.isArray(t)&&t[0]===+t[0]&&t.length<65535)return Math.min.apply(Math,t);var r=1/0,i=1/0;return B(t,function(t,o,u){var a=e?e.call(n,t,o,u):t;i>a&&(r=t,i=a)}),r},U.shuffle=function(t){var e,n=0,r=[];return B(t,function(t){e=U.random(n++),r[n-1]=r[e],r[e]=t}),r},U.sample=function(t,e,n){return null==e||n?(t.length!==+t.length&&(t=U.values(t)),t[U.random(t.length-1)]):U.shuffle(t).slice(0,Math.max(0,e))};var j=function(t){return null==t?U.identity:U.isFunction(t)?t:U.property(t)};U.sortBy=function(t,e,n){return e=j(e),U.pluck(U.map(t,function(t,r,i){return{value:t,index:r,criteria:e.call(n,t,r,i)}}).sort(function(t,e){var n=t.criteria,r=e.criteria;if(n!==r){if(n>r||void 0===n)return 1;if(r>n||void 0===r)return-1}return t.index-e.index}),"value")};var k=function(t){return function(e,n,r){var i={};return n=j(n),B(e,function(o,u){var a=n.call(r,o,u,e);t(i,a,o)}),i}};U.groupBy=k(function(t,e,n){U.has(t,e)?t[e].push(n):t[e]=[n]}),U.indexBy=k(function(t,e,n){t[e]=n}),U.countBy=k(function(t,e){U.has(t,e)?t[e]++:t[e]=1}),U.sortedIndex=function(t,e,n,r){n=j(n);for(var i=n.call(r,e),o=0,u=t.length;u>o;){var a=o+u>>>1;n.call(r,t[a])e?[]:c.call(t,0,e)},U.initial=function(t,e,n){return c.call(t,0,t.length-(null==e||n?1:e))},U.last=function(t,e,n){return null==t?void 0:null==e||n?t[t.length-1]:c.call(t,Math.max(t.length-e,0))},U.rest=U.tail=U.drop=function(t,e,n){return c.call(t,null==e||n?1:e)},U.compact=function(t){return U.filter(t,U.identity)};var D=function(t,e,n){return e&&U.every(t,U.isArray)?l.apply(n,t):(B(t,function(t){U.isArray(t)||U.isArguments(t)?e?s.apply(n,t):D(t,e,n):n.push(t)}),n)};U.flatten=function(t,e){return D(t,e,[])},U.without=function(t){return U.difference(t,c.call(arguments,1))},U.partition=function(t,e){var n=[],r=[];return B(t,function(t){(e(t)?n:r).push(t)}),[n,r]},U.uniq=U.unique=function(t,e,n,r){U.isFunction(e)&&(r=n,n=e,e=!1); +var i=n?U.map(t,n,r):t,o=[],u=[];return B(i,function(n,r){(e?r&&u[u.length-1]===n:U.contains(u,n))||(u.push(n),o.push(t[r]))}),o},U.union=function(){return U.uniq(U.flatten(arguments,!0))},U.intersection=function(t){var e=c.call(arguments,1);return U.filter(U.uniq(t),function(t){return U.every(e,function(e){return U.contains(e,t)})})},U.difference=function(t){var e=l.apply(o,c.call(arguments,1));return U.filter(t,function(t){return!U.contains(e,t)})},U.zip=function(){for(var t=U.max(U.pluck(arguments,"length").concat(0)),e=new Array(t),n=0;t>n;n++)e[n]=U.pluck(arguments,""+n);return e},U.object=function(t,e){if(null==t)return{};for(var n={},r=0,i=t.length;i>r;r++)e?n[t[r]]=e[r]:n[t[r][0]]=t[r][1];return n},U.indexOf=function(t,e,n){if(null==t)return-1;var r=0,i=t.length;if(n){if("number"!=typeof n)return r=U.sortedIndex(t,e),t[r]===e?r:-1;r=0>n?Math.max(0,i+n):n}if(x&&t.indexOf===x)return t.indexOf(e,n);for(;i>r;r++)if(t[r]===e)return r;return-1},U.lastIndexOf=function(t,e,n){if(null==t)return-1;var r=null!=n;if(b&&t.lastIndexOf===b)return r?t.lastIndexOf(e,n):t.lastIndexOf(e);for(var i=r?n:t.length;i--;)if(t[i]===e)return i;return-1},U.range=function(t,e,n){arguments.length<=1&&(e=t||0,t=0),n=arguments[2]||1;for(var r=Math.max(Math.ceil((e-t)/n),0),i=0,o=new Array(r);r>i;)o[i++]=t,t+=n;return o};var H=function(){};U.bind=function(t,e){var n,r;if(T&&t.bind===T)return T.apply(t,c.call(arguments,1));if(!U.isFunction(t))throw new TypeError;return n=c.call(arguments,2),r=function(){if(!(this instanceof r))return t.apply(e,n.concat(c.call(arguments)));H.prototype=t.prototype;var i=new H;H.prototype=null;var o=t.apply(i,n.concat(c.call(arguments)));return Object(o)===o?o:i}},U.partial=function(t){var e=c.call(arguments,1);return function(){for(var n=0,r=e.slice(),i=0,o=r.length;o>i;i++)r[i]===U&&(r[i]=arguments[n++]);for(;n=l?(clearTimeout(u),u=null,a=c,o=t.apply(r,i),r=i=null):u||n.trailing===!1||(u=setTimeout(s,l)),o}},U.debounce=function(t,e,n){var r,i,o,u,a,s=function(){var c=U.now()-u;e>c?r=setTimeout(s,e-c):(r=null,n||(a=t.apply(o,i),o=i=null))};return function(){o=this,i=arguments,u=U.now();var c=n&&!r;return r||(r=setTimeout(s,e)),c&&(a=t.apply(o,i),o=i=null),a}},U.once=function(t){var e,n=!1;return function(){return n?e:(n=!0,e=t.apply(this,arguments),t=null,e)}},U.wrap=function(t,e){return U.partial(e,t)},U.compose=function(){var t=arguments;return function(){for(var e=arguments,n=t.length-1;n>=0;n--)e=[t[n].apply(this,e)];return e[0]}},U.after=function(t,e){return function(){return--t<1?e.apply(this,arguments):void 0}},U.keys=function(t){if(!U.isObject(t))return[];if(O)return O(t);var e=[];for(var n in t)U.has(t,n)&&e.push(n);return e},U.values=function(t){for(var e=U.keys(t),n=e.length,r=new Array(n),i=0;n>i;i++)r[i]=t[e[i]];return r},U.pairs=function(t){for(var e=U.keys(t),n=e.length,r=new Array(n),i=0;n>i;i++)r[i]=[e[i],t[e[i]]];return r},U.invert=function(t){for(var e={},n=U.keys(t),r=0,i=n.length;i>r;r++)e[t[n[r]]]=n[r];return e},U.functions=U.methods=function(t){var e=[];for(var n in t)U.isFunction(t[n])&&e.push(n);return e.sort()},U.extend=function(t){return B(c.call(arguments,1),function(e){if(e)for(var n in e)t[n]=e[n]}),t},U.pick=function(t){var e={},n=l.apply(o,c.call(arguments,1));return B(n,function(n){n in t&&(e[n]=t[n])}),e},U.omit=function(t){var e={},n=l.apply(o,c.call(arguments,1));for(var r in t)U.contains(n,r)||(e[r]=t[r]);return e},U.defaults=function(t){return B(c.call(arguments,1),function(e){if(e)for(var n in e)void 0===t[n]&&(t[n]=e[n])}),t},U.clone=function(t){return U.isObject(t)?U.isArray(t)?t.slice():U.extend({},t):t},U.tap=function(t,e){return e(t),t};var M=function(t,e,n,r){if(t===e)return 0!==t||1/t==1/e;if(null==t||null==e)return t===e;t instanceof U&&(t=t._wrapped),e instanceof U&&(e=e._wrapped);var i=p.call(t);if(i!=p.call(e))return!1;switch(i){case"[object String]":return t==String(e);case"[object Number]":return t!=+t?e!=+e:0==t?1/t==1/e:t==+e;case"[object Date]":case"[object Boolean]":return+t==+e;case"[object RegExp]":return t.source==e.source&&t.global==e.global&&t.multiline==e.multiline&&t.ignoreCase==e.ignoreCase}if("object"!=typeof t||"object"!=typeof e)return!1;for(var o=n.length;o--;)if(n[o]==t)return r[o]==e;var u=t.constructor,a=e.constructor;if(u!==a&&!(U.isFunction(u)&&u instanceof u&&U.isFunction(a)&&a instanceof a)&&"constructor"in t&&"constructor"in e)return!1;n.push(t),r.push(e);var s=0,c=!0;if("[object Array]"==i){if(s=t.length,c=s==e.length)for(;s--&&(c=M(t[s],e[s],n,r)););}else{for(var l in t)if(U.has(t,l)&&(s++,!(c=U.has(e,l)&&M(t[l],e[l],n,r))))break;if(c){for(l in e)if(U.has(e,l)&&!s--)break;c=!s}}return n.pop(),r.pop(),c};U.isEqual=function(t,e){return M(t,e,[],[])},U.isEmpty=function(t){if(null==t)return!0;if(U.isArray(t)||U.isString(t))return 0===t.length;for(var e in t)if(U.has(t,e))return!1;return!0},U.isElement=function(t){return!(!t||1!==t.nodeType)},U.isArray=w||function(t){return"[object Array]"==p.call(t)},U.isObject=function(t){return t===Object(t)},B(["Arguments","Function","String","Number","Date","RegExp"],function(t){U["is"+t]=function(e){return p.call(e)=="[object "+t+"]"}}),U.isArguments(arguments)||(U.isArguments=function(t){return!(!t||!U.has(t,"callee"))}),"function"!=typeof/./&&(U.isFunction=function(t){return"function"==typeof t}),U.isFinite=function(t){return isFinite(t)&&!isNaN(parseFloat(t))},U.isNaN=function(t){return U.isNumber(t)&&t!=+t},U.isBoolean=function(t){return t===!0||t===!1||"[object Boolean]"==p.call(t)},U.isNull=function(t){return null===t},U.isUndefined=function(t){return void 0===t},U.has=function(t,e){return f.call(t,e)},U.noConflict=function(){return t._=r,this},U.identity=function(t){return t},U.constant=function(t){return function(){return t}},U.property=function(t){return function(e){return e[t]}},U.matches=function(t){return function(e){if(e===t)return!0;for(var n in t)if(t[n]!==e[n])return!1;return!0}},U.times=function(t,e,n){for(var r=Array(Math.max(0,t)),i=0;t>i;i++)r[i]=e.call(n,i);return r},U.random=function(t,e){return null==e&&(e=t,t=0),t+Math.floor(Math.random()*(e-t+1))},U.now=Date.now||function(){return(new Date).getTime()};var S={escape:{"&":"&","<":"<",">":">",'"':""","'":"'"}};S.unescape=U.invert(S.escape);var R={escape:new RegExp("["+U.keys(S.escape).join("")+"]","g"),unescape:new RegExp("("+U.keys(S.unescape).join("|")+")","g")};U.each(["escape","unescape"],function(t){U[t]=function(e){return null==e?"":(""+e).replace(R[t],function(e){return S[t][e]})}}),U.result=function(t,e){if(null==t)return void 0;var n=t[e];return U.isFunction(n)?n.call(t):n},U.mixin=function(t){B(U.functions(t),function(e){var n=U[e]=t[e];U.prototype[e]=function(){var t=[this._wrapped];return s.apply(t,arguments),F.call(this,n.apply(U,t))}})};var C=0;U.uniqueId=function(t){var e=++C+"";return t?t+e:e},U.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var A=/(.)^/,Y={"'":"'","\\":"\\","\r":"r","\n":"n"," ":"t","\u2028":"u2028","\u2029":"u2029"},P=/\\|'|\r|\n|\t|\u2028|\u2029/g;U.template=function(t,e,n){var r;n=U.defaults({},n,U.templateSettings);var i=new RegExp([(n.escape||A).source,(n.interpolate||A).source,(n.evaluate||A).source].join("|")+"|$","g"),o=0,u="__p+='";t.replace(i,function(e,n,r,i,a){return u+=t.slice(o,a).replace(P,function(t){return"\\"+Y[t]}),n&&(u+="'+\n((__t=("+n+"))==null?'':_.escape(__t))+\n'"),r&&(u+="'+\n((__t=("+r+"))==null?'':__t)+\n'"),i&&(u+="';\n"+i+"\n__p+='"),o=a+e.length,e}),u+="';\n",n.variable||(u="with(obj||{}){\n"+u+"}\n"),u="var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\n"+u+"return __p;\n";try{r=new Function(n.variable||"obj","_",u)}catch(a){throw a.source=u,a}if(e)return r(e,U);var s=function(t){return r.call(this,t,U)};return s.source="function("+(n.variable||"obj")+"){\n"+u+"}",s},U.chain=function(t){return U(t).chain()};var F=function(t){return this._chain?U(t).chain():t};U.mixin(U),B(["pop","push","reverse","shift","sort","splice","unshift"],function(t){var e=o[t];U.prototype[t]=function(){var n=this._wrapped;return e.apply(n,arguments),"shift"!=t&&"splice"!=t||0!==n.length||delete n[0],F.call(this,n)}}),B(["concat","join","slice"],function(t){var e=o[t];U.prototype[t]=function(){return F.call(this,e.apply(this._wrapped,arguments))}}),U.extend(U.prototype,{chain:function(){return this._chain=!0,this},value:function(){return this._wrapped}}),"function"==typeof define&&define.amd&&define("underscore",[],function(){return U})}).call(this)},{}]},{},[11]); \ No newline at end of file diff --git a/build/node/Engine.js b/build/node/Engine.js new file mode 100644 index 00000000..2a63e3a4 --- /dev/null +++ b/build/node/Engine.js @@ -0,0 +1,2 @@ +(function(){var t;t=function(){function t(t,e){this.HB=t,this.parser=e,this.unprocessed_ops=[]}return t.prototype.parseOperation=function(t){var e;if(e=this.parser[t.type],null!=e)return e(t);throw new Error("You forgot to specify a parser for type "+t.type+". The message is "+JSON.stringify(t)+".")},t.prototype.applyOpsBundle=function(t){var e,r,p,s,o,n,i,u;for(r=[],p=0,n=t.length;n>p;p++)e=t[p],r.push(this.parseOperation(e));for(s=0,i=r.length;i>s;s++)e=r[s],this.HB.addOperation(e);for(o=0,u=r.length;u>o;o++)e=r[o],e.execute()||this.unprocessed_ops.push(e);return this.tryUnprocessed()},t.prototype.applyOpsCheckDouble=function(t){var e,r,p,s;for(s=[],r=0,p=t.length;p>r;r++)e=t[r],s.push(null==this.HB.getOperation(e.uid)?this.applyOp(e):void 0);return s},t.prototype.applyOps=function(t){var e,r,p,s;for(s=[],r=0,p=t.length;p>r;r++)e=t[r],s.push(this.applyOp(e));return s},t.prototype.applyOp=function(t){var e;return e=this.parseOperation(t),this.HB.addToCounter(e),e.execute()?this.HB.addOperation(e):this.unprocessed_ops.push(e),this.tryUnprocessed()},t.prototype.tryUnprocessed=function(){var t,e,r,p,s,o,n;for(n=[];;){for(t=this.unprocessed_ops.length,r=[],o=this.unprocessed_ops,p=0,s=o.length;s>p;p++)e=o[p],e.execute()?this.HB.addOperation(e):r.push(e);if(this.unprocessed_ops=r,this.unprocessed_ops.length===t)break;n.push(void 0)}return n},t}(),module.exports=t}).call(this); +//# sourceMappingURL=Engine.js.map \ No newline at end of file diff --git a/build/node/Engine.js.map b/build/node/Engine.js.map new file mode 100755 index 00000000..c9a1ff30 --- /dev/null +++ b/build/node/Engine.js.map @@ -0,0 +1 @@ +{"version":3,"file":"Engine.js","sources":["Engine.coffee"],"names":[],"mappings":"CAIA,WAAA,GAAA,EAAM,GAAA,WAMS,QAAA,GAAE,EAAK,GAAN,KAAC,GAAA,EAAI,KAAC,OAAA,EAClB,KAAC,yBADH,GAAA,UAMA,eAAgB,SAAC,GACf,GAAA,EACA,IADA,EAAa,KAAC,OAAO,EAAK,MACvB,MAAA,QACD,GAAW,EAEX,MAAU,IAAA,OAAO,2CAAyC,EAAK,KAAM,oBAAkB,KAAK,UAAU,GAAM,MAXhH,EAAA,UAiBA,eAAgB,SAAC,GACf,GAAA,GAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,CACA,KADA,KACA,EAAA,EAAA,EAAA,EAAA,OAAA,EAAA,EAAA,WACE,EAAI,KAAK,KAAC,eAAe,GAC3B,KAAA,EAAA,EAAA,EAAA,EAAA,OAAA,EAAA,EAAA,WACE,KAAC,GAAG,aAAa,EACnB,KAAA,EAAA,EAAA,EAAA,EAAA,OAAA,EAAA,EAAA,WACK,EAAM,WACP,KAAC,gBAAgB,KAAK,SAC1B,MAAC,kBA1BH,EAAA,UAgCA,oBAAqB,SAAC,GACpB,GAAA,GAAA,EAAA,EAAA,MAAA,KAAA,EAAA,EAAA,EAAA,EAAA,OAAA,EAAA,EAAA,kBACS,MAAA,KAAA,GAAA,aAAA,EAAA,KACL,KAAC,QAAQ,qBAnCf,EAAA,UAwCA,SAAU,SAAC,GACT,GAAA,GAAA,EAAA,EAAA,MAAA,KAAA,EAAA,EAAA,EAAA,EAAA,OAAA,EAAA,EAAA,WACE,EAAA,KAAA,KAAC,QAAQ,cA1Cb,EAAA,UA+CA,QAAS,SAAC,GAER,GAAA,SAAA,GAAI,KAAC,eAAe,GACpB,KAAC,GAAG,aAAa,GAEd,EAAM,UAGP,KAAC,GAAG,aAAa,GAFjB,KAAC,gBAAgB,KAAK,GAGxB,KAAC,kBAxDH,EAAA,UA8DA,eAAgB,WACd,GAAA,GAAA,EAAA,EAAA,EAAA,EAAA,EAAA,MAAA,OAAA,CAGE,IAFA,EAAa,KAAC,gBAAgB,OAC9B,KACA,EAAA,KAAA,gBAAA,EAAA,EAAA,EAAA,EAAA,OAAA,EAAA,EAAA,WACK,EAAO,UAGR,KAAC,GAAG,aAAa,GAFjB,EAAY,KAAK,EAIrB,IADA,KAAC,gBAAkB,EAChB,KAAC,gBAAgB,SAAU,EAC5B,oCAKR,OAAO,QAAU","sourcesContent":["\r\n#\r\n# The Engine handles how and in which order to execute operations and add operations to the HistoryBuffer.\r\n#\r\nclass Engine\r\n\r\n #\r\n # @param {HistoryBuffer} HB\r\n # @param {Array} parser Defines how to parse encoded messages.\r\n #\r\n constructor: (@HB, @parser)->\r\n @unprocessed_ops = []\r\n\r\n #\r\n # Parses an operatio from the json format. It uses the specified parser in your OperationType module.\r\n #\r\n parseOperation: (json)->\r\n typeParser = @parser[json.type]\r\n if typeParser?\r\n typeParser json\r\n else\r\n throw new Error \"You forgot to specify a parser for type #{json.type}. The message is #{JSON.stringify json}.\"\r\n\r\n #\r\n # Apply a set of operations. E.g. the operations you received from another users HB.toJson().\r\n # @note You must not use this method when you already have ops in your HB!\r\n #\r\n applyOpsBundle: (ops_json)->\r\n ops = []\r\n for o in ops_json\r\n ops.push @parseOperation o\r\n for o in ops\r\n @HB.addOperation o\r\n for o in ops\r\n if not o.execute()\r\n @unprocessed_ops.push o\r\n @tryUnprocessed()\r\n\r\n #\r\n # Same as applyOps but operations that are already in the HB are not applied.\r\n # @see Engine.applyOps\r\n #\r\n applyOpsCheckDouble: (ops_json)->\r\n for o in ops_json\r\n if not @HB.getOperation(o.uid)?\r\n @applyOp o\r\n\r\n #\r\n # Apply a set of operations. (Helper for using applyOp on Arrays)\r\n # @see Engine.applyOp\r\n applyOps: (ops_json)->\r\n for o in ops_json\r\n @applyOp o\r\n\r\n #\r\n # Apply an operation that you received from another peer.\r\n #\r\n applyOp: (op_json)->\r\n # $parse_and_execute will return false if $o_json was parsed and executed, otherwise the parsed operadion\r\n o = @parseOperation op_json\r\n @HB.addToCounter o\r\n # @HB.addOperation o\r\n if not o.execute()\r\n @unprocessed_ops.push o\r\n else\r\n @HB.addOperation o\r\n @tryUnprocessed()\r\n\r\n #\r\n # Call this method when you applied a new operation.\r\n # It checks if operations that were previously not executable are now executable.\r\n #\r\n tryUnprocessed: ()->\r\n while true\r\n old_length = @unprocessed_ops.length\r\n unprocessed = []\r\n for op in @unprocessed_ops\r\n if not op.execute()\r\n unprocessed.push op\r\n else\r\n @HB.addOperation op\r\n @unprocessed_ops = unprocessed\r\n if @unprocessed_ops.length is old_length\r\n break\r\n\r\n\r\n\r\n\r\nmodule.exports = Engine\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n"],"sourceRoot":"/source/"} \ No newline at end of file diff --git a/build/node/Frameworks/TextYatta.js b/build/node/Frameworks/TextYatta.js index 28ac3830..ae443fc4 100644 --- a/build/node/Frameworks/TextYatta.js +++ b/build/node/Frameworks/TextYatta.js @@ -1,2 +1,2 @@ -(function(){var e,t,n,o;o=require("../Types/TextTypes"),t=require("../HistoryBuffer"),e=require("../Engine"),n=function(){function n(n,r){var i,u;this.HB=new t(n),u=o(this.HB),this.engine=new e(this.HB,u.parser),this.connector=new r(this.engine,this.HB,u.execution_listener,this),i=new u.types.Word({creator:"_",op_number:"_"}),this.HB.addOperation(i).execute(),this.root_element=i}return n.prototype.getRootElement=function(){return this.root_element},n.prototype.getEngine=function(){return this.engine},n.prototype.getConnector=function(){return this.connector},n.prototype.getHistoryBuffer=function(){return this.HB},n.prototype.getUserId=function(){return this.HB.getUserId()},n.prototype.val=function(){return this.root_element.val()},n.prototype.insertText=function(e,t){return this.root_element.insertText(e,t)},n.prototype.deleteText=function(e,t){return this.root_element.deleteText(e,t)},n.prototype.bind=function(e){return this.root_element.bind(e)},n.prototype.replaceText=function(e){return this.root_element.replaceText(e)},n}(),module.exports=n,"undefined"!=typeof window&&null!==window&&(null==window.Y&&(window.Y={}),window.Y.TextYatta=n)}).call(this); +(function(){var e,t,n,o;o=require("../Types/TextTypes"),t=require("../HistoryBuffer"),e=require("../Engine"),n=function(){function n(n,r){var i,u,s,p,c;this.HB=new t(n),p=o(this.HB),c=p.types,this.engine=new e(this.HB,p.parser),this.connector=new r(this.engine,this.HB,p.execution_listener,this),i=this.HB.addOperation(new c.Delimiter({creator:"_",op_number:"_beginning"},void 0,void 0)),u=this.HB.addOperation(new c.Delimiter({creator:"_",op_number:"_end"},i,void 0)),i.next_cl=u,i.execute(),u.execute(),s=new p.types.Word({creator:"_",op_number:"_"},i,u),this.HB.addOperation(s).execute(),this.root_element=s}return n.prototype.getRootElement=function(){return this.root_element},n.prototype.getEngine=function(){return this.engine},n.prototype.getConnector=function(){return this.connector},n.prototype.getHistoryBuffer=function(){return this.HB},n.prototype.getUserId=function(){return this.HB.getUserId()},n.prototype.val=function(){return this.root_element.val()},n.prototype.insertText=function(e,t){return this.root_element.insertText(e,t)},n.prototype.deleteText=function(e,t){return this.root_element.deleteText(e,t)},n.prototype.bind=function(e){return this.root_element.bind(e)},n.prototype.replaceText=function(e){return this.root_element.replaceText(e)},n}(),module.exports=n,"undefined"!=typeof window&&null!==window&&(null==window.Y&&(window.Y={}),window.Y.TextYatta=n)}).call(this); //# sourceMappingURL=../Frameworks/TextYatta.js.map \ No newline at end of file diff --git a/build/node/Frameworks/TextYatta.js.map b/build/node/Frameworks/TextYatta.js.map index 58ff76e0..0f0c9bfc 100755 --- a/build/node/Frameworks/TextYatta.js.map +++ b/build/node/Frameworks/TextYatta.js.map @@ -1 +1 @@ -{"version":3,"file":"Frameworks/TextYatta.js","sources":["Frameworks/TextYatta.coffee"],"names":[],"mappings":"CACA,WAAA,GAAA,GAAA,EAAA,EAAA,CAAA,GAA2B,QAAQ,sBACnC,EAAgB,QAAQ,oBACxB,EAAS,QAAQ,aAKX,EAAA,WAMS,QAAA,GAAC,EAAS,GACrB,GAAA,GAAA,CAAA,MAAC,GAAS,GAAA,GAAc,GACxB,EAAa,EAAyB,KAAC,IACvC,KAAC,OAAa,GAAA,GAAO,KAAC,GAAI,EAAW,QACrC,KAAC,UAAgB,GAAA,GAAU,KAAC,OAAQ,KAAC,GAAI,EAAW,mBAAoB,MAExE,EAAiB,GAAA,GAAW,MAAM,MAAM,QAAS,IAAK,UAAW,MACjE,KAAC,GAAG,aAAa,GAAY,UAC7B,KAAC,aAAe,QARlB,GAAA,UAaA,eAAgB,iBACd,MAAC,cAdH,EAAA,UAmBA,UAAW,iBACT,MAAC,QApBH,EAAA,UAyBA,aAAc,iBACZ,MAAC,WA1BH,EAAA,UA+BA,iBAAkB,iBAChB,MAAC,IAhCH,EAAA,UAuCA,UAAW,iBACT,MAAC,GAAG,aAxCN,EAAA,UA6CA,IAAK,iBACH,MAAC,aAAa,OA9ChB,EAAA,UAmDA,WAAY,SAAC,EAAK,SAChB,MAAC,aAAa,WAAW,EAAK,IApDhC,EAAA,UAyDA,WAAY,SAAC,EAAK,SAChB,MAAC,aAAa,WAAW,EAAK,IA1DhC,EAAA,UA+DA,KAAM,SAAC,SACL,MAAC,aAAa,KAAK,IAhErB,EAAA,UAqEA,YAAa,SAAC,SACZ,MAAC,aAAa,YAAY,SAG9B,OAAO,QAAU,EACd,mBAAA,SAAA,OAAA,SACM,MAAA,OAAA,IACL,OAAO,MACT,OAAO,EAAE,UAAY","sourcesContent":["\ntext_types_uninitialized = require \"../Types/TextTypes\"\nHistoryBuffer = require \"../HistoryBuffer\"\nEngine = require \"../Engine\"\n\n#\n# Framework for Text Datastructures.\n#\nclass TextYatta\n\n #\n # @param {String} user_id Uniqe user id that defines this peer.\n # @param {Connector} Connector The connector defines how you connect to the other peers.\n #\n constructor: (user_id, Connector)->\n @HB = new HistoryBuffer user_id\n text_types = text_types_uninitialized @HB\n @engine = new Engine @HB, text_types.parser\n @connector = new Connector @engine, @HB, text_types.execution_listener, @\n\n first_word = new text_types.types.Word {creator: '_', op_number: '_'}\n @HB.addOperation(first_word).execute()\n @root_element = first_word\n\n #\n # @result Word\n #\n getRootElement: ()->\n @root_element\n\n #\n # @see Engine\n #\n getEngine: ()->\n @engine\n\n #\n # Get the initialized connector.\n #\n getConnector: ()->\n @connector\n\n #\n # @see HistoryBuffer\n #\n getHistoryBuffer: ()->\n @HB\n\n #\n # Get the UserId from the HistoryBuffer object.\n # In most cases this will be the same as the user_id value with which\n # JsonYatta was initialized (Depending on the HistoryBuffer implementation).\n #\n getUserId: ()->\n @HB.getUserId()\n\n #\n # @see JsonType.val\n #\n val: ()->\n @root_element.val()\n\n #\n # @see Word.insertText\n #\n insertText: (pos, content)->\n @root_element.insertText pos, content\n\n #\n # @see Word.deleteText\n #\n deleteText: (pos, length)->\n @root_element.deleteText pos, length\n\n #\n # @see Word.bind\n #\n bind: (textarea)->\n @root_element.bind textarea\n\n #\n # @see Word.replaceText\n #\n replaceText: (text)->\n @root_element.replaceText text\n\n\nmodule.exports = TextYatta\nif window?\n if not window.Y?\n window.Y = {}\n window.Y.TextYatta = TextYatta\n"],"sourceRoot":"/source/"} \ No newline at end of file +{"version":3,"file":"Frameworks/TextYatta.js","sources":["Frameworks/TextYatta.coffee"],"names":[],"mappings":"CACA,WAAA,GAAA,GAAA,EAAA,EAAA,CAAA,GAA2B,QAAQ,sBACnC,EAAgB,QAAQ,oBACxB,EAAS,QAAQ,aAKX,EAAA,WAMS,QAAA,GAAC,EAAS,GACrB,GAAA,GAAA,EAAA,EAAA,EAAA,CAAA,MAAC,GAAS,GAAA,GAAc,GACxB,EAAa,EAAyB,KAAC,IACvC,EAAQ,EAAW,MACnB,KAAC,OAAa,GAAA,GAAO,KAAC,GAAI,EAAW,QACrC,KAAC,UAAgB,GAAA,GAAU,KAAC,OAAQ,KAAC,GAAI,EAAW,mBAAoB,MAExE,EAAY,KAAC,GAAG,aAAiB,GAAA,GAAM,WAAW,QAAS,IAAK,UAAW,cAAgB,OAAW,SACtG,EAAY,KAAC,GAAG,aAAiB,GAAA,GAAM,WAAW,QAAS,IAAK,UAAW,QAAgB,EAAW,SACtG,EAAU,QAAU,EACpB,EAAU,UACV,EAAI,UACJ,EAAiB,GAAA,GAAW,MAAM,MAAM,QAAS,IAAK,UAAW,KAAM,EAAW,GAClF,KAAC,GAAG,aAAa,GAAY,UAC7B,KAAC,aAAe,QAdlB,GAAA,UAmBA,eAAgB,iBACd,MAAC,cApBH,EAAA,UAyBA,UAAW,iBACT,MAAC,QA1BH,EAAA,UA+BA,aAAc,iBACZ,MAAC,WAhCH,EAAA,UAqCA,iBAAkB,iBAChB,MAAC,IAtCH,EAAA,UA6CA,UAAW,iBACT,MAAC,GAAG,aA9CN,EAAA,UAmDA,IAAK,iBACH,MAAC,aAAa,OApDhB,EAAA,UAyDA,WAAY,SAAC,EAAK,SAChB,MAAC,aAAa,WAAW,EAAK,IA1DhC,EAAA,UA+DA,WAAY,SAAC,EAAK,SAChB,MAAC,aAAa,WAAW,EAAK,IAhEhC,EAAA,UAqEA,KAAM,SAAC,SACL,MAAC,aAAa,KAAK,IAtErB,EAAA,UA2EA,YAAa,SAAC,SACZ,MAAC,aAAa,YAAY,SAG9B,OAAO,QAAU,EACd,mBAAA,SAAA,OAAA,SACM,MAAA,OAAA,IACL,OAAO,MACT,OAAO,EAAE,UAAY","sourcesContent":["\ntext_types_uninitialized = require \"../Types/TextTypes\"\nHistoryBuffer = require \"../HistoryBuffer\"\nEngine = require \"../Engine\"\n\n#\n# Framework for Text Datastructures.\n#\nclass TextYatta\n\n #\n # @param {String} user_id Uniqe user id that defines this peer.\n # @param {Connector} Connector The connector defines how you connect to the other peers.\n #\n constructor: (user_id, Connector)->\n @HB = new HistoryBuffer user_id\n text_types = text_types_uninitialized @HB\n types = text_types.types\n @engine = new Engine @HB, text_types.parser\n @connector = new Connector @engine, @HB, text_types.execution_listener, @\n\n beginning = @HB.addOperation new types.Delimiter {creator: '_', op_number: '_beginning'} , undefined, undefined\n end = @HB.addOperation new types.Delimiter {creator: '_', op_number: '_end'} , beginning, undefined\n beginning.next_cl = end\n beginning.execute()\n end.execute()\n first_word = new text_types.types.Word {creator: '_', op_number: '_'}, beginning, end\n @HB.addOperation(first_word).execute()\n @root_element = first_word\n\n #\n # @result Word\n #\n getRootElement: ()->\n @root_element\n\n #\n # @see Engine\n #\n getEngine: ()->\n @engine\n\n #\n # Get the initialized connector.\n #\n getConnector: ()->\n @connector\n\n #\n # @see HistoryBuffer\n #\n getHistoryBuffer: ()->\n @HB\n\n #\n # Get the UserId from the HistoryBuffer object.\n # In most cases this will be the same as the user_id value with which\n # JsonYatta was initialized (Depending on the HistoryBuffer implementation).\n #\n getUserId: ()->\n @HB.getUserId()\n\n #\n # @see JsonType.val\n #\n val: ()->\n @root_element.val()\n\n #\n # @see Word.insertText\n #\n insertText: (pos, content)->\n @root_element.insertText pos, content\n\n #\n # @see Word.deleteText\n #\n deleteText: (pos, length)->\n @root_element.deleteText pos, length\n\n #\n # @see Word.bind\n #\n bind: (textarea)->\n @root_element.bind textarea\n\n #\n # @see Word.replaceText\n #\n replaceText: (text)->\n @root_element.replaceText text\n\n\nmodule.exports = TextYatta\nif window?\n if not window.Y?\n window.Y = {}\n window.Y.TextYatta = TextYatta\n"],"sourceRoot":"/source/"} \ No newline at end of file diff --git a/build/node/HistoryBuffer.js b/build/node/HistoryBuffer.js new file mode 100644 index 00000000..523dc44a --- /dev/null +++ b/build/node/HistoryBuffer.js @@ -0,0 +1,2 @@ +(function(){var r;r=function(){function r(r){this.user_id=r,this.operation_counter={},this.buffer={},this.change_listeners=[]}return r.prototype.getUserId=function(){return this.user_id},r.prototype.getReservedUniqueIdentifier=function(){return{creator:"_",op_number:"_"}},r.prototype.getOperationCounter=function(){var r,t,e,o;t={},o=this.operation_counter;for(e in o)r=o[e],t[e]=r;return t},r.prototype._encode=function(r){var t,e,o,n,i,u,c,p,f,l;null==r&&(r={}),t=[],p=function(t,e){if(null==t||null==e)throw new Error("dah!");return null==r[t]||r[t]<=e},l=this.buffer;for(c in l){f=l[c];for(i in f)if(e=f[i],!isNaN(parseInt(i))&&p(c,i)){if(o=e._encode(),null!=e.next_cl){for(n=e.next_cl;null!=n.next_cl&&p(n.creator,n.op_number);)n=n.next_cl;o.next=n.getUid()}else if(null!=e.prev_cl){for(u=e.prev_cl;null!=u.prev_cl&&p(n.creator,n.op_number);)u=u.prev_cl;o.prev=u.getUid()}t.push(o)}}return t},r.prototype.getNextOperationIdentifier=function(r){var t;return null==r&&(r=this.user_id),null==this.operation_counter[r]&&(this.operation_counter[r]=0),t={creator:r,op_number:this.operation_counter[r]},this.operation_counter[r]++,t},r.prototype.getOperation=function(r){var t;if(r instanceof Object)return null!=(t=this.buffer[r.creator])?t[r.op_number]:void 0;if(null!=r)throw new Error("This type of uid is not defined!")},r.prototype.addOperation=function(r){if(null==this.buffer[r.creator]&&(this.buffer[r.creator]={}),null!=this.buffer[r.creator][r.op_number])throw new Error("You must not overwrite operations!");return this.buffer[r.creator][r.op_number]=r,r},r.prototype.addToCounter=function(r){return null==this.operation_counter[r.creator]&&(this.operation_counter[r.creator]=0),"number"==typeof r.op_number&&r.creator!==this.getUserId()?this.operation_counter[r.creator]++:void 0},r}(),module.exports=r}).call(this); +//# sourceMappingURL=HistoryBuffer.js.map \ No newline at end of file diff --git a/build/node/HistoryBuffer.js.map b/build/node/HistoryBuffer.js.map new file mode 100755 index 00000000..0cbb1ed0 --- /dev/null +++ b/build/node/HistoryBuffer.js.map @@ -0,0 +1 @@ +{"version":3,"file":"HistoryBuffer.js","sources":["HistoryBuffer.coffee"],"names":[],"mappings":"CAMA,WAAA,GAAA,EAAM,GAAA,WAMS,QAAA,GAAE,GAAD,KAAC,QAAA,EACb,KAAC,qBACD,KAAC,UACD,KAAC,0BAHH,GAAA,UAQA,UAAW,iBACT,MAAC,SATH,EAAA,UAiBA,4BAA6B,kBAEzB,QAAU,IACV,UAAY,MApBhB,EAAA,UA0BA,oBAAqB,WACnB,GAAA,GAAA,EAAA,EAAA,CAAA,MACA,EAAA,KAAA,iBAAA,KAAA,IAAA,UACE,EAAI,GAAQ,QACd,IA9BF,EAAA,UAmCA,QAAS,SAAC,GACR,GAAA,GAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,YADQ,MACR,KACA,EAAU,SAAC,EAAM,GACf,GAAQ,MAAA,GAAe,MAAA,EACrB,KAAU,IAAA,OAAM,cACd,OAAA,EAAA,IAAuB,EAAa,IAAS,GAEnD,EAAA,KAAA,MAAA,KAAA,IAAA,GAAA,OACE,KAAA,IAAA,GACE,WAAI,MAAU,SAAS,KAAgB,EAAQ,EAAQ,GAAvD,CAEE,GADA,EAAS,EAAE,UACR,MAAA,EAAA,QAAH,CAEE,IADA,EAAS,EAAE,QACL,MAAA,EAAA,SAAoB,EAAQ,EAAO,QAAS,EAAO,YACvD,EAAS,EAAO,OAClB,GAAO,KAAO,EAAO,aAClB,IAAG,MAAA,EAAA,QAAH,CAEH,IADA,EAAS,EAAE,QACL,MAAA,EAAA,SAAoB,EAAQ,EAAO,QAAS,EAAO,YACvD,EAAS,EAAO,OAClB,GAAO,KAAO,EAAO,SACvB,EAAK,KAAK,UAEhB,IA1DF,EAAA,UAiEA,2BAA4B,SAAC,GAC3B,GAAA,SAAO,OAAA,IACL,EAAU,KAAC,SACN,MAAA,KAAA,kBAAA,KACL,KAAC,kBAAkB,GAAW,GAChC,GACE,QAAY,EACZ,UAAc,KAAC,kBAAkB,IACnC,KAAC,kBAAkB,KACnB,GA1EF,EAAA,UA+EA,aAAc,SAAC,GACb,GAAA,EAAA,IAAG,YAAe,kDACM,EAAI,WAAJ,MACnB,IAAO,MAAA,EAEV,KAAU,IAAA,OAAM,qCApFpB,EAAA,UAyFA,aAAc,SAAC,GAGb,GAFO,MAAA,KAAA,OAAA,EAAA,WACL,KAAC,OAAO,EAAE,aACT,MAAA,KAAA,OAAA,EAAA,SAAA,EAAA,WACD,KAAU,IAAA,OAAM,4CAClB,MAAC,OAAO,EAAE,SAAS,EAAE,WAAa,EAClC,GA/FF,EAAA,UAoGA,aAAc,SAAC,GAGb,MAFO,OAAA,KAAA,kBAAA,EAAA,WACL,KAAC,kBAAkB,EAAE,SAAW,GACT,gBAAtB,GAAS,WAA0B,EAAE,UAAa,KAAC,YACpD,KAAC,kBAAkB,EAAE,WADvB,aAOJ,OAAO,QAAU","sourcesContent":["\n#\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\n #\n # Get the user id with wich the History Buffer was initialized.\n #\n getUserId: ()->\n @user_id\n\n #\n # There is only one reserved unique identifier (uid), so use it wisely.\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 : '_'\n }\n\n #\n # Get the operation counter that describes the current state of the document.\n #\n getOperationCounter: ()->\n res = {}\n for user,ctn of @operation_counter\n res[user] = ctn\n res\n\n #\n # Encode this operation in such a way that it can be parsed by remote peers.\n #\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 for o_number,o of user\n if (not isNaN(parseInt(o_number))) and unknown(u_name, o_number)\n o_json = o._encode()\n if o.next_cl?\n o_next = o.next_cl\n while o_next.next_cl? and unknown(o_next.creator, o_next.op_number)\n o_next = o_next.next_cl\n o_json.next = o_next.getUid()\n else if o.prev_cl?\n o_prev = o.prev_cl\n while o_prev.prev_cl? and unknown(o_next.creator, o_next.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 getOperation: (uid)->\n if uid instanceof Object\n @buffer[uid.creator]?[uid.op_number]\n else if not uid?\n else\n throw new Error \"This type of uid is not defined!\"\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.creator]?\n @buffer[o.creator] = {}\n if @buffer[o.creator][o.op_number]?\n throw new Error \"You must not overwrite operations!\"\n @buffer[o.creator][o.op_number] = o\n o\n\n #\n # Increment the operation_counter that defines the current state of the Engine.\n #\n addToCounter: (o)->\n if not @operation_counter[o.creator]?\n @operation_counter[o.creator] = 0\n if typeof o.op_number is 'number' and o.creator isnt @getUserId()\n @operation_counter[o.creator]++\n #if @operation_counter[o.creator] isnt (o.op_number + 1)\n #console.log (@operation_counter[o.creator] - (o.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"],"sourceRoot":"/source/"} \ No newline at end of file diff --git a/build/node/Types/TextTypes.js b/build/node/Types/TextTypes.js index d2faecd5..f429ee55 100644 --- a/build/node/Types/TextTypes.js +++ b/build/node/Types/TextTypes.js @@ -1,2 +1,2 @@ -(function(){var e,t={}.hasOwnProperty,n=function(e,n){function r(){this.constructor=e}for(var i in n)t.call(n,i)&&(e[i]=n[i]);return r.prototype=n.prototype,e.prototype=new r,e.__super__=n.prototype,e};e=require("./StructuredTypes"),module.exports=function(t){var r,i,o,l,s,a;return s=e(t),a=s.types,l=s.parser,r=function(e){function t(){return t.__super__.constructor.apply(this,arguments)}return n(t,e),t}(a.Delete),l.TextDelete=l.Delete,i=function(e){function t(e,n,r,i,o){if(this.content=e,null==r||null==i)throw new Error("You must define prev, and next for TextInsert-types!");t.__super__.constructor.call(this,n,r,i,o)}return n(t,e),t.prototype.getLength=function(){return this.isDeleted()?0:this.content.length},t.prototype.val=function(){return this.isDeleted()?"":this.content},t.prototype._encode=function(){var e;return e={type:"TextInsert",content:this.content,uid:this.getUid(),prev:this.prev_cl.getUid(),next:this.next_cl.getUid()},null!=this.origin&&this.origin!==this.prev_cl&&(e.origin=this.origin.getUid()),e},t}(a.Insert),l.TextInsert=function(e){var t,n,r,o,l;return t=e.content,l=e.uid,o=e.prev,n=e.next,r=e.origin,new i(t,l,o,n,r)},o=function(e){function o(e,t,n,r,i,l){o.__super__.constructor.call(this,e,t,n,r,i,l)}return n(o,e),o.prototype.insertText=function(e,n){var r,o,l,s,a,u;for(o=this.getOperationByPosition(e),u=[],s=0,a=n.length;a>s;s++)r=n[s],l=new i(r,void 0,o.prev_cl,o),u.push(t.addOperation(l).execute());return u},o.prototype.deleteText=function(e,n){var i,o,l,s,u,c;for(s=this.getOperationByPosition(e),o=[],c=[],l=u=0;n>=0?n>u:u>n;l=n>=0?++u:--u){for(i=t.addOperation(new r(void 0,s)).execute(),s=s.next_cl;s.isDeleted()&&!(s instanceof a.Delimiter);){if(s instanceof a.Delimiter)throw new Error("You can't delete more than there is..");s=s.next_cl}if(o.push(i._encode()),s instanceof a.Delimiter)break;c.push(void 0)}return c},o.prototype.replaceText=function(e){var n;if(null!=this.replace_manager)return n=t.addOperation(new o(void 0)).execute(),n.insertText(0,e),this.replace_manager.replace(n);throw new Error("This type is currently not maintained by a ReplaceManager!")},o.prototype.val=function(){var e,t;return e=function(){var e,n,r,i;for(r=this.toArray(),i=[],e=0,n=r.length;n>e;e++)t=r[e],i.push(null!=t.val?t.val():"");return i}.call(this),e.join("")},o.prototype.setReplaceManager=function(e){return this.saveOperation("replace_manager",e),this.validateSavedOperations},o.prototype.bind=function(e){var n;return n=this,e.value=this.val(),this.on("insert",function(r,i){var o,l,s,a;return i.creator!==t.getUserId()?(s=i.getPosition(),o=function(e){return s>=e?e:e+=1},l=o(e.selectionStart),a=o(e.selectionEnd),e.value=n.val(),e.setSelectionRange(l,a)):void 0}),this.on("delete",function(t,r){var i,o,l,s;return l=r.getPosition(),i=function(e){return l>e?e:e-=1},o=i(e.selectionStart),s=i(e.selectionEnd),e.value=n.val(),e.setSelectionRange(o,s)}),e.onkeypress=function(t){var r,i,o;return r=String.fromCharCode(t.keyCode),r.length>0?(console.log(r.length),o=Math.min(e.selectionStart,e.selectionEnd),i=Math.abs(e.selectionEnd-e.selectionStart),n.deleteText(o,i),n.insertText(o,r)):t.preventDefault()},e.onkeydown=function(t){var r,i,o,l,s;if(l=Math.min(e.selectionStart,e.selectionEnd),i=Math.abs(e.selectionEnd-e.selectionStart),null!=t.keyCode&&8===t.keyCode){if(i>0)n.deleteText(l,i);else if(null!=t.ctrlKey&&t.ctrlKey){for(s=e.value,o=l,r=0,l>0&&(o--,r++);o>0&&" "!==s[o]&&"\n"!==s[o];)o--,r++;n.deleteText(o,l-o),e.setSelectionRange(o,o)}else n.deleteText(l-1,1);return t.preventDefault()}return null!=t.keyCode&&46===t.keyCode?(i>0?n.deleteText(l,i):n.deleteText(l,1),t.preventDefault()):void 0}},o.prototype._encode=function(){var e;return e={type:"Word",uid:this.getUid(),beginning:this.beginning.getUid(),end:this.end.getUid()},null!=this.prev_cl&&(e.prev=this.prev_cl.getUid()),null!=this.next_cl&&(e.next=this.next_cl.getUid()),null!=this.origin&&this.origin!==this.prev_cl&&(e.origin=this.origin.getUid()),e},o}(a.ListManager),l.Word=function(e){var t,n,r,i,l,s;return s=e.uid,t=e.beginning,n=e.end,l=e.prev,r=e.next,i=e.origin,new o(s,t,n,l,r,i)},a.TextInsert=i,a.TextDelete=r,a.Word=o,s}}).call(this); +(function(){var e,t={}.hasOwnProperty,n=function(e,n){function r(){this.constructor=e}for(var i in n)t.call(n,i)&&(e[i]=n[i]);return r.prototype=n.prototype,e.prototype=new r,e.__super__=n.prototype,e};e=require("./StructuredTypes"),module.exports=function(t){var r,i,o,l,s,a;return s=e(t),a=s.types,l=s.parser,r=function(e){function t(){return t.__super__.constructor.apply(this,arguments)}return n(t,e),t}(a.Delete),l.TextDelete=l.Delete,i=function(e){function t(e,n,r,i,o){if(this.content=e,null==r||null==i)throw new Error("You must define prev, and next for TextInsert-types!");t.__super__.constructor.call(this,n,r,i,o)}return n(t,e),t.prototype.getLength=function(){return this.isDeleted()?0:this.content.length},t.prototype.val=function(){return this.isDeleted()?"":this.content},t.prototype._encode=function(){var e;return e={type:"TextInsert",content:this.content,uid:this.getUid(),prev:this.prev_cl.getUid(),next:this.next_cl.getUid()},null!=this.origin&&this.origin!==this.prev_cl&&(e.origin=this.origin.getUid()),e},t}(a.Insert),l.TextInsert=function(e){var t,n,r,o,l;return t=e.content,l=e.uid,o=e.prev,n=e.next,r=e.origin,new i(t,l,o,n,r)},o=function(e){function o(e,t,n,r,i,l){o.__super__.constructor.call(this,e,t,n,r,i,l)}return n(o,e),o.prototype.insertText=function(e,n){var r,o,l,s,a,u;for(o=this.getOperationByPosition(e),u=[],s=0,a=n.length;a>s;s++)r=n[s],l=new i(r,void 0,o.prev_cl,o),u.push(t.addOperation(l).execute());return u},o.prototype.deleteText=function(e,n){var i,o,l,s,u,c;for(s=this.getOperationByPosition(e),o=[],c=[],l=u=0;n>=0?n>u:u>n;l=n>=0?++u:--u){for(i=t.addOperation(new r(void 0,s)).execute(),s=s.next_cl;s.isDeleted()&&!(s instanceof a.Delimiter);){if(s instanceof a.Delimiter)throw new Error("You can't delete more than there is..");s=s.next_cl}if(o.push(i._encode()),s instanceof a.Delimiter)break;c.push(void 0)}return c},o.prototype.replaceText=function(e){var n;if(null!=this.replace_manager)return n=t.addOperation(new o(void 0)).execute(),n.insertText(0,e),this.replace_manager.replace(n);throw new Error("This type is currently not maintained by a ReplaceManager!")},o.prototype.val=function(){var e,t;return e=function(){var e,n,r,i;for(r=this.toArray(),i=[],e=0,n=r.length;n>e;e++)t=r[e],i.push(null!=t.val?t.val():"");return i}.call(this),e.join("")},o.prototype.setReplaceManager=function(e){return this.saveOperation("replace_manager",e),this.validateSavedOperations},o.prototype.bind=function(e){var n;return n=this,e.value=this.val(),this.on("insert",function(r,i){var o,l,s,a;return i.creator!==t.getUserId()?(s=i.getPosition(),o=function(e){return s>=e?e:e+=1},l=o(e.selectionStart),a=o(e.selectionEnd),e.value=n.val(),e.setSelectionRange(l,a)):void 0}),this.on("delete",function(t,r){var i,o,l,s;return l=r.getPosition(),i=function(e){return l>e?e:e-=1},o=i(e.selectionStart),s=i(e.selectionEnd),e.value=n.val(),e.setSelectionRange(o,s)}),e.onkeypress=function(t){var r,i,o;return r=String.fromCharCode(t.keyCode),r.length>0?(o=Math.min(e.selectionStart,e.selectionEnd),i=Math.abs(e.selectionEnd-e.selectionStart),n.deleteText(o,i),n.insertText(o,r)):t.preventDefault()},e.onkeydown=function(t){var r,i,o,l,s;if(l=Math.min(e.selectionStart,e.selectionEnd),i=Math.abs(e.selectionEnd-e.selectionStart),null!=t.keyCode&&8===t.keyCode){if(i>0)n.deleteText(l,i);else if(null!=t.ctrlKey&&t.ctrlKey){for(s=e.value,o=l,r=0,l>0&&(o--,r++);o>0&&" "!==s[o]&&"\n"!==s[o];)o--,r++;n.deleteText(o,l-o),e.setSelectionRange(o,o)}else n.deleteText(l-1,1);return t.preventDefault()}return null!=t.keyCode&&46===t.keyCode?(i>0?n.deleteText(l,i):n.deleteText(l,1),t.preventDefault()):void 0}},o.prototype._encode=function(){var e;return e={type:"Word",uid:this.getUid(),beginning:this.beginning.getUid(),end:this.end.getUid()},null!=this.prev_cl&&(e.prev=this.prev_cl.getUid()),null!=this.next_cl&&(e.next=this.next_cl.getUid()),null!=this.origin&&this.origin!==this.prev_cl&&(e.origin=this.origin.getUid()),e},o}(a.ListManager),l.Word=function(e){var t,n,r,i,l,s;return s=e.uid,t=e.beginning,n=e.end,l=e.prev,r=e.next,i=e.origin,new o(s,t,n,l,r,i)},a.TextInsert=i,a.TextDelete=r,a.Word=o,s}}).call(this); //# sourceMappingURL=../Types/TextTypes.js.map \ No newline at end of file diff --git a/build/node/Types/TextTypes.js.map b/build/node/Types/TextTypes.js.map index 66a3571a..182e6bf8 100755 --- a/build/node/Types/TextTypes.js.map +++ b/build/node/Types/TextTypes.js.map @@ -1 +1 @@ -{"version":3,"file":"Types/TextTypes.js","sources":["Types/TextTypes.coffee"],"names":[],"mappings":"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","sourcesContent":["structured_types_uninitialized = require \"./StructuredTypes\"\n\nmodule.exports = (HB)->\n structured_types = structured_types_uninitialized HB\n types = structured_types.types\n parser = structured_types.parser\n\n #\n # At the moment TextDelete type equals the Delete type in BasicTypes.\n # @see BasicTypes.Delete\n #\n class TextDelete extends types.Delete\n parser[\"TextDelete\"] = parser[\"Delete\"]\n\n #\n # Extends the basic Insert type to an operation that holds a text value\n #\n class TextInsert extends types.Insert\n #\n # @param {String} content The content of this Insert-type Operation. Usually you restrict the length of content to size 1\n # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n #\n constructor: (@content, uid, prev, next, origin)->\n if not (prev? and next?)\n throw new Error \"You must define prev, and next for TextInsert-types!\"\n super uid, prev, next, origin\n #\n # Retrieve the effective length of the $content of this operation.\n #\n getLength: ()->\n if @isDeleted()\n 0\n else\n @content.length\n\n #\n # The result will be concatenated with the results from the other insert operations\n # in order to retrieve the content of the engine.\n # @see HistoryBuffer.toExecutedArray\n #\n val: (current_position)->\n if @isDeleted()\n \"\"\n else\n @content\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: ()->\n json =\n {\n 'type': \"TextInsert\"\n 'content': @content\n 'uid' : @getUid()\n 'prev': @prev_cl.getUid()\n 'next': @next_cl.getUid()\n }\n if @origin? and @origin isnt @prev_cl\n json[\"origin\"] = @origin.getUid()\n json\n\n parser[\"TextInsert\"] = (json)->\n {\n 'content' : content\n 'uid' : uid\n 'prev': prev\n 'next': next\n 'origin' : origin\n } = json\n new TextInsert content, uid, prev, next, origin\n\n #\n # Handles a Text-like data structures with support for insertText/deleteText at a word-position.\n #\n class Word extends types.ListManager\n\n #\n # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n #\n constructor: (uid, beginning, end, prev, next, origin)->\n super uid, beginning, end, prev, next, origin\n\n #\n # Inserts a string into the word\n #\n insertText: (position, content)->\n o = @getOperationByPosition position\n for c in content\n op = new TextInsert c, undefined, o.prev_cl, o\n HB.addOperation(op).execute()\n\n #\n # Deletes a part of the word.\n #\n deleteText: (position, length)->\n o = @getOperationByPosition position\n\n delete_ops = []\n for i in [0...length]\n d = HB.addOperation(new TextDelete undefined, o).execute()\n o = o.next_cl\n while o.isDeleted() and not (o instanceof types.Delimiter)\n if o instanceof types.Delimiter\n throw new Error \"You can't delete more than there is..\"\n o = o.next_cl\n delete_ops.push d._encode()\n if o instanceof types.Delimiter\n break\n\n\n #\n # Replace the content of this word with another one. Concurrent replacements are not merged!\n # Only one of the replacements will be used.\n #\n # Can only be used if the ReplaceManager was set!\n # @see Word.setReplaceManager\n #\n replaceText: (text)->\n if @replace_manager?\n word = HB.addOperation(new Word undefined).execute()\n word.insertText 0, text\n @replace_manager.replace(word)\n else\n throw new Error \"This type is currently not maintained by a ReplaceManager!\"\n\n #\n # @returns [Json] A Json object.\n #\n val: ()->\n c = for o in @toArray()\n if o.val?\n o.val()\n else\n \"\"\n c.join('')\n\n #\n # In most cases you would embed a Word in a Replaceable, wich is handled by the ReplaceManager in order\n # to provide replace functionality.\n #\n setReplaceManager: (op)->\n @saveOperation 'replace_manager', op\n @validateSavedOperations\n\n #\n # Bind this Word to a textfield.\n #\n bind: (textfield)->\n word = @\n textfield.value = @val()\n\n @on \"insert\", (event, op)->\n if op.creator isnt HB.getUserId()\n o_pos = op.getPosition()\n fix = (cursor)->\n if cursor <= o_pos\n cursor\n else\n cursor += 1\n cursor\n left = fix textfield.selectionStart\n right = fix textfield.selectionEnd\n\n textfield.value = word.val()\n textfield.setSelectionRange left, right\n\n\n @on \"delete\", (event, op)->\n o_pos = op.getPosition()\n fix = (cursor)->\n if cursor < o_pos\n cursor\n else\n cursor -= 1\n cursor\n left = fix textfield.selectionStart\n right = fix textfield.selectionEnd\n\n textfield.value = word.val()\n textfield.setSelectionRange left, right\n\n # consume all text-insert changes.\n textfield.onkeypress = (event)->\n char = String.fromCharCode event.keyCode\n if char.length > 0\n console.log char.length\n pos = Math.min textfield.selectionStart, textfield.selectionEnd\n diff = Math.abs(textfield.selectionEnd - textfield.selectionStart)\n word.deleteText pos, diff\n word.insertText pos, char\n else\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 pos = Math.min textfield.selectionStart, textfield.selectionEnd\n diff = Math.abs(textfield.selectionEnd - textfield.selectionStart)\n if event.keyCode? and event.keyCode is 8\n if diff > 0\n word.deleteText pos, diff\n else\n if event.ctrlKey? and event.ctrlKey\n val = textfield.value\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.deleteText new_pos, (pos-new_pos)\n textfield.setSelectionRange new_pos, new_pos\n else\n word.deleteText (pos-1), 1\n event.preventDefault()\n else if event.keyCode? and event.keyCode is 46\n if diff > 0\n word.deleteText pos, diff\n else\n word.deleteText pos, 1\n event.preventDefault()\n\n\n\n #\n # Encode this operation in such a way that it can be parsed by remote peers.\n #\n _encode: ()->\n json = {\n 'type': \"Word\"\n 'uid' : @getUid()\n 'beginning' : @beginning.getUid()\n 'end' : @end.getUid()\n }\n if @prev_cl?\n json['prev'] = @prev_cl.getUid()\n if @next_cl?\n json['next'] = @next_cl.getUid()\n if @origin? and @origin isnt @prev_cl\n json[\"origin\"] = @origin.getUid()\n json\n\n parser['Word'] = (json)->\n {\n 'uid' : uid\n 'beginning' : beginning\n 'end' : end\n 'prev': prev\n 'next': next\n 'origin' : origin\n } = json\n new Word uid, beginning, end, prev, next, origin\n\n types['TextInsert'] = TextInsert\n types['TextDelete'] = TextDelete\n types['Word'] = Word\n structured_types\n\n\n"],"sourceRoot":"/source/"} \ No newline at end of file +{"version":3,"file":"Types/TextTypes.js","sources":["Types/TextTypes.coffee"],"names":[],"mappings":"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","sourcesContent":["structured_types_uninitialized = require \"./StructuredTypes\"\n\nmodule.exports = (HB)->\n structured_types = structured_types_uninitialized HB\n types = structured_types.types\n parser = structured_types.parser\n\n #\n # At the moment TextDelete type equals the Delete type in BasicTypes.\n # @see BasicTypes.Delete\n #\n class TextDelete extends types.Delete\n parser[\"TextDelete\"] = parser[\"Delete\"]\n\n #\n # Extends the basic Insert type to an operation that holds a text value\n #\n class TextInsert extends types.Insert\n #\n # @param {String} content The content of this Insert-type Operation. Usually you restrict the length of content to size 1\n # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n #\n constructor: (@content, uid, prev, next, origin)->\n if not (prev? and next?)\n throw new Error \"You must define prev, and next for TextInsert-types!\"\n super uid, prev, next, origin\n #\n # Retrieve the effective length of the $content of this operation.\n #\n getLength: ()->\n if @isDeleted()\n 0\n else\n @content.length\n\n #\n # The result will be concatenated with the results from the other insert operations\n # in order to retrieve the content of the engine.\n # @see HistoryBuffer.toExecutedArray\n #\n val: (current_position)->\n if @isDeleted()\n \"\"\n else\n @content\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: ()->\n json =\n {\n 'type': \"TextInsert\"\n 'content': @content\n 'uid' : @getUid()\n 'prev': @prev_cl.getUid()\n 'next': @next_cl.getUid()\n }\n if @origin? and @origin isnt @prev_cl\n json[\"origin\"] = @origin.getUid()\n json\n\n parser[\"TextInsert\"] = (json)->\n {\n 'content' : content\n 'uid' : uid\n 'prev': prev\n 'next': next\n 'origin' : origin\n } = json\n new TextInsert content, uid, prev, next, origin\n\n #\n # Handles a Text-like data structures with support for insertText/deleteText at a word-position.\n #\n class Word extends types.ListManager\n\n #\n # @param {Object} uid A unique identifier. If uid is undefined, a new uid will be created.\n #\n constructor: (uid, beginning, end, prev, next, origin)->\n super uid, beginning, end, prev, next, origin\n\n #\n # Inserts a string into the word\n #\n insertText: (position, content)->\n o = @getOperationByPosition position\n for c in content\n op = new TextInsert c, undefined, o.prev_cl, o\n HB.addOperation(op).execute()\n\n #\n # Deletes a part of the word.\n #\n deleteText: (position, length)->\n o = @getOperationByPosition position\n\n delete_ops = []\n for i in [0...length]\n d = HB.addOperation(new TextDelete undefined, o).execute()\n o = o.next_cl\n while o.isDeleted() and not (o instanceof types.Delimiter)\n if o instanceof types.Delimiter\n throw new Error \"You can't delete more than there is..\"\n o = o.next_cl\n delete_ops.push d._encode()\n if o instanceof types.Delimiter\n break\n\n\n #\n # Replace the content of this word with another one. Concurrent replacements are not merged!\n # Only one of the replacements will be used.\n #\n # Can only be used if the ReplaceManager was set!\n # @see Word.setReplaceManager\n #\n replaceText: (text)->\n if @replace_manager?\n word = HB.addOperation(new Word undefined).execute()\n word.insertText 0, text\n @replace_manager.replace(word)\n else\n throw new Error \"This type is currently not maintained by a ReplaceManager!\"\n\n #\n # @returns [Json] A Json object.\n #\n val: ()->\n c = for o in @toArray()\n if o.val?\n o.val()\n else\n \"\"\n c.join('')\n\n #\n # In most cases you would embed a Word in a Replaceable, wich is handled by the ReplaceManager in order\n # to provide replace functionality.\n #\n setReplaceManager: (op)->\n @saveOperation 'replace_manager', op\n @validateSavedOperations\n\n #\n # Bind this Word to a textfield.\n #\n bind: (textfield)->\n word = @\n textfield.value = @val()\n\n @on \"insert\", (event, op)->\n if op.creator isnt HB.getUserId()\n o_pos = op.getPosition()\n fix = (cursor)->\n if cursor <= o_pos\n cursor\n else\n cursor += 1\n cursor\n left = fix textfield.selectionStart\n right = fix textfield.selectionEnd\n\n textfield.value = word.val()\n textfield.setSelectionRange left, right\n\n\n @on \"delete\", (event, op)->\n o_pos = op.getPosition()\n fix = (cursor)->\n if cursor < o_pos\n cursor\n else\n cursor -= 1\n cursor\n left = fix textfield.selectionStart\n right = fix textfield.selectionEnd\n\n textfield.value = word.val()\n textfield.setSelectionRange left, right\n\n # consume all text-insert changes.\n textfield.onkeypress = (event)->\n char = String.fromCharCode event.keyCode\n if char.length > 0\n pos = Math.min textfield.selectionStart, textfield.selectionEnd\n diff = Math.abs(textfield.selectionEnd - textfield.selectionStart)\n word.deleteText pos, diff\n word.insertText pos, char\n else\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 pos = Math.min textfield.selectionStart, textfield.selectionEnd\n diff = Math.abs(textfield.selectionEnd - textfield.selectionStart)\n if event.keyCode? and event.keyCode is 8\n if diff > 0\n word.deleteText pos, diff\n else\n if event.ctrlKey? and event.ctrlKey\n val = textfield.value\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.deleteText new_pos, (pos-new_pos)\n textfield.setSelectionRange new_pos, new_pos\n else\n word.deleteText (pos-1), 1\n event.preventDefault()\n else if event.keyCode? and event.keyCode is 46\n if diff > 0\n word.deleteText pos, diff\n else\n word.deleteText pos, 1\n event.preventDefault()\n\n\n\n #\n # Encode this operation in such a way that it can be parsed by remote peers.\n #\n _encode: ()->\n json = {\n 'type': \"Word\"\n 'uid' : @getUid()\n 'beginning' : @beginning.getUid()\n 'end' : @end.getUid()\n }\n if @prev_cl?\n json['prev'] = @prev_cl.getUid()\n if @next_cl?\n json['next'] = @next_cl.getUid()\n if @origin? and @origin isnt @prev_cl\n json[\"origin\"] = @origin.getUid()\n json\n\n parser['Word'] = (json)->\n {\n 'uid' : uid\n 'beginning' : beginning\n 'end' : end\n 'prev': prev\n 'next': next\n 'origin' : origin\n } = json\n new Word uid, beginning, end, prev, next, origin\n\n types['TextInsert'] = TextInsert\n types['TextDelete'] = TextDelete\n types['Word'] = Word\n structured_types\n\n\n"],"sourceRoot":"/source/"} \ No newline at end of file diff --git a/build/node/index.js b/build/node/index.js new file mode 100644 index 00000000..bf1fd1a8 --- /dev/null +++ b/build/node/index.js @@ -0,0 +1,2 @@ +(function(){exports.IwcConnector=require("./Connectors/IwcConnector"),exports.TestConnector=require("./Connectors/TestConnector"),exports.JsonYatta=require("./Frameworks/JsonYatta"),exports.TextYatta=require("./Frameworks/TextYatta")}).call(this); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/build/node/index.js.map b/build/node/index.js.map new file mode 100755 index 00000000..a9aac5bb --- /dev/null +++ b/build/node/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sources":["index.coffee"],"names":[],"mappings":"CACA,WAAA,QAAQ,aACN,QAAQ,6BACV,QAAQ,cACN,QAAQ,8BACV,QAAQ,UACN,QAAQ,0BACV,QAAQ,UACN,QAAQ","sourcesContent":["\nexports['IwcConnector'] =\n require './Connectors/IwcConnector'\nexports['TestConnector'] =\n require './Connectors/TestConnector'\nexports['JsonYatta'] =\n require './Frameworks/JsonYatta'\nexports['TextYatta'] =\n require './Frameworks/TextYatta'\n\n"],"sourceRoot":"/source/"} \ No newline at end of file diff --git a/build/test/Yatta_test.js b/build/test/Yatta_test.js new file mode 100644 index 00000000..a5e03c77 --- /dev/null +++ b/build/test/Yatta_test.js @@ -0,0 +1,13882 @@ +(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 0) { + return this.engine.applyOp(this.unexecuted[user].shift()); + } + }; + + TestConnector.prototype.flushOneRandom = function() { + return this.flushOne(_.random(0, user_list.length - 1)); + }; + + TestConnector.prototype.flushAll = function() { + var n, ops, _ref; + _ref = this.unexecuted; + for (n in _ref) { + ops = _ref[n]; + this.engine.applyOps(ops); + } + return this.unexecuted = {}; + }; + + return TestConnector; + + })(); +}; + + +},{"underscore":64}],2:[function(require,module,exports){ +var Engine; + +Engine = (function() { + function Engine(HB, parser) { + this.HB = HB; + this.parser = parser; + this.unprocessed_ops = []; + } + + Engine.prototype.parseOperation = function(json) { + var typeParser; + typeParser = this.parser[json.type]; + if (typeParser != null) { + return typeParser(json); + } else { + throw new Error("You forgot to specify a parser for type " + json.type + ". The message is " + (JSON.stringify(json)) + "."); + } + }; + + Engine.prototype.applyOpsBundle = function(ops_json) { + var o, ops, _i, _j, _k, _len, _len1, _len2; + ops = []; + for (_i = 0, _len = ops_json.length; _i < _len; _i++) { + o = ops_json[_i]; + ops.push(this.parseOperation(o)); + } + for (_j = 0, _len1 = ops.length; _j < _len1; _j++) { + o = ops[_j]; + this.HB.addOperation(o); + } + for (_k = 0, _len2 = ops.length; _k < _len2; _k++) { + o = ops[_k]; + if (!o.execute()) { + this.unprocessed_ops.push(o); + } + } + return this.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) { + var o, _i, _len, _results; + _results = []; + for (_i = 0, _len = ops_json.length; _i < _len; _i++) { + o = ops_json[_i]; + _results.push(this.applyOp(o)); + } + return _results; + }; + + Engine.prototype.applyOp = function(op_json) { + var o; + o = this.parseOperation(op_json); + this.HB.addToCounter(o); + if (!o.execute()) { + this.unprocessed_ops.push(o); + } else { + this.HB.addOperation(o); + } + return this.tryUnprocessed(); + }; + + Engine.prototype.tryUnprocessed = function() { + var old_length, op, unprocessed, _i, _len, _ref, _results; + _results = []; + 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 (!op.execute()) { + unprocessed.push(op); + } else { + this.HB.addOperation(op); + } + } + this.unprocessed_ops = unprocessed; + if (this.unprocessed_ops.length === old_length) { + break; + } else { + _results.push(void 0); + } + } + return _results; + }; + + return Engine; + +})(); + +module.exports = Engine; + + +},{}],3:[function(require,module,exports){ +var Engine, HistoryBuffer, JsonYatta, json_types_uninitialized; + +json_types_uninitialized = require("../Types/JsonTypes"); + +HistoryBuffer = require("../HistoryBuffer"); + +Engine = require("../Engine"); + +JsonYatta = (function() { + function JsonYatta(user_id, Connector) { + var first_word, json_types; + this.HB = new HistoryBuffer(user_id); + json_types = json_types_uninitialized(this.HB); + this.engine = new Engine(this.HB, json_types.parser); + this.connector = new Connector(this.engine, this.HB, json_types.execution_listener, this); + first_word = new json_types.types.JsonType(this.HB.getReservedUniqueIdentifier()); + this.HB.addOperation(first_word).execute(); + this.root_element = first_word; + } + + JsonYatta.prototype.getRootElement = function() { + return this.root_element; + }; + + JsonYatta.prototype.getEngine = function() { + return this.engine; + }; + + JsonYatta.prototype.getConnector = function() { + return this.connector; + }; + + JsonYatta.prototype.getHistoryBuffer = function() { + return this.HB; + }; + + JsonYatta.prototype.setMutableDefault = function(mutable) { + return this.root_element.setMutableDefault(mutable); + }; + + JsonYatta.prototype.getUserId = function() { + return this.HB.getUserId(); + }; + + JsonYatta.prototype.val = function(name, content, mutable) { + return this.root_element.val(name, content, mutable); + }; + + Object.defineProperty(JsonYatta.prototype, 'value', { + get: function() { + return this.root_element.value; + }, + set: function(o) { + var o_name, o_obj, _results; + if (o.constructor === {}.constructor) { + _results = []; + for (o_name in o) { + o_obj = o[o_name]; + _results.push(this.val(o_name, o_obj, 'immutable')); + } + return _results; + } else { + throw new Error("You must only set Object values!"); + } + } + }); + + return JsonYatta; + +})(); + +module.exports = JsonYatta; + +if (typeof window !== "undefined" && window !== null) { + if (window.Y == null) { + window.Y = {}; + } + window.Y.JsonYatta = JsonYatta; +} + + +},{"../Engine":2,"../HistoryBuffer":4,"../Types/JsonTypes":6}],4:[function(require,module,exports){ +var HistoryBuffer; + +HistoryBuffer = (function() { + function HistoryBuffer(user_id) { + this.user_id = user_id; + this.operation_counter = {}; + this.buffer = {}; + this.change_listeners = []; + } + + HistoryBuffer.prototype.getUserId = function() { + return this.user_id; + }; + + HistoryBuffer.prototype.getReservedUniqueIdentifier = function() { + return { + creator: '_', + op_number: '_' + }; + }; + + HistoryBuffer.prototype.getOperationCounter = function() { + var ctn, res, user, _ref; + res = {}; + _ref = this.operation_counter; + for (user in _ref) { + ctn = _ref[user]; + res[user] = ctn; + } + return res; + }; + + 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]; + for (o_number in user) { + o = user[o_number]; + if ((!isNaN(parseInt(o_number))) && 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.creator, o_next.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_next.creator, o_next.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 _ref; + if (uid instanceof Object) { + return (_ref = this.buffer[uid.creator]) != null ? _ref[uid.op_number] : void 0; + } else if (uid == null) { + + } else { + throw new Error("This type of uid is not defined!"); + } + }; + + HistoryBuffer.prototype.addOperation = function(o) { + if (this.buffer[o.creator] == null) { + this.buffer[o.creator] = {}; + } + if (this.buffer[o.creator][o.op_number] != null) { + throw new Error("You must not overwrite operations!"); + } + this.buffer[o.creator][o.op_number] = o; + return o; + }; + + HistoryBuffer.prototype.addToCounter = function(o) { + if (this.operation_counter[o.creator] == null) { + this.operation_counter[o.creator] = 0; + } + if (typeof o.op_number === 'number' && o.creator !== this.getUserId()) { + return this.operation_counter[o.creator]++; + } + }; + + return HistoryBuffer; + +})(); + +module.exports = HistoryBuffer; + + +},{}],5:[function(require,module,exports){ +var __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(HB) { + var Delete, Delimiter, ImmutableObject, Insert, Operation, execution_listener, parser; + parser = {}; + execution_listener = []; + Operation = (function() { + function Operation(uid) { + if (uid == null) { + uid = HB.getNextOperationIdentifier(); + } + this.creator = uid['creator'], this.op_number = uid['op_number']; + } + + Operation.prototype.on = function(event, f) { + var _base; + if (this.event_listeners == null) { + this.event_listeners = {}; + } + if ((_base = this.event_listeners)[event] == null) { + _base[event] = []; + } + return this.event_listeners[event].push(f); + }; + + Operation.prototype.callEvent = function(event, args) { + var f, _i, _len, _ref, _ref1, _results; + if (((_ref = this.event_listeners) != null ? _ref[event] : void 0) != null) { + _ref1 = this.event_listeners[event]; + _results = []; + for (_i = 0, _len = _ref1.length; _i < _len; _i++) { + f = _ref1[_i]; + _results.push(f.call(this, event, args)); + } + return _results; + } + }; + + Operation.prototype.setParent = function(o) { + return this.parent = o; + }; + + Operation.prototype.getParent = function() { + return this.parent; + }; + + Operation.prototype.getUid = function() { + return { + 'creator': this.creator, + 'op_number': this.op_number + }; + }; + + Operation.prototype.execute = function() { + var l, _i, _len; + this.is_executed = true; + for (_i = 0, _len = execution_listener.length; _i < _len; _i++) { + l = execution_listener[_i]; + l(this._encode()); + } + return this; + }; + + Operation.prototype.saveOperation = function(name, op) { + if ((op != null ? op.execute : void 0) != null) { + return this[name] = op; + } else if (op != null) { + 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 = 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; + }; + + return Operation; + + })(); + Delete = (function(_super) { + __extends(Delete, _super); + + function Delete(uid, deletes) { + this.saveOperation('deletes', deletes); + Delete.__super__.constructor.call(this, uid); + } + + Delete.prototype._encode = function() { + return { + 'type': "Delete", + 'uid': this.getUid(), + 'deletes': this.deletes.getUid() + }; + }; + + Delete.prototype.execute = function() { + if (this.validateSavedOperations()) { + this.deletes.applyDelete(this); + return Delete.__super__.execute.apply(this, arguments); + } else { + return false; + } + }; + + return Delete; + + })(Operation); + parser['Delete'] = function(o) { + var deletes_uid, uid; + uid = o['uid'], deletes_uid = o['deletes']; + return new Delete(uid, deletes_uid); + }; + Insert = (function(_super) { + __extends(Insert, _super); + + function Insert(uid, prev_cl, next_cl, origin) { + 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, uid); + } + + Insert.prototype.applyDelete = function(o) { + if (this.deleted_by == null) { + this.deleted_by = []; + } + this.deleted_by.push(o); + if ((this.parent != null) && this.deleted_by.length === 1) { + return this.parent.callEvent("delete", this); + } + }; + + Insert.prototype.isDeleted = function() { + var _ref; + return ((_ref = this.deleted_by) != null ? _ref.length : void 0) > 0; + }; + + Insert.prototype.getDistanceToOrigin = function() { + var d, o; + d = 0; + o = this.prev_cl; + while (true) { + if (this.origin === o) { + break; + } + d++; + if (this === this.prev_cl) { + throw new Error("this should not happen ;) "); + } + o = o.prev_cl; + } + return d; + }; + + Insert.prototype.update_sl = function() { + var o; + o = this.prev_cl; + ({ + update: function(dest_cl, dest_sl) { + var _results; + _results = []; + while (true) { + if (o.isDeleted()) { + _results.push(o = o[dest_cl]); + } else { + this[dest_sl] = o; + break; + } + } + return _results; + } + }); + update("prev_cl", "prev_sl"); + return update("next_cl", "prev_sl"); + }; + + Insert.prototype.execute = function() { + var distance_to_origin, i, o, parent, _ref, _ref1, _ref2; + if (this.is_executed != null) { + return this; + } + if (!this.validateSavedOperations()) { + return false; + } else { + if (((_ref = this.prev_cl) != null ? _ref.validateSavedOperations() : void 0) && ((_ref1 = this.next_cl) != null ? _ref1.validateSavedOperations() : void 0) && this.prev_cl.next_cl !== this) { + distance_to_origin = 0; + o = this.prev_cl.next_cl; + i = 0; + while (true) { + if (o == null) { + console.log(JSON.stringify(this.prev_cl.getUid())); + console.log(JSON.stringify(this.next_cl.getUid())); + } + if (o !== this.next_cl) { + if (o.getDistanceToOrigin() === i) { + if (o.creator < this.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; + } + parent = (_ref2 = this.prev_cl) != null ? _ref2.getParent() : void 0; + if (parent != null) { + this.setParent(parent); + this.parent.callEvent("insert", this); + } + return Insert.__super__.execute.apply(this, arguments); + } + }; + + Insert.prototype.getPosition = function() { + var position, prev; + position = 0; + prev = this.prev_cl; + while (true) { + if (prev instanceof Delimiter) { + break; + } + if ((prev.isDeleted != null) && !prev.isDeleted()) { + position++; + } + prev = prev.prev_cl; + } + return position; + }; + + return Insert; + + })(Operation); + ImmutableObject = (function(_super) { + __extends(ImmutableObject, _super); + + function ImmutableObject(uid, content, prev, next, origin) { + this.content = content; + ImmutableObject.__super__.constructor.call(this, uid, prev, next, origin); + } + + ImmutableObject.prototype.val = function() { + return this.content; + }; + + ImmutableObject.prototype._encode = function() { + var json; + json = { + 'type': "ImmutableObject", + 'uid': this.getUid(), + 'content': this.content + }; + if (this.prev_cl != null) { + json['prev'] = this.prev_cl.getUid(); + } + if (this.next_cl != null) { + json['next'] = this.next_cl.getUid(); + } + if ((this.origin != null) && this.origin !== this.prev_cl) { + json["origin"] = this.origin.getUid(); + } + return json; + }; + + return ImmutableObject; + + })(Insert); + parser['ImmutableObject'] = function(json) { + var content, next, origin, prev, uid; + uid = json['uid'], content = json['content'], prev = json['prev'], next = json['next'], origin = json['origin']; + return new ImmutableObject(uid, content, prev, next, origin); + }; + Delimiter = (function(_super) { + __extends(Delimiter, _super); + + function Delimiter(uid, 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, uid); + } + + Delimiter.prototype.isDeleted = function() { + return false; + }; + + 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; + delete this.prev_cl.unchecked.next_cl; + 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; + return this.prev_cl.next_cl = this; + } else if ((this.prev_cl != null) || (this.next_cl != null)) { + return Delimiter.__super__.execute.apply(this, arguments); + } else { + throw new Error("Delimiter is unsufficient defined!"); + } + }; + + Delimiter.prototype._encode = function() { + var _ref, _ref1; + return { + 'type': "Delimiter", + '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; + + })(Operation); + parser['Delimiter'] = function(json) { + var next, prev, uid; + uid = json['uid'], prev = json['prev'], next = json['next']; + return new Delimiter(uid, prev, next); + }; + return { + 'types': { + 'Delete': Delete, + 'Insert': Insert, + 'Delimiter': Delimiter, + 'Operation': Operation, + 'ImmutableObject': ImmutableObject + }, + 'parser': parser, + 'execution_listener': execution_listener + }; +}; + + +},{}],6:[function(require,module,exports){ +var text_types_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; }; + +text_types_uninitialized = require("./TextTypes"); + +module.exports = function(HB) { + var JsonType, createJsonWrapper, parser, text_types, types; + text_types = text_types_uninitialized(HB); + types = text_types.types; + parser = text_types.parser; + createJsonWrapper = function(_jsonType) { + var JsonWrapper; + JsonWrapper = (function() { + function JsonWrapper(jsonType) { + var name, obj, _fn, _ref; + _ref = jsonType.map; + _fn = function(name, obj) { + return Object.defineProperty(JsonWrapper.prototype, name, { + get: function() { + var x; + x = obj.val(); + if (x instanceof JsonType) { + return createJsonWrapper(x); + } else if (x instanceof types.ImmutableObject) { + return x.val(); + } else { + return x; + } + }, + set: function(o) { + var o_name, o_obj, overwrite, _results; + if (o.constructor === {}.constructor) { + overwrite = jsonType.val(name); + _results = []; + for (o_name in o) { + o_obj = o[o_name]; + _results.push(overwrite.val(o_name, o_obj, 'immutable')); + } + return _results; + } else { + return jsonType.val(name, o, 'immutable'); + } + }, + enumerable: true, + configurable: false + }); + }; + for (name in _ref) { + obj = _ref[name]; + _fn(name, obj); + } + } + + return JsonWrapper; + + })(); + return new JsonWrapper(_jsonType); + }; + JsonType = (function(_super) { + __extends(JsonType, _super); + + function JsonType(uid, initial_value, mutable) { + var name, o; + JsonType.__super__.constructor.call(this, uid); + if (initial_value != null) { + if (typeof initial_value !== "object") { + throw new Error("The initial value of JsonTypes must be of type Object! (current type: " + (typeof initial_value) + ")"); + } + for (name in initial_value) { + o = initial_value[name]; + this.val(name, o, mutable); + } + } + } + + JsonType.prototype.mutable_default = true; + + JsonType.prototype.setMutableDefault = function(mutable) { + if (mutable === true || mutable === 'mutable') { + JsonType.prototype.mutable_default = true; + } else if (mutable === false || mutable === 'immutable') { + JsonType.prototype.mutable_default = false; + } else { + throw new Error('Set mutable either "mutable" or "immutable"!'); + } + return 'OK'; + }; + + JsonType.prototype.val = function(name, content, mutable) { + var json, o, o_name, obj, word; + if (typeof name === 'object') { + for (o_name in name) { + o = name[o_name]; + this.val(o_name, o, content); + } + return this; + } else if ((name != null) && (content != null)) { + if (mutable != null) { + if (mutable === true || mutable === 'mutable') { + mutable = true; + } else { + mutable = false; + } + } else { + mutable = this.mutable_default; + } + if (typeof content === 'function') { + return this; + } else if (((!mutable) || typeof content === 'number') && content.constructor !== Object) { + obj = HB.addOperation(new types.ImmutableObject(void 0, content)).execute(); + return JsonType.__super__.val.call(this, name, obj); + } else { + if (typeof content === 'string') { + word = HB.addOperation(new types.Word(void 0)).execute(); + word.insertText(0, content); + return JsonType.__super__.val.call(this, name, word); + } else if (content.constructor === Object) { + json = HB.addOperation(new JsonType(void 0, content, mutable)).execute(); + return JsonType.__super__.val.call(this, name, json); + } else { + throw new Error("You must not set " + (typeof content) + "-types in collaborative Json-objects!"); + } + } + } else { + return JsonType.__super__.val.call(this, name, content); + } + }; + + Object.defineProperty(JsonType.prototype, 'value', { + get: function() { + return createJsonWrapper(this); + }, + set: function(o) { + var o_name, o_obj, _results; + if (o.constructor === {}.constructor) { + _results = []; + for (o_name in o) { + o_obj = o[o_name]; + _results.push(this.val(o_name, o_obj, 'immutable')); + } + return _results; + } else { + throw new Error("You must only set Object values!"); + } + } + }); + + JsonType.prototype._encode = function() { + return { + 'type': "JsonType", + 'uid': this.getUid() + }; + }; + + return JsonType; + + })(types.MapManager); + parser['JsonType'] = function(json) { + var uid; + uid = json['uid']; + return new JsonType(uid); + }; + types['JsonType'] = JsonType; + return text_types; +}; + + +},{"./TextTypes":8}],7:[function(require,module,exports){ +var basic_types_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_types_uninitialized = require("./BasicTypes"); + +module.exports = function(HB) { + var AddName, ListManager, MapManager, ReplaceManager, Replaceable, basic_types, parser, types; + basic_types = basic_types_uninitialized(HB); + types = basic_types.types; + parser = basic_types.parser; + MapManager = (function(_super) { + __extends(MapManager, _super); + + function MapManager(uid) { + this.map = {}; + MapManager.__super__.constructor.call(this, uid); + } + + MapManager.prototype.val = function(name, content) { + var o, obj, result, _ref, _ref1; + if (content != null) { + if (this.map[name] == null) { + HB.addOperation(new AddName(void 0, this, name)).execute(); + } + this.map[name].replace(content); + return this; + } else if (name != null) { + obj = (_ref = this.map[name]) != null ? _ref.val() : void 0; + if (obj instanceof types.ImmutableObject) { + return obj.val(); + } else { + return obj; + } + } else { + result = {}; + _ref1 = this.map; + for (name in _ref1) { + o = _ref1[name]; + obj = o.val(); + if (obj instanceof types.ImmutableObject || obj instanceof MapManager) { + obj = obj.val(); + } + result[name] = obj; + } + return result; + } + }; + + return MapManager; + + })(types.Operation); + AddName = (function(_super) { + __extends(AddName, _super); + + function AddName(uid, map_manager, name) { + this.name = name; + this.saveOperation('map_manager', map_manager); + AddName.__super__.constructor.call(this, uid); + } + + AddName.prototype.execute = function() { + var beg, end, uid_beg, uid_end, uid_r; + if (!this.validateSavedOperations()) { + return false; + } else { + uid_r = this.map_manager.getUid(); + uid_r.op_number = "_" + uid_r.op_number + "_RM_" + this.name; + if (HB.getOperation(uid_r) == null) { + uid_beg = this.map_manager.getUid(); + uid_beg.op_number = "_" + uid_beg.op_number + "_RM_" + this.name + "_beginning"; + uid_end = this.map_manager.getUid(); + uid_end.op_number = "_" + uid_end.op_number + "_RM_" + this.name + "_end"; + beg = HB.addOperation(new types.Delimiter(uid_beg, void 0, uid_end)).execute(); + end = HB.addOperation(new types.Delimiter(uid_end, beg, void 0)).execute(); + this.map_manager.map[this.name] = HB.addOperation(new ReplaceManager(void 0, uid_r, beg, end)).execute(); + } + return AddName.__super__.execute.apply(this, arguments); + } + }; + + AddName.prototype._encode = function() { + return { + 'type': "AddName", + 'uid': this.getUid(), + 'map_manager': this.map_manager.getUid(), + 'name': this.name + }; + }; + + return AddName; + + })(types.Operation); + parser['AddName'] = function(json) { + var map_manager, name, uid; + map_manager = json['map_manager'], uid = json['uid'], name = json['name']; + return new AddName(uid, map_manager, name); + }; + ListManager = (function(_super) { + __extends(ListManager, _super); + + function ListManager(uid, beginning, end, prev, next, origin) { + if ((beginning != null) && (end != null)) { + this.saveOperation('beginning', beginning); + this.saveOperation('end', end); + } else { + this.beginning = HB.addOperation(new types.Delimiter(void 0, void 0, void 0)); + this.end = HB.addOperation(new types.Delimiter(void 0, this.beginning, void 0)); + this.beginning.next_cl = this.end; + this.beginning.execute(); + this.end.execute(); + } + ListManager.__super__.constructor.call(this, uid, prev, next, origin); + } + + 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) { + result.push(o); + o = o.next_cl; + } + return result; + }; + + ListManager.prototype.getOperationByPosition = function(position) { + var o; + o = this.beginning.next_cl; + if (position > 0) { + while (true) { + o = o.next_cl; + if (!o.isDeleted()) { + position -= 1; + } + if (position === 0) { + break; + } + if (o instanceof types.Delimiter) { + console.log("position parameter exceeded the length of the document!"); + o = null; + break; + } + } + } + return o; + }; + + return ListManager; + + })(types.Insert); + ReplaceManager = (function(_super) { + __extends(ReplaceManager, _super); + + function ReplaceManager(initial_content, uid, beginning, end, prev, next, origin) { + ReplaceManager.__super__.constructor.call(this, uid, beginning, end, prev, next, origin); + if (initial_content != null) { + this.replace(initial_content); + } + } + + ReplaceManager.prototype.replace = function(content) { + var o, op; + o = this.getLastOperation(); + op = new Replaceable(content, this, void 0, o, o.next_cl); + return HB.addOperation(op).execute(); + }; + + ReplaceManager.prototype.val = function() { + var o; + o = this.getLastOperation(); + if (o instanceof types.Delimiter) { + throw new Error("dtrn"); + } + return o.val(); + }; + + ReplaceManager.prototype._encode = function() { + var json; + json = { + 'type': "ReplaceManager", + 'uid': this.getUid(), + 'beginning': this.beginning.getUid(), + 'end': this.end.getUid() + }; + if ((this.prev_cl != null) && (this.next_cl != null)) { + json['prev'] = this.prev_cl.getUid(); + json['next'] = this.next_cl.getUid(); + } + if ((this.origin != null) && this.origin !== this.prev_cl) { + json["origin"] = this.origin.getUid(); + } + return json; + }; + + return ReplaceManager; + + })(ListManager); + parser["ReplaceManager"] = function(json) { + var beginning, content, end, next, origin, prev, uid; + content = json['content'], uid = json['uid'], prev = json['prev'], next = json['next'], origin = json['origin'], beginning = json['beginning'], end = json['end']; + return new ReplaceManager(content, uid, beginning, end, prev, next, origin); + }; + Replaceable = (function(_super) { + __extends(Replaceable, _super); + + function Replaceable(content, parent, uid, prev, next, origin) { + this.saveOperation('content', content); + this.saveOperation('parent', parent); + if (!((prev != null) && (next != null) && (content != null))) { + throw new Error("You must define content, prev, and next for Replaceable-types!"); + } + Replaceable.__super__.constructor.call(this, uid, prev, next, origin); + } + + Replaceable.prototype.val = function() { + return this.content; + }; + + Replaceable.prototype.replace = function(content) { + return this.parent.replace(content); + }; + + Replaceable.prototype.execute = function() { + var _base; + if (!this.validateSavedOperations()) { + return false; + } else { + if (typeof (_base = this.content).setReplaceManager === "function") { + _base.setReplaceManager(this.parent); + } + return Replaceable.__super__.execute.apply(this, arguments); + } + }; + + Replaceable.prototype._encode = function() { + var json; + json = { + 'type': "Replaceable", + 'content': this.content.getUid(), + 'ReplaceManager': this.parent.getUid(), + 'prev': this.prev_cl.getUid(), + 'next': this.next_cl.getUid(), + 'uid': this.getUid() + }; + if ((this.origin != null) && this.origin !== this.prev_cl) { + json["origin"] = this.origin.getUid(); + } + return json; + }; + + return Replaceable; + + })(types.Insert); + parser["Replaceable"] = function(json) { + var content, next, origin, parent, prev, uid; + content = json['content'], parent = json['ReplaceManager'], uid = json['uid'], prev = json['prev'], next = json['next'], origin = json['origin']; + return new Replaceable(content, parent, uid, prev, next, origin); + }; + types['ListManager'] = ListManager; + types['MapManager'] = MapManager; + types['ReplaceManager'] = ReplaceManager; + types['Replaceable'] = Replaceable; + return basic_types; +}; + + +},{"./BasicTypes":5}],8:[function(require,module,exports){ +var structured_types_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; }; + +structured_types_uninitialized = require("./StructuredTypes"); + +module.exports = function(HB) { + var TextDelete, TextInsert, Word, parser, structured_types, types; + structured_types = structured_types_uninitialized(HB); + types = structured_types.types; + parser = structured_types.parser; + TextDelete = (function(_super) { + __extends(TextDelete, _super); + + function TextDelete() { + return TextDelete.__super__.constructor.apply(this, arguments); + } + + return TextDelete; + + })(types.Delete); + parser["TextDelete"] = parser["Delete"]; + TextInsert = (function(_super) { + __extends(TextInsert, _super); + + function TextInsert(content, uid, prev, next, origin) { + this.content = content; + if (!((prev != null) && (next != null))) { + throw new Error("You must define prev, and next for TextInsert-types!"); + } + TextInsert.__super__.constructor.call(this, uid, prev, next, origin); + } + + TextInsert.prototype.getLength = function() { + if (this.isDeleted()) { + return 0; + } else { + return this.content.length; + } + }; + + TextInsert.prototype.val = function(current_position) { + if (this.isDeleted()) { + return ""; + } else { + return this.content; + } + }; + + TextInsert.prototype._encode = function() { + var json; + json = { + 'type': "TextInsert", + 'content': this.content, + 'uid': this.getUid(), + 'prev': this.prev_cl.getUid(), + 'next': this.next_cl.getUid() + }; + if ((this.origin != null) && this.origin !== this.prev_cl) { + json["origin"] = this.origin.getUid(); + } + return json; + }; + + return TextInsert; + + })(types.Insert); + parser["TextInsert"] = function(json) { + var content, next, origin, prev, uid; + content = json['content'], uid = json['uid'], prev = json['prev'], next = json['next'], origin = json['origin']; + return new TextInsert(content, uid, prev, next, origin); + }; + Word = (function(_super) { + __extends(Word, _super); + + function Word(uid, beginning, end, prev, next, origin) { + Word.__super__.constructor.call(this, uid, beginning, end, prev, next, origin); + } + + Word.prototype.insertText = function(position, content) { + var c, o, op, _i, _len, _results; + o = this.getOperationByPosition(position); + _results = []; + for (_i = 0, _len = content.length; _i < _len; _i++) { + c = content[_i]; + op = new TextInsert(c, void 0, o.prev_cl, o); + _results.push(HB.addOperation(op).execute()); + } + return _results; + }; + + Word.prototype.deleteText = function(position, length) { + var d, delete_ops, i, o, _i, _results; + o = this.getOperationByPosition(position); + delete_ops = []; + _results = []; + for (i = _i = 0; 0 <= length ? _i < length : _i > length; i = 0 <= length ? ++_i : --_i) { + d = HB.addOperation(new TextDelete(void 0, o)).execute(); + o = o.next_cl; + while (o.isDeleted() && !(o instanceof types.Delimiter)) { + if (o instanceof types.Delimiter) { + throw new Error("You can't delete more than there is.."); + } + o = o.next_cl; + } + delete_ops.push(d._encode()); + if (o instanceof types.Delimiter) { + break; + } else { + _results.push(void 0); + } + } + return _results; + }; + + Word.prototype.replaceText = function(text) { + var word; + if (this.replace_manager != null) { + word = HB.addOperation(new Word(void 0)).execute(); + word.insertText(0, text); + return this.replace_manager.replace(word); + } else { + throw new Error("This type is currently not maintained by a ReplaceManager!"); + } + }; + + Word.prototype.val = function() { + var c, o; + c = (function() { + var _i, _len, _ref, _results; + _ref = this.toArray(); + _results = []; + for (_i = 0, _len = _ref.length; _i < _len; _i++) { + o = _ref[_i]; + if (o.val != null) { + _results.push(o.val()); + } else { + _results.push(""); + } + } + return _results; + }).call(this); + return c.join(''); + }; + + Word.prototype.setReplaceManager = function(op) { + this.saveOperation('replace_manager', op); + return this.validateSavedOperations; + }; + + Word.prototype.bind = function(textfield) { + var word; + word = this; + textfield.value = this.val(); + this.on("insert", function(event, op) { + var fix, left, o_pos, right; + if (op.creator !== HB.getUserId()) { + o_pos = op.getPosition(); + fix = function(cursor) { + if (cursor <= o_pos) { + return cursor; + } else { + cursor += 1; + return cursor; + } + }; + left = fix(textfield.selectionStart); + right = fix(textfield.selectionEnd); + textfield.value = word.val(); + return textfield.setSelectionRange(left, right); + } + }); + this.on("delete", function(event, op) { + var fix, left, o_pos, right; + o_pos = op.getPosition(); + fix = function(cursor) { + if (cursor < o_pos) { + return cursor; + } else { + cursor -= 1; + return cursor; + } + }; + left = fix(textfield.selectionStart); + right = fix(textfield.selectionEnd); + textfield.value = word.val(); + return textfield.setSelectionRange(left, right); + }); + textfield.onkeypress = function(event) { + var char, diff, pos; + char = String.fromCharCode(event.keyCode); + if (char.length > 0) { + pos = Math.min(textfield.selectionStart, textfield.selectionEnd); + diff = Math.abs(textfield.selectionEnd - textfield.selectionStart); + word.deleteText(pos, diff); + return word.insertText(pos, char); + } else { + return event.preventDefault(); + } + }; + return textfield.onkeydown = function(event) { + var del_length, diff, new_pos, pos, val; + pos = Math.min(textfield.selectionStart, textfield.selectionEnd); + diff = Math.abs(textfield.selectionEnd - textfield.selectionStart); + if ((event.keyCode != null) && event.keyCode === 8) { + if (diff > 0) { + word.deleteText(pos, diff); + } else { + if ((event.ctrlKey != null) && event.ctrlKey) { + val = textfield.value; + 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.deleteText(new_pos, pos - new_pos); + textfield.setSelectionRange(new_pos, new_pos); + } else { + word.deleteText(pos - 1, 1); + } + } + return event.preventDefault(); + } else if ((event.keyCode != null) && event.keyCode === 46) { + if (diff > 0) { + word.deleteText(pos, diff); + } else { + word.deleteText(pos, 1); + } + return event.preventDefault(); + } + }; + }; + + Word.prototype._encode = function() { + var json; + json = { + 'type': "Word", + 'uid': this.getUid(), + 'beginning': this.beginning.getUid(), + 'end': this.end.getUid() + }; + if (this.prev_cl != null) { + json['prev'] = this.prev_cl.getUid(); + } + if (this.next_cl != null) { + json['next'] = this.next_cl.getUid(); + } + if ((this.origin != null) && this.origin !== this.prev_cl) { + json["origin"] = this.origin.getUid(); + } + return json; + }; + + return Word; + + })(types.ListManager); + parser['Word'] = function(json) { + var beginning, end, next, origin, prev, uid; + uid = json['uid'], beginning = json['beginning'], end = json['end'], prev = json['prev'], next = json['next'], origin = json['origin']; + return new Word(uid, beginning, end, prev, next, origin); + }; + types['TextInsert'] = TextInsert; + types['TextDelete'] = TextDelete; + types['Word'] = Word; + return structured_types; +}; + + +},{"./StructuredTypes":7}],9:[function(require,module,exports){ +module.exports = require('./lib/chai'); + +},{"./lib/chai":10}],10:[function(require,module,exports){ +/*! + * chai + * Copyright(c) 2011-2014 Jake Luer + * MIT Licensed + */ + +var used = [] + , exports = module.exports = {}; + +/*! + * Chai version + */ + +exports.version = '1.9.1'; + +/*! + * Assertion Error + */ + +exports.AssertionError = require('assertion-error'); + +/*! + * Utils for plugins (not exported) + */ + +var util = require('./chai/utils'); + +/** + * # .use(function) + * + * Provides a way to extend the internals of Chai + * + * @param {Function} + * @returns {this} for chaining + * @api public + */ + +exports.use = function (fn) { + if (!~used.indexOf(fn)) { + fn(this, util); + used.push(fn); + } + + return this; +}; + +/*! + * 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":11,"./chai/config":12,"./chai/core/assertions":13,"./chai/interface/assert":14,"./chai/interface/expect":15,"./chai/interface/should":16,"./chai/utils":27,"assertion-error":36}],11:[function(require,module,exports){ +/*! + * chai + * http://chaijs.com + * Copyright(c) 2011-2014 Jake Luer + * MIT Licensed + */ + +var config = require('./config'); + +module.exports = function (_chai, util) { + /*! + * Module dependencies. + */ + + var AssertionError = _chai.AssertionError + , flag = util.flag; + + /*! + * Module export. + */ + + _chai.Assertion = Assertion; + + /*! + * Assertion Constructor + * + * Creates object for chaining. + * + * @api private + */ + + function Assertion (obj, msg, stack) { + flag(this, 'ssfi', stack || arguments.callee); + flag(this, 'object', obj); + flag(this, 'message', msg); + } + + Object.defineProperty(Assertion, 'includeStack', { + get: function() { + console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.'); + return config.includeStack; + }, + set: function(value) { + console.warn('Assertion.includeStack is deprecated, use chai.config.includeStack instead.'); + config.includeStack = value; + } + }); + + Object.defineProperty(Assertion, 'showDiff', { + get: function() { + console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.'); + return config.showDiff; + }, + set: function(value) { + console.warn('Assertion.showDiff is deprecated, use chai.config.showDiff instead.'); + config.showDiff = value; + } + }); + + Assertion.addProperty = function (name, fn) { + util.addProperty(this.prototype, name, fn); + }; + + Assertion.addMethod = function (name, fn) { + util.addMethod(this.prototype, name, fn); + }; + + Assertion.addChainableMethod = function (name, fn, chainingBehavior) { + util.addChainableMethod(this.prototype, name, fn, chainingBehavior); + }; + + Assertion.overwriteProperty = function (name, fn) { + util.overwriteProperty(this.prototype, name, fn); + }; + + Assertion.overwriteMethod = function (name, fn) { + util.overwriteMethod(this.prototype, name, fn); + }; + + Assertion.overwriteChainableMethod = function (name, fn, chainingBehavior) { + util.overwriteChainableMethod(this.prototype, name, fn, chainingBehavior); + }; + + /*! + * ### .assert(expression, message, negateMessage, expected, actual) + * + * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass. + * + * @name assert + * @param {Philosophical} expression to be tested + * @param {String} message to display if fails + * @param {String} negatedMessage to display if negated expression fails + * @param {Mixed} expected value (remember to check for negation) + * @param {Mixed} actual (optional) will default to `this.obj` + * @api private + */ + + Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) { + var ok = util.test(this, arguments); + if (true !== showDiff) showDiff = false; + if (true !== 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":12}],12:[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 + +}; + +},{}],13:[function(require,module,exports){ +/*! + * chai + * http://chaijs.com + * Copyright(c) 2011-2014 Jake Luer + * 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; + * + * @name ok + * @api public + */ + + Assertion.addProperty('ok', function () { + this.assert( + flag(this, 'object') + , 'expected #{this} to be truthy' + , 'expected #{this} to be falsy'); + }); + + /** + * ### .true + * + * Asserts that the target is `true`. + * + * expect(true).to.be.true; + * expect(1).to.not.be.true; + * + * @name true + * @api public + */ + + Assertion.addProperty('true', function () { + this.assert( + true === flag(this, 'object') + , 'expected #{this} to be true' + , 'expected #{this} to be false' + , this.negate ? false : true + ); + }); + + /** + * ### .false + * + * Asserts that the target is `false`. + * + * expect(false).to.be.false; + * expect(0).to.not.be.false; + * + * @name false + * @api public + */ + + Assertion.addProperty('false', function () { + this.assert( + false === flag(this, 'object') + , 'expected #{this} to be false' + , 'expected #{this} to be true' + , this.negate ? true : false + ); + }); + + /** + * ### .null + * + * Asserts that the target is `null`. + * + * expect(null).to.be.null; + * expect(undefined).not.to.be.null; + * + * @name null + * @api public + */ + + Assertion.addProperty('null', function () { + this.assert( + null === flag(this, 'object') + , 'expected #{this} to be null' + , 'expected #{this} not to be null' + ); + }); + + /** + * ### .undefined + * + * Asserts that the target is `undefined`. + * + * expect(undefined).to.be.undefined; + * expect(null).to.not.be.undefined; + * + * @name undefined + * @api public + */ + + Assertion.addProperty('undefined', function () { + this.assert( + undefined === flag(this, 'object') + , 'expected #{this} to be undefined' + , 'expected #{this} not to be undefined' + ); + }); + + /** + * ### .exist + * + * Asserts that the target is neither `null` nor `undefined`. + * + * var foo = 'hi' + * , bar = null + * , baz; + * + * expect(foo).to.exist; + * expect(bar).to.not.exist; + * expect(baz).to.not.exist; + * + * @name exist + * @api public + */ + + Assertion.addProperty('exist', function () { + this.assert( + null != flag(this, 'object') + , 'expected #{this} to exist' + , 'expected #{this} to not exist' + ); + }); + + + /** + * ### .empty + * + * Asserts that the target's length is `0`. For arrays, it checks + * the `length` property. For objects, it gets the count of + * enumerable keys. + * + * expect([]).to.be.empty; + * expect('').to.be.empty; + * expect({}).to.be.empty; + * + * @name empty + * @api public + */ + + Assertion.addProperty('empty', function () { + var obj = flag(this, 'object') + , expected = obj; + + if (Array.isArray(obj) || 'string' === typeof object) { + expected = obj.length; + } else if (typeof obj === 'object') { + expected = Object.keys(obj).length; + } + + this.assert( + !expected + , 'expected #{this} to be empty' + , 'expected #{this} not to be empty' + ); + }); + + /** + * ### .arguments + * + * Asserts that the target is an arguments object. + * + * function test () { + * expect(arguments).to.be.arguments; + * } + * + * @name arguments + * @alias Arguments + * @api public + */ + + function checkArguments () { + var obj = flag(this, 'object') + , type = Object.prototype.toString.call(obj); + this.assert( + '[object Arguments]' === type + , 'expected #{this} to be arguments but got ' + type + , 'expected #{this} to not be arguments' + ); + } + + Assertion.addProperty('arguments', checkArguments); + Assertion.addProperty('Arguments', checkArguments); + + /** + * ### .equal(value) + * + * Asserts that the target is strictly equal (`===`) to `value`. + * Alternately, if the `deep` flag is set, asserts that + * the target is deeply equal to `value`. + * + * expect('hello').to.equal('hello'); + * expect(42).to.equal(42); + * expect(1).to.not.equal(true); + * expect({ foo: 'bar' }).to.not.equal({ foo: 'bar' }); + * expect({ foo: 'bar' }).to.deep.equal({ foo: 'bar' }); + * + * @name equal + * @alias equals + * @alias eq + * @alias deep.equal + * @param {Mixed} value + * @param {String} message _optional_ + * @api public + */ + + function assertEqual (val, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + if (flag(this, 'deep')) { + return this.eql(val); + } else { + this.assert( + val === obj + , 'expected #{this} to equal #{exp}' + , 'expected #{this} to not equal #{exp}' + , val + , this._obj + , true + ); + } + } + + Assertion.addMethod('equal', assertEqual); + Assertion.addMethod('equals', assertEqual); + Assertion.addMethod('eq', assertEqual); + + /** + * ### .eql(value) + * + * Asserts that the target is deeply equal to `value`. + * + * expect({ foo: 'bar' }).to.eql({ foo: 'bar' }); + * expect([ 1, 2, 3 ]).to.eql([ 1, 2, 3 ]); + * + * @name eql + * @alias eqls + * @param {Mixed} value + * @param {String} message _optional_ + * @api public + */ + + function assertEql(obj, msg) { + if (msg) flag(this, 'message', msg); + this.assert( + _.eql(obj, flag(this, 'object')) + , 'expected #{this} to deeply equal #{exp}' + , 'expected #{this} to not deeply equal #{exp}' + , obj + , this._obj + , true + ); + } + + Assertion.addMethod('eql', assertEql); + Assertion.addMethod('eqls', assertEql); + + /** + * ### .above(value) + * + * Asserts that the target is greater than `value`. + * + * expect(10).to.be.above(5); + * + * Can also be used in conjunction with `length` to + * assert a minimum length. The benefit being a + * more informative error message than if the length + * was supplied directly. + * + * expect('foo').to.have.length.above(2); + * expect([ 1, 2, 3 ]).to.have.length.above(2); + * + * @name above + * @alias gt + * @alias greaterThan + * @param {Number} value + * @param {String} message _optional_ + * @api public + */ + + function assertAbove (n, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + if (flag(this, 'doLength')) { + new Assertion(obj, msg).to.have.property('length'); + var len = obj.length; + this.assert( + len > n + , 'expected #{this} to have a length above #{exp} but got #{act}' + , 'expected #{this} to not have a length above #{exp}' + , n + , len + ); + } else { + this.assert( + obj > n + , 'expected #{this} to be above ' + n + , 'expected #{this} to be at most ' + n + ); + } + } + + Assertion.addMethod('above', assertAbove); + Assertion.addMethod('gt', assertAbove); + Assertion.addMethod('greaterThan', assertAbove); + + /** + * ### .least(value) + * + * Asserts that the target is greater than or equal to `value`. + * + * expect(10).to.be.at.least(10); + * + * Can also be used in conjunction with `length` to + * assert a minimum length. The benefit being a + * more informative error message than if the length + * was supplied directly. + * + * expect('foo').to.have.length.of.at.least(2); + * expect([ 1, 2, 3 ]).to.have.length.of.at.least(3); + * + * @name least + * @alias gte + * @param {Number} value + * @param {String} message _optional_ + * @api public + */ + + function assertLeast (n, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + if (flag(this, 'doLength')) { + new Assertion(obj, msg).to.have.property('length'); + var len = obj.length; + this.assert( + len >= n + , 'expected #{this} to have a length at least #{exp} but got #{act}' + , 'expected #{this} to have a length below #{exp}' + , n + , len + ); + } else { + this.assert( + obj >= n + , 'expected #{this} to be at least ' + n + , 'expected #{this} to be below ' + n + ); + } + } + + Assertion.addMethod('least', assertLeast); + Assertion.addMethod('gte', assertLeast); + + /** + * ### .below(value) + * + * Asserts that the target is less than `value`. + * + * expect(5).to.be.below(10); + * + * Can also be used in conjunction with `length` to + * assert a maximum length. The benefit being a + * more informative error message than if the length + * was supplied directly. + * + * expect('foo').to.have.length.below(4); + * expect([ 1, 2, 3 ]).to.have.length.below(4); + * + * @name below + * @alias lt + * @alias lessThan + * @param {Number} value + * @param {String} message _optional_ + * @api public + */ + + function assertBelow (n, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + if (flag(this, 'doLength')) { + new Assertion(obj, msg).to.have.property('length'); + var len = obj.length; + this.assert( + len < n + , 'expected #{this} to have a length below #{exp} but got #{act}' + , 'expected #{this} to not have a length below #{exp}' + , n + , len + ); + } else { + this.assert( + obj < n + , 'expected #{this} to be below ' + n + , 'expected #{this} to be at least ' + n + ); + } + } + + Assertion.addMethod('below', assertBelow); + Assertion.addMethod('lt', assertBelow); + Assertion.addMethod('lessThan', assertBelow); + + /** + * ### .most(value) + * + * Asserts that the target is less than or equal to `value`. + * + * expect(5).to.be.at.most(5); + * + * Can also be used in conjunction with `length` to + * assert a maximum length. The benefit being a + * more informative error message than if the length + * was supplied directly. + * + * expect('foo').to.have.length.of.at.most(4); + * expect([ 1, 2, 3 ]).to.have.length.of.at.most(3); + * + * @name most + * @alias lte + * @param {Number} value + * @param {String} message _optional_ + * @api public + */ + + function assertMost (n, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + if (flag(this, 'doLength')) { + new Assertion(obj, msg).to.have.property('length'); + var len = obj.length; + this.assert( + len <= n + , 'expected #{this} to have a length at most #{exp} but got #{act}' + , 'expected #{this} to have a length above #{exp}' + , n + , len + ); + } else { + this.assert( + obj <= n + , 'expected #{this} to be at most ' + n + , 'expected #{this} to be above ' + n + ); + } + } + + Assertion.addMethod('most', assertMost); + Assertion.addMethod('lte', assertMost); + + /** + * ### .within(start, finish) + * + * Asserts that the target is within a range. + * + * expect(7).to.be.within(5,10); + * + * Can also be used in conjunction with `length` to + * assert a length range. The benefit being a + * more informative error message than if the length + * was supplied directly. + * + * expect('foo').to.have.length.within(2,4); + * expect([ 1, 2, 3 ]).to.have.length.within(2,4); + * + * @name within + * @param {Number} start lowerbound inclusive + * @param {Number} finish upperbound inclusive + * @param {String} message _optional_ + * @api public + */ + + Assertion.addMethod('within', function (start, finish, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object') + , range = start + '..' + finish; + if (flag(this, 'doLength')) { + new Assertion(obj, msg).to.have.property('length'); + var len = obj.length; + this.assert( + len >= start && len <= finish + , 'expected #{this} to have a length within ' + range + , 'expected #{this} to not have a length within ' + range + ); + } else { + this.assert( + obj >= start && obj <= finish + , 'expected #{this} to be within ' + range + , 'expected #{this} to not be within ' + range + ); + } + }); + + /** + * ### .instanceof(constructor) + * + * Asserts that the target is an instance of `constructor`. + * + * var Tea = function (name) { this.name = name; } + * , Chai = new Tea('chai'); + * + * expect(Chai).to.be.an.instanceof(Tea); + * expect([ 1, 2, 3 ]).to.be.instanceof(Array); + * + * @name instanceof + * @param {Constructor} constructor + * @param {String} message _optional_ + * @alias instanceOf + * @api public + */ + + function assertInstanceOf (constructor, msg) { + if (msg) flag(this, 'message', msg); + var name = _.getName(constructor); + this.assert( + flag(this, 'object') instanceof constructor + , 'expected #{this} to be an instance of ' + name + , 'expected #{this} to not be an instance of ' + name + ); + }; + + Assertion.addMethod('instanceof', assertInstanceOf); + Assertion.addMethod('instanceOf', assertInstanceOf); + + /** + * ### .property(name, [value]) + * + * Asserts that the target has a property `name`, optionally asserting that + * the value of that property is strictly equal to `value`. + * If the `deep` flag is set, you can use dot- and bracket-notation for deep + * references into objects and arrays. + * + * // simple referencing + * var obj = { foo: 'bar' }; + * expect(obj).to.have.property('foo'); + * expect(obj).to.have.property('foo', 'bar'); + * + * // deep referencing + * var deepObj = { + * green: { tea: 'matcha' } + * , teas: [ 'chai', 'matcha', { tea: 'konacha' } ] + * }; + + * expect(deepObj).to.have.deep.property('green.tea', 'matcha'); + * expect(deepObj).to.have.deep.property('teas[1]', 'matcha'); + * expect(deepObj).to.have.deep.property('teas[2].tea', 'konacha'); + * + * You can also use an array as the starting point of a `deep.property` + * assertion, or traverse nested arrays. + * + * var arr = [ + * [ 'chai', 'matcha', 'konacha' ] + * , [ { tea: 'chai' } + * , { tea: 'matcha' } + * , { tea: 'konacha' } ] + * ]; + * + * expect(arr).to.have.deep.property('[0][1]', 'matcha'); + * expect(arr).to.have.deep.property('[1][2].tea', 'konacha'); + * + * Furthermore, `property` changes the subject of the assertion + * to be the value of that property from the original object. This + * permits for further chainable assertions on that property. + * + * expect(obj).to.have.property('foo') + * .that.is.a('string'); + * expect(deepObj).to.have.property('green') + * .that.is.an('object') + * .that.deep.equals({ tea: 'matcha' }); + * expect(deepObj).to.have.property('teas') + * .that.is.an('array') + * .with.deep.property('[2]') + * .that.deep.equals({ tea: 'konacha' }); + * + * @name property + * @alias deep.property + * @param {String} name + * @param {Mixed} value (optional) + * @param {String} message _optional_ + * @returns value of property for chaining + * @api public + */ + + Assertion.addMethod('property', function (name, val, msg) { + if (msg) flag(this, 'message', msg); + + var descriptor = flag(this, 'deep') ? 'deep property ' : 'property ' + , negate = flag(this, 'negate') + , obj = flag(this, 'object') + , value = flag(this, 'deep') + ? _.getPathValue(name, obj) + : obj[name]; + + if (negate && undefined !== val) { + if (undefined === value) { + msg = (msg != null) ? msg + ': ' : ''; + throw new Error(msg + _.inspect(obj) + ' has no ' + descriptor + _.inspect(name)); + } + } else { + this.assert( + undefined !== value + , 'expected #{this} to have a ' + descriptor + _.inspect(name) + , 'expected #{this} to not have ' + descriptor + _.inspect(name)); + } + + if (undefined !== val) { + this.assert( + val === value + , 'expected #{this} to have a ' + descriptor + _.inspect(name) + ' of #{exp}, but got #{act}' + , 'expected #{this} to not have a ' + descriptor + _.inspect(name) + ' of #{act}' + , val + , value + ); + } + + flag(this, 'object', value); + }); + + + /** + * ### .ownProperty(name) + * + * Asserts that the target has an own property `name`. + * + * expect('test').to.have.ownProperty('length'); + * + * @name ownProperty + * @alias haveOwnProperty + * @param {String} name + * @param {String} message _optional_ + * @api public + */ + + function assertOwnProperty (name, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + this.assert( + obj.hasOwnProperty(name) + , 'expected #{this} to have own property ' + _.inspect(name) + , 'expected #{this} to not have own property ' + _.inspect(name) + ); + } + + Assertion.addMethod('ownProperty', assertOwnProperty); + Assertion.addMethod('haveOwnProperty', assertOwnProperty); + + /** + * ### .length(value) + * + * Asserts that the target's `length` property has + * the expected value. + * + * expect([ 1, 2, 3]).to.have.length(3); + * expect('foobar').to.have.length(6); + * + * Can also be used as a chain precursor to a value + * comparison for the length property. + * + * expect('foo').to.have.length.above(2); + * expect([ 1, 2, 3 ]).to.have.length.above(2); + * expect('foo').to.have.length.below(4); + * expect([ 1, 2, 3 ]).to.have.length.below(4); + * expect('foo').to.have.length.within(2,4); + * expect([ 1, 2, 3 ]).to.have.length.within(2,4); + * + * @name length + * @alias lengthOf + * @param {Number} length + * @param {String} message _optional_ + * @api public + */ + + function assertLengthChain () { + flag(this, 'doLength', true); + } + + function assertLength (n, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + new Assertion(obj, msg).to.have.property('length'); + var len = obj.length; + + this.assert( + len == n + , 'expected #{this} to have a length of #{exp} but got #{act}' + , 'expected #{this} to not have a length of #{act}' + , n + , len + ); + } + + Assertion.addChainableMethod('length', assertLength, assertLengthChain); + Assertion.addMethod('lengthOf', assertLength, assertLengthChain); + + /** + * ### .match(regexp) + * + * Asserts that the target matches a regular expression. + * + * expect('foobar').to.match(/^foo/); + * + * @name match + * @param {RegExp} RegularExpression + * @param {String} message _optional_ + * @api public + */ + + Assertion.addMethod('match', function (re, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + this.assert( + re.exec(obj) + , 'expected #{this} to match ' + re + , 'expected #{this} not to match ' + re + ); + }); + + /** + * ### .string(string) + * + * Asserts that the string target contains another string. + * + * expect('foobar').to.have.string('bar'); + * + * @name string + * @param {String} string + * @param {String} message _optional_ + * @api public + */ + + Assertion.addMethod('string', function (str, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + new Assertion(obj, msg).is.a('string'); + + this.assert( + ~obj.indexOf(str) + , 'expected #{this} to contain ' + _.inspect(str) + , 'expected #{this} to not contain ' + _.inspect(str) + ); + }); + + + /** + * ### .keys(key1, [key2], [...]) + * + * Asserts that the target has exactly the given keys, or + * asserts the inclusion of some keys when using the + * `include` or `contain` modifiers. + * + * expect({ foo: 1, bar: 2 }).to.have.keys(['foo', 'bar']); + * expect({ foo: 1, bar: 2, baz: 3 }).to.contain.keys('foo', 'bar'); + * + * @name keys + * @alias key + * @param {String...|Array} keys + * @api public + */ + + function assertKeys (keys) { + var obj = flag(this, 'object') + , str + , ok = true; + + keys = keys instanceof Array + ? keys + : Array.prototype.slice.call(arguments); + + if (!keys.length) throw new Error('keys required'); + + var actual = Object.keys(obj) + , len = keys.length; + + // Inclusion + ok = keys.every(function(key){ + return ~actual.indexOf(key); + }); + + // Strict + if (!flag(this, 'negate') && !flag(this, 'contains')) { + ok = ok && keys.length == actual.length; + } + + // Key string + if (len > 1) { + keys = keys.map(function(key){ + return _.inspect(key); + }); + var last = keys.pop(); + str = keys.join(', ') + ', and ' + last; + } else { + str = _.inspect(keys[0]); + } + + // Form + str = (len > 1 ? 'keys ' : 'key ') + str; + + // Have / include + str = (flag(this, 'contains') ? 'contain ' : 'have ') + str; + + // Assertion + this.assert( + ok + , 'expected #{this} to ' + str + , 'expected #{this} to not ' + str + ); + } + + Assertion.addMethod('keys', assertKeys); + Assertion.addMethod('key', assertKeys); + + /** + * ### .throw(constructor) + * + * Asserts that the function target will throw a specific error, or specific type of error + * (as determined using `instanceof`), optionally with a RegExp or string inclusion test + * for the error's message. + * + * var err = new ReferenceError('This is a bad function.'); + * var fn = function () { throw err; } + * expect(fn).to.throw(ReferenceError); + * expect(fn).to.throw(Error); + * expect(fn).to.throw(/bad function/); + * expect(fn).to.not.throw('good function'); + * expect(fn).to.throw(ReferenceError, /bad function/); + * expect(fn).to.throw(err); + * expect(fn).to.not.throw(new RangeError('Out of range.')); + * + * Please note that when a throw expectation is negated, it will check each + * parameter independently, starting with error constructor type. The appropriate way + * to check for the existence of a type of error but for a message that does not match + * is to use `and`. + * + * expect(fn).to.throw(ReferenceError) + * .and.not.throw(/good function/); + * + * @name throw + * @alias throws + * @alias Throw + * @param {ErrorConstructor} constructor + * @param {String|RegExp} expected error message + * @param {String} message _optional_ + * @see https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error#Error_types + * @returns error for chaining (null if no error) + * @api public + */ + + function assertThrows (constructor, errMsg, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + new Assertion(obj, msg).is.a('function'); + + var thrown = false + , desiredError = null + , name = null + , thrownError = null; + + if (arguments.length === 0) { + errMsg = null; + constructor = null; + } else if (constructor && (constructor instanceof RegExp || 'string' === typeof constructor)) { + errMsg = constructor; + constructor = null; + } else if (constructor && constructor instanceof Error) { + desiredError = constructor; + constructor = null; + errMsg = null; + } else if (typeof constructor === 'function') { + name = constructor.prototype.name || constructor.name; + if (name === 'Error' && constructor !== Error) { + name = (new constructor()).name; + } + } else { + constructor = null; + } + + try { + obj(); + } catch (err) { + // first, check desired error + if (desiredError) { + this.assert( + err === desiredError + , 'expected #{this} to throw #{exp} but #{act} was thrown' + , 'expected #{this} to not throw #{exp}' + , (desiredError instanceof Error ? desiredError.toString() : desiredError) + , (err instanceof Error ? err.toString() : err) + ); + + flag(this, 'object', err); + return this; + } + + // next, check constructor + if (constructor) { + this.assert( + err instanceof constructor + , 'expected #{this} to throw #{exp} but #{act} was thrown' + , 'expected #{this} to not throw #{exp} but #{act} was thrown' + , name + , (err instanceof Error ? err.toString() : err) + ); + + if (!errMsg) { + flag(this, 'object', err); + return this; + } + } + + // next, check message + var message = 'object' === _.type(err) && "message" in err + ? err.message + : '' + err; + + if ((message != null) && errMsg && errMsg instanceof RegExp) { + this.assert( + errMsg.exec(message) + , 'expected #{this} to throw error matching #{exp} but got #{act}' + , 'expected #{this} to throw error not matching #{exp}' + , errMsg + , message + ); + + flag(this, 'object', err); + return this; + } else if ((message != null) && errMsg && 'string' === typeof errMsg) { + this.assert( + ~message.indexOf(errMsg) + , 'expected #{this} to throw error including #{exp} but got #{act}' + , 'expected #{this} to throw error not including #{act}' + , errMsg + , message + ); + + flag(this, 'object', err); + return this; + } else { + thrown = true; + thrownError = err; + } + } + + var actuallyGot = '' + , expectedThrown = name !== null + ? name + : desiredError + ? '#{exp}' //_.inspect(desiredError) + : 'an error'; + + if (thrown) { + actuallyGot = ' but #{act} was thrown' + } + + this.assert( + thrown === true + , 'expected #{this} to throw ' + expectedThrown + actuallyGot + , 'expected #{this} to not throw ' + expectedThrown + actuallyGot + , (desiredError instanceof Error ? desiredError.toString() : desiredError) + , (thrownError instanceof Error ? thrownError.toString() : thrownError) + ); + + flag(this, 'object', thrownError); + }; + + Assertion.addMethod('throw', assertThrows); + Assertion.addMethod('throws', assertThrows); + Assertion.addMethod('Throw', assertThrows); + + /** + * ### .respondTo(method) + * + * Asserts that the object or class target will respond to a method. + * + * Klass.prototype.bar = function(){}; + * expect(Klass).to.respondTo('bar'); + * expect(obj).to.respondTo('bar'); + * + * To check if a constructor will respond to a static function, + * set the `itself` flag. + * + * Klass.baz = function(){}; + * expect(Klass).itself.to.respondTo('baz'); + * + * @name respondTo + * @param {String} method + * @param {String} message _optional_ + * @api public + */ + + Assertion.addMethod('respondTo', function (method, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object') + , itself = flag(this, 'itself') + , context = ('function' === _.type(obj) && !itself) + ? obj.prototype[method] + : obj[method]; + + this.assert( + 'function' === typeof context + , 'expected #{this} to respond to ' + _.inspect(method) + , 'expected #{this} to not respond to ' + _.inspect(method) + ); + }); + + /** + * ### .itself + * + * Sets the `itself` flag, later used by the `respondTo` assertion. + * + * function Foo() {} + * Foo.bar = function() {} + * Foo.prototype.baz = function() {} + * + * expect(Foo).itself.to.respondTo('bar'); + * expect(Foo).itself.not.to.respondTo('baz'); + * + * @name itself + * @api public + */ + + Assertion.addProperty('itself', function () { + flag(this, 'itself', true); + }); + + /** + * ### .satisfy(method) + * + * Asserts that the target passes a given truth test. + * + * expect(1).to.satisfy(function(num) { return num > 0; }); + * + * @name satisfy + * @param {Function} matcher + * @param {String} message _optional_ + * @api public + */ + + Assertion.addMethod('satisfy', function (matcher, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + this.assert( + matcher(obj) + , 'expected #{this} to satisfy ' + _.objDisplay(matcher) + , 'expected #{this} to not satisfy' + _.objDisplay(matcher) + , this.negate ? false : true + , matcher(obj) + ); + }); + + /** + * ### .closeTo(expected, delta) + * + * Asserts that the target is equal `expected`, to within a +/- `delta` range. + * + * expect(1.5).to.be.closeTo(1, 0.5); + * + * @name closeTo + * @param {Number} expected + * @param {Number} delta + * @param {String} message _optional_ + * @api public + */ + + Assertion.addMethod('closeTo', function (expected, delta, msg) { + if (msg) flag(this, 'message', msg); + var obj = flag(this, 'object'); + this.assert( + Math.abs(obj - expected) <= delta + , 'expected #{this} to be close to ' + expected + ' +/- ' + delta + , 'expected #{this} not to be close to ' + expected + ' +/- ' + delta + ); + }); + + function isSubsetOf(subset, superset, 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 + ); + }); +}; + +},{}],14:[function(require,module,exports){ +/*! + * chai + * Copyright(c) 2011-2014 Jake Luer + * 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} superset + * @param {Array} subset + * @param {String} message + * @api public + */ + + assert.sameMembers = function (set1, set2, msg) { + new Assertion(set1, msg).to.have.same.members(set2); + } + + /** + * ### .includeMembers(superset, subset, [message]) + * + * Asserts that `subset` is included in `superset`. + * Order is not taken into account. + * + * assert.includeMembers([ 1, 2, 3 ], [ 2, 1 ], 'include members'); + * + * @name includeMembers + * @param {Array} superset + * @param {Array} subset + * @param {String} message + * @api public + */ + + assert.includeMembers = function (superset, subset, msg) { + new Assertion(superset, msg).to.include.members(subset); + } + + /*! + * Undocumented / untested + */ + + assert.ifError = function (val, msg) { + new Assertion(val, msg).to.not.be.ok; + }; + + /*! + * Aliases. + */ + + (function alias(name, as){ + assert[as] = assert[name]; + return alias; + }) + ('Throw', 'throw') + ('Throw', 'throws'); +}; + +},{}],15:[function(require,module,exports){ +/*! + * chai + * Copyright(c) 2011-2014 Jake Luer + * MIT Licensed + */ + +module.exports = function (chai, util) { + chai.expect = function (val, message) { + return new chai.Assertion(val, message); + }; +}; + + +},{}],16:[function(require,module,exports){ +/*! + * chai + * Copyright(c) 2011-2014 Jake Luer + * 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; +}; + +},{}],17:[function(require,module,exports){ +/*! + * Chai - addChainingMethod utility + * Copyright(c) 2012-2014 Jake Luer + * 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":12,"./flag":20,"./transferFlags":34}],18:[function(require,module,exports){ +/*! + * Chai - addMethod utility + * Copyright(c) 2012-2014 Jake Luer + * 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":12,"./flag":20}],19:[function(require,module,exports){ +/*! + * Chai - addProperty utility + * Copyright(c) 2012-2014 Jake Luer + * 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 + }); +}; + +},{}],20:[function(require,module,exports){ +/*! + * Chai - flag utility + * Copyright(c) 2012-2014 Jake Luer + * 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]; + } +}; + +},{}],21:[function(require,module,exports){ +/*! + * Chai - getActual utility + * Copyright(c) 2012-2014 Jake Luer + * 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; +}; + +},{}],22:[function(require,module,exports){ +/*! + * Chai - getEnumerableProperties utility + * Copyright(c) 2012-2014 Jake Luer + * 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; +}; + +},{}],23:[function(require,module,exports){ +/*! + * Chai - message composition utility + * Copyright(c) 2012-2014 Jake Luer + * MIT Licensed + */ + +/*! + * Module dependancies + */ + +var flag = require('./flag') + , getActual = require('./getActual') + , inspect = require('./inspect') + , objDisplay = require('./objDisplay'); + +/** + * ### .getMessage(object, message, negateMessage) + * + * Construct the error message based on flags + * and template tags. Template tags will return + * a stringified inspection of the object referenced. + * + * Message template tags: + * - `#{this}` current asserted object + * - `#{act}` actual value + * - `#{exp}` expected value + * + * @param {Object} object (constructed Assertion) + * @param {Arguments} chai.Assertion.prototype.assert arguments + * @name getMessage + * @api public + */ + +module.exports = function (obj, args) { + var negate = flag(obj, 'negate') + , val = flag(obj, 'object') + , expected = args[3] + , actual = getActual(obj, args) + , msg = negate ? args[2] : args[1] + , flagMsg = flag(obj, 'message'); + + msg = msg || ''; + msg = msg + .replace(/#{this}/g, objDisplay(val)) + .replace(/#{act}/g, objDisplay(actual)) + .replace(/#{exp}/g, objDisplay(expected)); + + return flagMsg ? flagMsg + ': ' + msg : msg; +}; + +},{"./flag":20,"./getActual":21,"./inspect":28,"./objDisplay":29}],24:[function(require,module,exports){ +/*! + * Chai - getName utility + * Copyright(c) 2012-2014 Jake Luer + * 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] : ""; +}; + +},{}],25:[function(require,module,exports){ +/*! + * Chai - getPathValue utility + * Copyright(c) 2012-2014 Jake Luer + * @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; +}; + +},{}],26:[function(require,module,exports){ +/*! + * Chai - getProperties utility + * Copyright(c) 2012-2014 Jake Luer + * 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; +}; + +},{}],27:[function(require,module,exports){ +/*! + * chai + * Copyright(c) 2011 Jake Luer + * 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":17,"./addMethod":18,"./addProperty":19,"./flag":20,"./getActual":21,"./getMessage":23,"./getName":24,"./getPathValue":25,"./inspect":28,"./objDisplay":29,"./overwriteChainableMethod":30,"./overwriteMethod":31,"./overwriteProperty":32,"./test":33,"./transferFlags":34,"./type":35,"deep-eql":37}],28:[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)); +} + +// https://gist.github.com/1044128/ +var getOuterHTML = function(element) { + if ('outerHTML' in element) return element.outerHTML; + var ns = "http://www.w3.org/1999/xhtml"; + var container = document.createElementNS(ns, '_'); + var elemProto = (window.HTMLElement || window.Element).prototype; + var xmlSerializer = new XMLSerializer(); + var html; + if (document.xmlVersion) { + return xmlSerializer.serializeToString(element); + } else { + container.appendChild(element.cloneNode(false)); + html = container.innerHTML.replace('><', '>' + element.innerHTML + '<'); + container.innerHTML = ''; + return html; + } +}; + +// Returns true if object is a DOM element. +var isDOMElement = function (object) { + if (typeof HTMLElement === 'object') { + return object instanceof HTMLElement; + } else { + return object && + typeof object === 'object' && + object.nodeType === 1 && + typeof object.nodeName === 'string'; + } +}; + +function formatValue(ctx, value, recurseTimes) { + // Provide a hook for user-specified inspect functions. + // Check that value is an object with an inspect function on it + if (value && typeof value.inspect === 'function' && + // Filter out the util module, it's inspect function is special + value.inspect !== exports.inspect && + // Also filter out any prototype objects using the circular check. + !(value.constructor && value.constructor.prototype === value)) { + var ret = value.inspect(recurseTimes); + if (typeof ret !== 'string') { + ret = formatValue(ctx, ret, recurseTimes); + } + return ret; + } + + // Primitive types cannot have properties + var primitive = formatPrimitive(ctx, value); + if (primitive) { + return primitive; + } + + // If it's DOM elem, get outer HTML. + if (isDOMElement(value)) { + return getOuterHTML(value); + } + + // Look up the keys of the object. + var visibleKeys = getEnumerableProperties(value); + var keys = ctx.showHidden ? getProperties(value) : visibleKeys; + + // Some type of object without properties can be shortcutted. + // In IE, errors have a single `stack` property, or if they are vanilla `Error`, + // a `stack` plus `description` property; ignore those for consistency. + if (keys.length === 0 || (isError(value) && ( + (keys.length === 1 && keys[0] === 'stack') || + (keys.length === 2 && keys[0] === 'description' && keys[1] === 'stack') + ))) { + if (typeof value === 'function') { + var name = getName(value); + var nameSuffix = name ? ': ' + name : ''; + return ctx.stylize('[Function' + nameSuffix + ']', 'special'); + } + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); + } + if (isDate(value)) { + return ctx.stylize(Date.prototype.toUTCString.call(value), 'date'); + } + if (isError(value)) { + return formatError(value); + } + } + + var base = '', array = false, braces = ['{', '}']; + + // Make Array say that they are Array + if (isArray(value)) { + array = true; + braces = ['[', ']']; + } + + // Make functions say that they are functions + if (typeof value === 'function') { + var name = getName(value); + var nameSuffix = name ? ': ' + name : ''; + base = ' [Function' + nameSuffix + ']'; + } + + // Make RegExps say that they are RegExps + if (isRegExp(value)) { + base = ' ' + RegExp.prototype.toString.call(value); + } + + // Make dates with properties first say the date + if (isDate(value)) { + base = ' ' + Date.prototype.toUTCString.call(value); + } + + // Make error with message first say the error + if (isError(value)) { + return formatError(value); + } + + if (keys.length === 0 && (!array || value.length == 0)) { + return braces[0] + base + braces[1]; + } + + if (recurseTimes < 0) { + if (isRegExp(value)) { + return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp'); + } else { + return ctx.stylize('[Object]', 'special'); + } + } + + ctx.seen.push(value); + + var output; + if (array) { + output = formatArray(ctx, value, recurseTimes, visibleKeys, keys); + } else { + output = keys.map(function(key) { + return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array); + }); + } + + ctx.seen.pop(); + + return reduceToSingleString(output, base, braces); +} + + +function formatPrimitive(ctx, value) { + switch (typeof value) { + case 'undefined': + return ctx.stylize('undefined', 'undefined'); + + case 'string': + var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '') + .replace(/'/g, "\\'") + .replace(/\\"/g, '"') + '\''; + return ctx.stylize(simple, 'string'); + + case 'number': + return ctx.stylize('' + value, 'number'); + + case 'boolean': + return ctx.stylize('' + value, 'boolean'); + } + // For some reason typeof null is "object", so special case here. + if (value === null) { + return ctx.stylize('null', 'null'); + } +} + + +function formatError(value) { + return '[' + Error.prototype.toString.call(value) + ']'; +} + + +function formatArray(ctx, value, recurseTimes, visibleKeys, keys) { + var output = []; + for (var i = 0, l = value.length; i < l; ++i) { + if (Object.prototype.hasOwnProperty.call(value, String(i))) { + output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, + String(i), true)); + } else { + output.push(''); + } + } + keys.forEach(function(key) { + if (!key.match(/^\d+$/)) { + output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, + key, true)); + } + }); + return output; +} + + +function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) { + var name, str; + if (value.__lookupGetter__) { + if (value.__lookupGetter__(key)) { + if (value.__lookupSetter__(key)) { + str = ctx.stylize('[Getter/Setter]', 'special'); + } else { + str = ctx.stylize('[Getter]', 'special'); + } + } else { + if (value.__lookupSetter__(key)) { + str = ctx.stylize('[Setter]', 'special'); + } + } + } + if (visibleKeys.indexOf(key) < 0) { + name = '[' + key + ']'; + } + if (!str) { + if (ctx.seen.indexOf(value[key]) < 0) { + if (recurseTimes === null) { + str = formatValue(ctx, value[key], null); + } else { + str = formatValue(ctx, value[key], recurseTimes - 1); + } + if (str.indexOf('\n') > -1) { + if (array) { + str = str.split('\n').map(function(line) { + return ' ' + line; + }).join('\n').substr(2); + } else { + str = '\n' + str.split('\n').map(function(line) { + return ' ' + line; + }).join('\n'); + } + } + } else { + str = ctx.stylize('[Circular]', 'special'); + } + } + if (typeof name === 'undefined') { + if (array && key.match(/^\d+$/)) { + return str; + } + name = JSON.stringify('' + key); + if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) { + name = name.substr(1, name.length - 2); + name = ctx.stylize(name, 'name'); + } else { + name = name.replace(/'/g, "\\'") + .replace(/\\"/g, '"') + .replace(/(^"|"$)/g, "'"); + name = ctx.stylize(name, 'string'); + } + } + + return name + ': ' + str; +} + + +function reduceToSingleString(output, base, braces) { + var numLinesEst = 0; + var length = output.reduce(function(prev, cur) { + numLinesEst++; + if (cur.indexOf('\n') >= 0) numLinesEst++; + return prev + cur.length + 1; + }, 0); + + if (length > 60) { + return braces[0] + + (base === '' ? '' : base + '\n ') + + ' ' + + output.join(',\n ') + + ' ' + + braces[1]; + } + + return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1]; +} + +function isArray(ar) { + return Array.isArray(ar) || + (typeof ar === 'object' && objectToString(ar) === '[object Array]'); +} + +function isRegExp(re) { + return typeof re === 'object' && objectToString(re) === '[object RegExp]'; +} + +function isDate(d) { + return typeof d === 'object' && objectToString(d) === '[object Date]'; +} + +function isError(e) { + return typeof e === 'object' && objectToString(e) === '[object Error]'; +} + +function objectToString(o) { + return Object.prototype.toString.call(o); +} + +},{"./getEnumerableProperties":22,"./getName":24,"./getProperties":26}],29:[function(require,module,exports){ +/*! + * Chai - flag utility + * Copyright(c) 2012-2014 Jake Luer + * 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":12,"./inspect":28}],30:[function(require,module,exports){ +/*! + * Chai - overwriteChainableMethod utility + * Copyright(c) 2012-2014 Jake Luer + * 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; + }; +}; + +},{}],31:[function(require,module,exports){ +/*! + * Chai - overwriteMethod utility + * Copyright(c) 2012-2014 Jake Luer + * 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; + } +}; + +},{}],32:[function(require,module,exports){ +/*! + * Chai - overwriteProperty utility + * Copyright(c) 2012-2014 Jake Luer + * 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 + }); +}; + +},{}],33:[function(require,module,exports){ +/*! + * Chai - test utility + * Copyright(c) 2012-2014 Jake Luer + * 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":20}],34:[function(require,module,exports){ +/*! + * Chai - transferFlags utility + * Copyright(c) 2012-2014 Jake Luer + * 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]; + } + } +}; + +},{}],35:[function(require,module,exports){ +/*! + * Chai - type utility + * Copyright(c) 2012-2014 Jake Luer + * 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; +}; + +},{}],36:[function(require,module,exports){ +/*! + * assertion-error + * Copyright(c) 2013 Jake Luer + * 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; +}; + +},{}],37:[function(require,module,exports){ +module.exports = require('./lib/eql'); + +},{"./lib/eql":38}],38:[function(require,module,exports){ +/*! + * deep-eql + * Copyright(c) 2013 Jake Luer + * 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":41,"type-detect":39}],39:[function(require,module,exports){ +module.exports = require('./lib/type'); + +},{"./lib/type":40}],40:[function(require,module,exports){ +/*! + * type-detect + * Copyright(c) 2013 jake luer + * 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.'); + } +}; + +},{}],41:[function(require,module,exports){ +/*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @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 '' +} + +/** + * 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":42,"ieee754":43}],42:[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) + + function decode (elt) { + var code = elt.charCodeAt(0) + if (code === PLUS) + return 62 // '+' + if (code === SLASH) + 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)) + +},{}],43:[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; +}; + +},{}],44:[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 + } +} + +},{}],45:[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'); +}; + +},{}],46:[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'; +} +},{}],47:[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":46,"1YiZ5S":45,"inherits":44}],48:[function(require,module,exports){ +(function (sinonChai) { + "use strict"; + + // Module systems magic dance. + + if (typeof require === "function" && typeof exports === "object" && typeof module === "object") { + // NodeJS + module.exports = sinonChai; + } else if (typeof define === "function" && define.amd) { + // AMD + define(function () { + return sinonChai; + }); + } else { + // Other environment (usually diff --git a/examples/TextEditing/index.js b/examples/TextEditing/index.js index cae49bef..18e68b0e 100644 --- a/examples/TextEditing/index.js +++ b/examples/TextEditing/index.js @@ -1,7 +1,8 @@ /** ## Text Editing Example - Here, I will give a short overview on how to enable collaborative text editing with the PeerJs Connector and the TextYatta Framework. + Here, I will give a short overview on how to enable collaborative text editing with the + [PeerJs](http://peerjs.com/) Connector and the TextYatta Framework. First you have to include the following libraries in your html file: ```