testing observers, refactoring some Basic Types

build/node/HistoryBuffer.js

@@ -0,0 +1,209 @@
+(function() {
+  var HistoryBuffer,
+    __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; };
+
+  HistoryBuffer = (function() {
+    function HistoryBuffer(user_id) {
+      this.user_id = user_id;
+      this.emptyGarbage = __bind(this.emptyGarbage, this);
+      this.operation_counter = {};
+      this.buffer = {};
+      this.change_listeners = [];
+      this.garbage = [];
+      this.trash = [];
+      this.performGarbageCollection = true;
+      this.garbageCollectTimeout = 1000;
+      this.reserved_identifier_counter = 0;
+      setTimeout(this.emptyGarbage, this.garbageCollectTimeout);
+    }
+
+    HistoryBuffer.prototype.emptyGarbage = function() {
+      var o, _i, _len, _ref;
+      _ref = this.garbage;
+      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+        o = _ref[_i];
+        if (typeof o.cleanup === "function") {
+          o.cleanup();
+        }
+      }
+      this.garbage = this.trash;
+      this.trash = [];
+      if (this.garbageCollectTimeout !== -1) {
+        this.garbageCollectTimeoutId = setTimeout(this.emptyGarbage, this.garbageCollectTimeout);
+      }
+      return void 0;
+    };
+
+    HistoryBuffer.prototype.getUserId = function() {
+      return this.user_id;
+    };
+
+    HistoryBuffer.prototype.addToGarbageCollector = function() {
+      var o, _i, _len, _results;
+      if (this.performGarbageCollection) {
+        _results = [];
+        for (_i = 0, _len = arguments.length; _i < _len; _i++) {
+          o = arguments[_i];
+          if (o != null) {
+            _results.push(this.garbage.push(o));
+          } else {
+            _results.push(void 0);
+          }
+        }
+        return _results;
+      }
+    };
+
+    HistoryBuffer.prototype.stopGarbageCollection = function() {
+      this.performGarbageCollection = false;
+      this.setManualGarbageCollect();
+      this.garbage = [];
+      return this.trash = [];
+    };
+
+    HistoryBuffer.prototype.setManualGarbageCollect = function() {
+      this.garbageCollectTimeout = -1;
+      clearTimeout(this.garbageCollectTimeoutId);
+      return this.garbageCollectTimeoutId = void 0;
+    };
+
+    HistoryBuffer.prototype.setGarbageCollectTimeout = function(garbageCollectTimeout) {
+      this.garbageCollectTimeout = garbageCollectTimeout;
+    };
+
+    HistoryBuffer.prototype.getReservedUniqueIdentifier = function() {
+      return {
+        creator: '_',
+        op_number: "_" + (this.reserved_identifier_counter++),
+        doSync: false
+      };
+    };
+
+    HistoryBuffer.prototype.getOperationCounter = function(user_id) {
+      var ctn, res, user, _ref;
+      if (user_id == null) {
+        res = {};
+        _ref = this.operation_counter;
+        for (user in _ref) {
+          ctn = _ref[user];
+          res[user] = ctn;
+        }
+        return res;
+      } else {
+        return this.operation_counter[user_id];
+      }
+    };
+
+    HistoryBuffer.prototype._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 (o.uid.doSync && unknown(u_name, o_number)) {
+            o_json = o._encode();
+            if (o.next_cl != null) {
+              o_next = o.next_cl;
+              while ((o_next.next_cl != null) && unknown(o_next.uid.creator, o_next.uid.op_number)) {
+                o_next = o_next.next_cl;
+              }
+              o_json.next = o_next.getUid();
+            } else if (o.prev_cl != null) {
+              o_prev = o.prev_cl;
+              while ((o_prev.prev_cl != null) && unknown(o_prev.uid.creator, o_prev.uid.op_number)) {
+                o_prev = o_prev.prev_cl;
+              }
+              o_json.prev = o_prev.getUid();
+            }
+            json.push(o_json);
+          }
+        }
+      }
+      return json;
+    };
+
+    HistoryBuffer.prototype.getNextOperationIdentifier = function(user_id) {
+      var uid;
+      if (user_id == null) {
+        user_id = this.user_id;
+      }
+      if (this.operation_counter[user_id] == null) {
+        this.operation_counter[user_id] = 0;
+      }
+      uid = {
+        'creator': user_id,
+        'op_number': this.operation_counter[user_id],
+        'doSync': true
+      };
+      this.operation_counter[user_id]++;
+      return uid;
+    };
+
+    HistoryBuffer.prototype.getOperation = function(uid) {
+      var _ref;
+      if (uid.uid != null) {
+        uid = uid.uid;
+      }
+      return (_ref = this.buffer[uid.creator]) != null ? _ref[uid.op_number] : void 0;
+    };
+
+    HistoryBuffer.prototype.addOperation = function(o) {
+      if (this.buffer[o.uid.creator] == null) {
+        this.buffer[o.uid.creator] = {};
+      }
+      if (this.buffer[o.uid.creator][o.uid.op_number] != null) {
+        throw new Error("You must not overwrite operations!");
+      }
+      this.buffer[o.uid.creator][o.uid.op_number] = o;
+      if (this.number_of_operations_added_to_HB == null) {
+        this.number_of_operations_added_to_HB = 0;
+      }
+      this.number_of_operations_added_to_HB++;
+      return o;
+    };
+
+    HistoryBuffer.prototype.removeOperation = function(o) {
+      var _ref;
+      return (_ref = this.buffer[o.uid.creator]) != null ? delete _ref[o.uid.op_number] : void 0;
+    };
+
+    HistoryBuffer.prototype.addToCounter = function(o) {
+      var _results;
+      if (this.operation_counter[o.uid.creator] == null) {
+        this.operation_counter[o.uid.creator] = 0;
+      }
+      if (typeof o.uid.op_number === 'number' && o.uid.creator !== this.getUserId()) {
+        if (o.uid.op_number === this.operation_counter[o.uid.creator]) {
+          this.operation_counter[o.uid.creator]++;
+          _results = [];
+          while (this.getOperation({
+              creator: o.uid.creator,
+              op_number: this.operation_counter[o.uid.creator]
+            }) != null) {
+            _results.push(this.operation_counter[o.uid.creator]++);
+          }
+          return _results;
+        }
+      }
+    };
+
+    return HistoryBuffer;
+
+  })();
+
+  module.exports = HistoryBuffer;
+
+}).call(this);
+
+//# sourceMappingURL=HistoryBuffer.js.map

build/node/Types/BasicTypes.js

@@ -0,0 +1,458 @@
+(function() {
+  var __slice = [].slice,
+    __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  module.exports = function(HB) {
+    var Delete, Delimiter, ImmutableObject, Insert, Operation, execution_listener, parser;
+    parser = {};
+    execution_listener = [];
+    Operation = (function() {
+      function Operation(uid) {
+        this.is_deleted = false;
+        this.garbage_collected = false;
+        this.event_listeners = [];
+        if (uid != null) {
+          this.uid = uid;
+        }
+      }
+
+      Operation.prototype.type = "Insert";
+
+      Operation.prototype.observe = function(f) {
+        return this.event_listeners.push(f);
+      };
+
+      Operation.prototype.unobserve = function(f) {
+        return this.event_listeners.filter(function(g) {
+          return f !== g;
+        });
+      };
+
+      Operation.prototype.deleteAllObservers = function() {
+        return this.event_listeners = [];
+      };
+
+      Operation.prototype.callEvent = function() {
+        return this.forwardEvent.apply(this, [this].concat(__slice.call(arguments)));
+      };
+
+      Operation.prototype.forwardEvent = function() {
+        var args, f, op, _i, _len, _ref, _results;
+        op = arguments[0], args = 2 <= arguments.length ? __slice.call(arguments, 1) : [];
+        _ref = this.event_listeners;
+        _results = [];
+        for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+          f = _ref[_i];
+          _results.push(f.call.apply(f, [op].concat(__slice.call(args))));
+        }
+        return _results;
+      };
+
+      Operation.prototype.isDeleted = function() {
+        return this.is_deleted;
+      };
+
+      Operation.prototype.applyDelete = function(garbagecollect) {
+        if (garbagecollect == null) {
+          garbagecollect = true;
+        }
+        if (!this.garbage_collected) {
+          this.is_deleted = true;
+          if (garbagecollect) {
+            this.garbage_collected = true;
+            return HB.addToGarbageCollector(this);
+          }
+        }
+      };
+
+      Operation.prototype.cleanup = function() {
+        HB.removeOperation(this);
+        return this.deleteAllObservers();
+      };
+
+      Operation.prototype.setParent = function(parent) {
+        this.parent = parent;
+      };
+
+      Operation.prototype.getParent = function() {
+        return this.parent;
+      };
+
+      Operation.prototype.getUid = function() {
+        return this.uid;
+      };
+
+      Operation.prototype.dontSync = function() {
+        return this.uid.doSync = false;
+      };
+
+      Operation.prototype.execute = function() {
+        var l, _i, _len;
+        this.is_executed = true;
+        if (this.uid == null) {
+          this.uid = HB.getNextOperationIdentifier();
+        }
+        HB.addOperation(this);
+        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.type = "Delete";
+
+      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.type = "Insert";
+
+      Insert.prototype.applyDelete = function(o) {
+        var callLater, garbagecollect, _ref;
+        if (this.deleted_by == null) {
+          this.deleted_by = [];
+        }
+        callLater = false;
+        if ((this.parent != null) && !this.isDeleted() && (o != null)) {
+          callLater = true;
+        }
+        if (o != null) {
+          this.deleted_by.push(o);
+        }
+        garbagecollect = false;
+        if (!((this.prev_cl != null) && (this.next_cl != null)) || this.prev_cl.isDeleted()) {
+          garbagecollect = true;
+        }
+        Insert.__super__.applyDelete.call(this, garbagecollect);
+        if (callLater) {
+          this.parent.callEvent([
+            {
+              type: "insert",
+              position: this.getPosition(),
+              object: this.parent,
+              changed_by: o.uid.creator
+            }
+          ]);
+        }
+        if ((_ref = this.next_cl) != null ? _ref.isDeleted() : void 0) {
+          return this.next_cl.applyDelete();
+        }
+      };
+
+      Insert.prototype.cleanup = function() {
+        var d, o, _i, _len, _ref, _ref1;
+        if ((_ref = this.prev_cl) != null ? _ref.isDeleted() : void 0) {
+          _ref1 = this.deleted_by;
+          for (_i = 0, _len = _ref1.length; _i < _len; _i++) {
+            d = _ref1[_i];
+            d.cleanup();
+          }
+          o = this.next_cl;
+          while (o.type !== "Delimiter") {
+            if (o.origin === this) {
+              o.origin = this.prev_cl;
+            }
+            o = o.next_cl;
+          }
+          this.prev_cl.next_cl = this.next_cl;
+          this.next_cl.prev_cl = this.prev_cl;
+          return Insert.__super__.cleanup.apply(this, arguments);
+        }
+      };
+
+      Insert.prototype.getDistanceToOrigin = function() {
+        var d, o;
+        d = 0;
+        o = this.prev_cl;
+        while (true) {
+          if (this.origin === o) {
+            break;
+          }
+          d++;
+          o = o.prev_cl;
+        }
+        return d;
+      };
+
+      Insert.prototype.execute = function() {
+        var distance_to_origin, i, o;
+        if (!this.validateSavedOperations()) {
+          return false;
+        } else {
+          if (this.prev_cl != null) {
+            distance_to_origin = this.getDistanceToOrigin();
+            o = this.prev_cl.next_cl;
+            i = distance_to_origin;
+            while (true) {
+              if (o !== this.next_cl) {
+                if (o.getDistanceToOrigin() === i) {
+                  if (o.uid.creator < this.uid.creator) {
+                    this.prev_cl = o;
+                    distance_to_origin = i + 1;
+                  } else {
+
+                  }
+                } else if (o.getDistanceToOrigin() < i) {
+                  if (i - distance_to_origin <= o.getDistanceToOrigin()) {
+                    this.prev_cl = o;
+                    distance_to_origin = i + 1;
+                  } else {
+
+                  }
+                } else {
+                  break;
+                }
+                i++;
+                o = o.next_cl;
+              } else {
+                break;
+              }
+            }
+            this.next_cl = this.prev_cl.next_cl;
+            this.prev_cl.next_cl = this;
+            this.next_cl.prev_cl = this;
+          }
+          this.setParent(this.prev_cl.getParent());
+          Insert.__super__.execute.apply(this, arguments);
+          this.callOperationSpecificEvents();
+          return this;
+        }
+      };
+
+      Insert.prototype.callOperationSpecificEvents = function() {
+        var _ref;
+        return (_ref = this.parent) != null ? _ref.callEvent([
+          {
+            type: "insert",
+            position: this.getPosition(),
+            object: this.parent,
+            changed_by: this.uid.creator
+          }
+        ]) : void 0;
+      };
+
+      Insert.prototype.getPosition = function() {
+        var position, prev;
+        position = 0;
+        prev = this.prev_cl;
+        while (true) {
+          if (prev instanceof Delimiter) {
+            break;
+          }
+          if (!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.type = "ImmutableObject";
+
+      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) {
+          json["origin"] = this.origin().getUid();
+        }
+        return json;
+      };
+
+      return ImmutableObject;
+
+    })(Operation);
+    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.type = "Delimiter";
+
+      Delimiter.prototype.applyDelete = function() {
+        var o;
+        Delimiter.__super__.applyDelete.call(this);
+        o = this.next_cl;
+        while (o != null) {
+          o.applyDelete();
+          o = o.next_cl;
+        }
+        return void 0;
+      };
+
+      Delimiter.prototype.cleanup = function() {
+        return Delimiter.__super__.cleanup.call(this);
+      };
+
+      Delimiter.prototype.execute = function() {
+        var _ref, _ref1;
+        if (((_ref = this.unchecked) != null ? _ref['next_cl'] : void 0) != null) {
+          return Delimiter.__super__.execute.apply(this, arguments);
+        } else if ((_ref1 = this.unchecked) != null ? _ref1['prev_cl'] : void 0) {
+          if (this.validateSavedOperations()) {
+            if (this.prev_cl.next_cl != null) {
+              throw new Error("Probably duplicated operations");
+            }
+            this.prev_cl.next_cl = this;
+            return Delimiter.__super__.execute.apply(this, arguments);
+          } else {
+            return false;
+          }
+        } else if ((this.prev_cl != null) && (this.prev_cl.next_cl == null)) {
+          delete this.prev_cl.unchecked.next_cl;
+          this.prev_cl.next_cl = this;
+          return Delimiter.__super__.execute.apply(this, arguments);
+        } else if ((this.prev_cl != null) || (this.next_cl != null) || true) {
+          return Delimiter.__super__.execute.apply(this, arguments);
+        }
+      };
+
+      Delimiter.prototype._encode = function() {
+        var _ref, _ref1;
+        return {
+          'type': "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
+    };
+  };
+
+}).call(this);
+
+//# sourceMappingURL=../Types/BasicTypes.js.map

build/node/Types/JsonTypes.js

@@ -0,0 +1,246 @@
+(function() {
+  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, createJsonTypeWrapper, parser, text_types, types;
+    text_types = text_types_uninitialized(HB);
+    types = text_types.types;
+    parser = text_types.parser;
+    createJsonTypeWrapper = function(_jsonType) {
+      var JsonTypeWrapper;
+      JsonTypeWrapper = (function() {
+        function JsonTypeWrapper(jsonType) {
+          var name, obj, _fn, _ref;
+          _ref = jsonType.map;
+          _fn = function(name, obj) {
+            return Object.defineProperty(JsonTypeWrapper.prototype, name, {
+              get: function() {
+                var x;
+                x = obj.val();
+                if (x instanceof JsonType) {
+                  return createJsonTypeWrapper(x);
+                } else if (x instanceof types.ImmutableObject) {
+                  return x.val();
+                } else {
+                  return x;
+                }
+              },
+              set: function(o) {
+                var o_name, o_obj, overwrite, _results;
+                overwrite = jsonType.val(name);
+                if (o.constructor === {}.constructor && overwrite instanceof types.Operation) {
+                  _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 JsonTypeWrapper;
+
+      })();
+      return new JsonTypeWrapper(_jsonType);
+    };
+    JsonType = (function(_super) {
+      __extends(JsonType, _super);
+
+      function JsonType() {
+        return JsonType.__super__.constructor.apply(this, arguments);
+      }
+
+      JsonType.prototype.type = "JsonType";
+
+      JsonType.prototype.applyDelete = function() {
+        return JsonType.__super__.applyDelete.call(this);
+      };
+
+      JsonType.prototype.cleanup = function() {
+        return JsonType.__super__.cleanup.call(this);
+      };
+
+      JsonType.prototype.toJson = function() {
+        var json, name, o, that, val;
+        if ((this.bound_json == null) || (Object.observe == null) || true) {
+          val = this.val();
+          json = {};
+          for (name in val) {
+            o = val[name];
+            if (o == null) {
+              json[name] = o;
+            } else if (o.constructor === {}.constructor) {
+              json[name] = this.val(name).toJson();
+            } else if (o instanceof types.Operation) {
+              while (o instanceof types.Operation) {
+                o = o.val();
+              }
+              json[name] = o;
+            } else {
+              json[name] = o;
+            }
+          }
+          this.bound_json = json;
+          if (Object.observe != null) {
+            that = this;
+            Object.observe(this.bound_json, function(events) {
+              var event, _i, _len, _results;
+              _results = [];
+              for (_i = 0, _len = events.length; _i < _len; _i++) {
+                event = events[_i];
+                if ((event.changed_by == null) && (event.type === "add" || (event.type = "update"))) {
+                  _results.push(that.val(event.name, event.object[event.name]));
+                } else {
+                  _results.push(void 0);
+                }
+              }
+              return _results;
+            });
+            this.observe(function(events) {
+              var event, notifier, oldVal, _i, _len, _results;
+              _results = [];
+              for (_i = 0, _len = events.length; _i < _len; _i++) {
+                event = events[_i];
+                if (event.created_ !== HB.getUserId()) {
+                  notifier = Object.getNotifier(that.bound_json);
+                  oldVal = that.bound_json[event.name];
+                  if (oldVal != null) {
+                    notifier.performChange('update', function() {
+                      return that.bound_json[event.name] = that.val(event.name);
+                    }, that.bound_json);
+                    _results.push(notifier.notify({
+                      object: that.bound_json,
+                      type: 'update',
+                      name: event.name,
+                      oldValue: oldVal,
+                      changed_by: event.changed_by
+                    }));
+                  } else {
+                    notifier.performChange('add', function() {
+                      return that.bound_json[event.name] = that.val(event.name);
+                    }, that.bound_json);
+                    _results.push(notifier.notify({
+                      object: that.bound_json,
+                      type: 'add',
+                      name: event.name,
+                      oldValue: oldVal,
+                      changed_by: event.changed_by
+                    }));
+                  }
+                } else {
+                  _results.push(void 0);
+                }
+              }
+              return _results;
+            });
+          }
+        }
+        return this.bound_json;
+      };
+
+      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, n, o, word;
+        if ((name != null) && arguments.length > 1) {
+          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 ((content == null) || (((!mutable) || typeof content === 'number') && content.constructor !== Object)) {
+            return JsonType.__super__.val.call(this, name, (new types.ImmutableObject(void 0, content)).execute());
+          } else {
+            if (typeof content === 'string') {
+              word = (new types.WordType(void 0)).execute();
+              word.insertText(0, content);
+              return JsonType.__super__.val.call(this, name, word);
+            } else if (content.constructor === Object) {
+              json = new JsonType().execute();
+              for (n in content) {
+                o = content[n];
+                json.val(n, o, mutable);
+              }
+              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 createJsonTypeWrapper(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;
+  };
+
+}).call(this);
+
+//# sourceMappingURL=../Types/JsonTypes.js.map

build/node/Types/StructuredTypes.js

@@ -0,0 +1,401 @@
+(function() {
+  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.type = "MapManager";
+
+      MapManager.prototype.applyDelete = function() {
+        var name, p, _ref;
+        _ref = this.map;
+        for (name in _ref) {
+          p = _ref[name];
+          p.applyDelete();
+        }
+        return MapManager.__super__.applyDelete.call(this);
+      };
+
+      MapManager.prototype.cleanup = function() {
+        return MapManager.__super__.cleanup.call(this);
+      };
+
+      MapManager.prototype.val = function(name, content) {
+        var o, obj, qqq, result, x, _ref, _ref1;
+        if (content != null) {
+          if (this.map[name] == null) {
+            (new AddName(void 0, this, name)).execute();
+          }
+          if (this.map[name] === null) {
+            qqq = this;
+            x = new AddName(void 0, this, name);
+            x.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.type = "AddName";
+
+      AddName.prototype.applyDelete = function() {
+        return AddName.__super__.applyDelete.call(this);
+      };
+
+      AddName.prototype.cleanup = function() {
+        return AddName.__super__.cleanup.call(this);
+      };
+
+      AddName.prototype.execute = function() {
+        var beg, clone, end, event_properties, event_this, uid_beg, uid_end, uid_r, _base;
+        if (!this.validateSavedOperations()) {
+          return false;
+        } else {
+          clone = function(o) {
+            var name, p, value;
+            p = {};
+            for (name in o) {
+              value = o[name];
+              p[name] = value;
+            }
+            return p;
+          };
+          uid_r = clone(this.map_manager.getUid());
+          uid_r.doSync = false;
+          uid_r.op_number = "_" + uid_r.op_number + "_RM_" + this.name;
+          if (HB.getOperation(uid_r) == null) {
+            uid_beg = clone(uid_r);
+            uid_beg.op_number = "" + uid_r.op_number + "_beginning";
+            uid_end = clone(uid_r);
+            uid_end.op_number = "" + uid_r.op_number + "_end";
+            beg = (new types.Delimiter(uid_beg, void 0, uid_end)).execute();
+            end = (new types.Delimiter(uid_end, beg, void 0)).execute();
+            event_properties = {
+              name: this.name
+            };
+            event_this = this.map_manager;
+            this.map_manager.map[this.name] = new ReplaceManager(event_properties, event_this, uid_r, beg, end);
+            this.map_manager.map[this.name].setParent(this.map_manager, this.name);
+            ((_base = this.map_manager.map[this.name]).add_name_ops != null ? _base.add_name_ops : _base.add_name_ops = []).push(this);
+            this.map_manager.map[this.name].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 = new types.Delimiter(void 0, void 0, void 0);
+          this.end = 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.type = "ListManager";
+
+      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 || o.isDeleted()) && !(o instanceof types.Delimiter)) {
+          while (o.isDeleted() && !(o instanceof types.Delimiter)) {
+            o = o.next_cl;
+          }
+          while (true) {
+            if (o instanceof types.Delimiter) {
+              break;
+            }
+            if (position <= 0 && !o.isDeleted()) {
+              break;
+            }
+            o = o.next_cl;
+            if (!o.isDeleted()) {
+              position -= 1;
+            }
+          }
+        }
+        return o;
+      };
+
+      return ListManager;
+
+    })(types.Operation);
+    ReplaceManager = (function(_super) {
+      __extends(ReplaceManager, _super);
+
+      function ReplaceManager(event_porperties, event_this, uid, beginning, end, prev, next, origin) {
+        this.event_porperties = event_porperties;
+        this.event_this = event_this;
+        ReplaceManager.__super__.constructor.call(this, uid, beginning, end, prev, next, origin);
+      }
+
+      ReplaceManager.prototype.type = "ReplaceManager";
+
+      ReplaceManager.prototype.applyDelete = function() {
+        var o, _i, _len, _ref;
+        o = this.beginning;
+        while (o != null) {
+          o.applyDelete();
+          o = o.next_cl;
+        }
+        if (this.add_name_ops != null) {
+          _ref = this.add_name_ops;
+          for (_i = 0, _len = _ref.length; _i < _len; _i++) {
+            o = _ref[_i];
+            o.applyDelete();
+          }
+        }
+        return ReplaceManager.__super__.applyDelete.call(this);
+      };
+
+      ReplaceManager.prototype.cleanup = function() {
+        return ReplaceManager.__super__.cleanup.call(this);
+      };
+
+      ReplaceManager.prototype.callEventDecorator = function(events) {
+        var event, name, prop, _i, _len, _ref;
+        if (!this.isDeleted()) {
+          _ref = this.event_porperties;
+          for (name in _ref) {
+            prop = _ref[name];
+            for (_i = 0, _len = events.length; _i < _len; _i++) {
+              event = events[_i];
+              event[name] = prop;
+            }
+          }
+          this.event_this.callEvent(events);
+        }
+        return void 0;
+      };
+
+      ReplaceManager.prototype.replace = function(content, replaceable_uid) {
+        var o;
+        o = this.getLastOperation();
+        (new Replaceable(content, this, replaceable_uid, o, o.next_cl)).execute();
+        return void 0;
+      };
+
+      ReplaceManager.prototype.val = function() {
+        var o;
+        o = this.getLastOperation();
+        return typeof o.val === "function" ? o.val() : void 0;
+      };
+
+      ReplaceManager.prototype._encode = function() {
+        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) {
+          json["origin"] = this.origin().getUid();
+        }
+        return json;
+      };
+
+      return ReplaceManager;
+
+    })(ListManager);
+    parser["ReplaceManager"] = function(json) {
+      var beginning, end, next, origin, prev, uid;
+      uid = json['uid'], prev = json['prev'], next = json['next'], origin = json['origin'], beginning = json['beginning'], end = json['end'];
+      return new ReplaceManager(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))) {
+          throw new Error("You must define prev, and next for Replaceable-types!");
+        }
+        Replaceable.__super__.constructor.call(this, uid, prev, next, origin);
+      }
+
+      Replaceable.prototype.type = "Replaceable";
+
+      Replaceable.prototype.val = function() {
+        return this.content;
+      };
+
+      Replaceable.prototype.applyDelete = function() {
+        if (this.content != null) {
+          if (this.next_cl.type !== "Delimiter") {
+            this.content.deleteAllObservers();
+          }
+          this.content.applyDelete();
+          this.content.dontSync();
+        }
+        this.content = null;
+        return Replaceable.__super__.applyDelete.apply(this, arguments);
+      };
+
+      Replaceable.prototype.cleanup = function() {
+        return Replaceable.__super__.cleanup.apply(this, arguments);
+      };
+
+      Replaceable.prototype.callOperationSpecificEvents = function() {
+        var old_value;
+        if (this.next_cl.type === "Delimiter" && this.prev_cl.type !== "Delimiter") {
+          old_value = this.prev_cl.content;
+          this.prev_cl.applyDelete();
+          this.parent.callEventDecorator([
+            {
+              type: "update",
+              changed_by: this.uid.creator,
+              oldValue: old_value
+            }
+          ]);
+        } else if (this.next_cl.type !== "Delimiter") {
+          this.applyDelete();
+        } else {
+          this.parent.callEventDecorator([
+            {
+              type: "add",
+              changed_by: this.uid.creator
+            }
+          ]);
+        }
+        return void 0;
+      };
+
+      Replaceable.prototype._encode = function() {
+        var json, _ref;
+        json = {
+          'type': "Replaceable",
+          'content': (_ref = this.content) != null ? _ref.getUid() : void 0,
+          '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;
+  };
+
+}).call(this);
+
+//# sourceMappingURL=../Types/StructuredTypes.js.map

build/node/Types/TextTypes.js

@@ -0,0 +1,342 @@
+(function() {
+  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, WordType, 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) {
+        var _ref;
+        if (content != null ? (_ref = content.uid) != null ? _ref.creator : void 0 : void 0) {
+          this.saveOperation('content', content);
+        } else {
+          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.type = "TextInsert";
+
+      TextInsert.prototype.getLength = function() {
+        if (this.isDeleted()) {
+          return 0;
+        } else {
+          return this.content.length;
+        }
+      };
+
+      TextInsert.prototype.applyDelete = function() {
+        TextInsert.__super__.applyDelete.apply(this, arguments);
+        if (this.content instanceof types.Operation) {
+          this.content.applyDelete();
+        }
+        return this.content = null;
+      };
+
+      TextInsert.prototype.execute = function() {
+        if (!this.validateSavedOperations()) {
+          return false;
+        } else {
+          if (this.content instanceof types.Operation) {
+            this.content.insert_parent = this;
+          }
+          return TextInsert.__super__.execute.call(this);
+        }
+      };
+
+      TextInsert.prototype.val = function(current_position) {
+        if (this.isDeleted() || (this.content == null)) {
+          return "";
+        } else {
+          return this.content;
+        }
+      };
+
+      TextInsert.prototype._encode = function() {
+        var json, _ref;
+        json = {
+          'type': "TextInsert",
+          'uid': this.getUid(),
+          'prev': this.prev_cl.getUid(),
+          'next': this.next_cl.getUid()
+        };
+        if (((_ref = this.content) != null ? _ref.getUid : void 0) != null) {
+          json['content'] = this.content.getUid();
+        } else {
+          json['content'] = this.content;
+        }
+        if (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);
+    };
+    WordType = (function(_super) {
+      __extends(WordType, _super);
+
+      function WordType(uid, beginning, end, prev, next, origin) {
+        WordType.__super__.constructor.call(this, uid, beginning, end, prev, next, origin);
+      }
+
+      WordType.prototype.type = "WordType";
+
+      WordType.prototype.applyDelete = function() {
+        var o;
+        o = this.beginning;
+        while (o != null) {
+          o.applyDelete();
+          o = o.next_cl;
+        }
+        return WordType.__super__.applyDelete.call(this);
+      };
+
+      WordType.prototype.cleanup = function() {
+        return WordType.__super__.cleanup.call(this);
+      };
+
+      WordType.prototype.push = function(content) {
+        return this.insertAfter(this.end.prev_cl, content);
+      };
+
+      WordType.prototype.insertAfter = function(left, content) {
+        var c, right, tmp, _i, _len;
+        while (left.isDeleted()) {
+          left = left.prev_cl;
+        }
+        right = left.next_cl;
+        if (content.type != null) {
+          (new TextInsert(content, void 0, left, right)).execute();
+        } else {
+          for (_i = 0, _len = content.length; _i < _len; _i++) {
+            c = content[_i];
+            tmp = (new TextInsert(c, void 0, left, right)).execute();
+            left = tmp;
+          }
+        }
+        return this;
+      };
+
+      WordType.prototype.insertText = function(position, content) {
+        var ith, left;
+        ith = this.getOperationByPosition(position);
+        left = ith.prev_cl;
+        return this.insertAfter(left, content);
+      };
+
+      WordType.prototype.deleteText = function(position, length) {
+        var d, delete_ops, i, o, _i;
+        o = this.getOperationByPosition(position);
+        delete_ops = [];
+        for (i = _i = 0; 0 <= length ? _i < length : _i > length; i = 0 <= length ? ++_i : --_i) {
+          if (o instanceof types.Delimiter) {
+            break;
+          }
+          d = (new TextDelete(void 0, o)).execute();
+          o = o.next_cl;
+          while (!(o instanceof types.Delimiter) && o.isDeleted()) {
+            o = o.next_cl;
+          }
+          delete_ops.push(d._encode());
+        }
+        return this;
+      };
+
+      WordType.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('');
+      };
+
+      WordType.prototype.toString = function() {
+        return this.val();
+      };
+
+      WordType.prototype.bind = function(textfield) {
+        var word;
+        word = this;
+        textfield.value = this.val();
+        this.on("insert", 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);
+        });
+        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, new_pos, pos;
+          char = null;
+          if (event.key != null) {
+            if (event.charCode === 32) {
+              char = " ";
+            } else if (event.keyCode === 13) {
+              char = '\n';
+            } else {
+              char = event.key;
+            }
+          } else {
+            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);
+            word.insertText(pos, char);
+            new_pos = pos + char.length;
+            textfield.setSelectionRange(new_pos, new_pos);
+            return event.preventDefault();
+          } else {
+            return event.preventDefault();
+          }
+        };
+        textfield.onpaste = function(event) {
+          return event.preventDefault();
+        };
+        textfield.oncut = function(event) {
+          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);
+              textfield.setSelectionRange(pos, pos);
+            } 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);
+              textfield.setSelectionRange(pos, pos);
+            } else {
+              word.deleteText(pos, 1);
+              textfield.setSelectionRange(pos, pos);
+            }
+            return event.preventDefault();
+          }
+        };
+      };
+
+      WordType.prototype._encode = function() {
+        var json;
+        json = {
+          'type': "WordType",
+          '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) {
+          json["origin"] = this.origin().getUid();
+        }
+        return json;
+      };
+
+      return WordType;
+
+    })(types.ListManager);
+    parser['WordType'] = 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 WordType(uid, beginning, end, prev, next, origin);
+    };
+    types['TextInsert'] = TextInsert;
+    types['TextDelete'] = TextDelete;
+    types['WordType'] = WordType;
+    return structured_types;
+  };
+
+}).call(this);
+
+//# sourceMappingURL=../Types/TextTypes.js.map

build/node/Types/XmlTypes.js

@@ -0,0 +1,409 @@
+(function() {
+  var dont_proxy, json_types_uninitialized, proxy_token, _proxy,
+    __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; };
+
+  json_types_uninitialized = require("./JsonTypes");
+
+  proxy_token = false;
+
+  dont_proxy = function(f) {
+    var e;
+    proxy_token = true;
+    try {
+      f();
+    } catch (_error) {
+      e = _error;
+      proxy_token = false;
+      throw new Error(e);
+    }
+    return proxy_token = false;
+  };
+
+  _proxy = function(f_name, f) {
+    var old_f;
+    old_f = this[f_name];
+    if (old_f != null) {
+      return this[f_name] = function() {
+        var args, that, _ref;
+        if (!proxy_token && !((_ref = this._yatta) != null ? _ref.isDeleted() : void 0)) {
+          that = this;
+          args = arguments;
+          return dont_proxy(function() {
+            f.apply(that, args);
+            return old_f.apply(that, args);
+          });
+        } else {
+          return old_f.apply(this, arguments);
+        }
+      };
+    }
+  };
+
+  if (typeof Element !== "undefined" && Element !== null) {
+    Element.prototype._proxy = _proxy;
+  }
+
+  module.exports = function(HB) {
+    var TextNodeType, XmlType, json_types, parser, types;
+    json_types = json_types_uninitialized(HB);
+    types = json_types.types;
+    parser = json_types.parser;
+    XmlType = (function(_super) {
+      __extends(XmlType, _super);
+
+      function XmlType(uid, tagname, attributes, elements, xml) {
+        var attr, d, element, i, n, word, _i, _j, _len, _ref, _ref1, _ref2;
+        this.tagname = tagname;
+        this.xml = xml;
+
+        /* In case you make this instanceof Insert again
+        if prev? and (not next?) and prev.type?
+           * adjust what you actually mean. you want to insert after prev, then
+           * next is not defined. but we only insert after non-deleted elements.
+           * This is also handled in TextInsert.
+          while prev.isDeleted()
+            prev = prev.prev_cl
+          next = prev.next_cl
+         */
+        XmlType.__super__.constructor.call(this, uid);
+        if (((_ref = this.xml) != null ? _ref._yatta : void 0) != null) {
+          d = new types.Delete(void 0, this.xml._yatta);
+          HB.addOperation(d).execute();
+          this.xml._yatta = null;
+        }
+        if ((attributes != null) && (elements != null)) {
+          this.saveOperation('attributes', attributes);
+          this.saveOperation('elements', elements);
+        } else if ((attributes == null) && (elements == null)) {
+          this.attributes = new types.JsonType();
+          this.attributes.setMutableDefault('immutable');
+          HB.addOperation(this.attributes).execute();
+          this.elements = new types.WordType();
+          this.elements.parent = this;
+          HB.addOperation(this.elements).execute();
+        } else {
+          throw new Error("Either define attribute and elements both, or none of them");
+        }
+        if (this.xml != null) {
+          this.tagname = this.xml.tagName;
+          for (i = _i = 0, _ref1 = this.xml.attributes.length; 0 <= _ref1 ? _i < _ref1 : _i > _ref1; i = 0 <= _ref1 ? ++_i : --_i) {
+            attr = xml.attributes[i];
+            this.attributes.val(attr.name, attr.value);
+          }
+          _ref2 = this.xml.childNodes;
+          for (_j = 0, _len = _ref2.length; _j < _len; _j++) {
+            n = _ref2[_j];
+            if (n.nodeType === n.TEXT_NODE) {
+              word = new TextNodeType(void 0, n);
+              HB.addOperation(word).execute();
+              this.elements.push(word);
+            } else if (n.nodeType === n.ELEMENT_NODE) {
+              element = new XmlType(void 0, void 0, void 0, void 0, n);
+              HB.addOperation(element).execute();
+              this.elements.push(element);
+            } else {
+              throw new Error("I don't know Node-type " + n.nodeType + "!!");
+            }
+          }
+          this.setXmlProxy();
+        }
+        void 0;
+      }
+
+      XmlType.prototype.type = "XmlType";
+
+      XmlType.prototype.applyDelete = function(op) {
+        if ((this.insert_parent != null) && !this.insert_parent.isDeleted()) {
+          return this.insert_parent.applyDelete(op);
+        } else {
+          this.attributes.applyDelete();
+          this.elements.applyDelete();
+          return XmlType.__super__.applyDelete.apply(this, arguments);
+        }
+      };
+
+      XmlType.prototype.cleanup = function() {
+        return XmlType.__super__.cleanup.call(this);
+      };
+
+      XmlType.prototype.setXmlProxy = function() {
+        var findNode, insertBefore, removeChild, renewClassList, that;
+        this.xml._yatta = this;
+        that = this;
+        this.elements.on('insert', function(event, op) {
+          var newNode, right, rightNode;
+          if (op.creator !== HB.getUserId() && this === that.elements) {
+            newNode = op.content.val();
+            right = op.next_cl;
+            while ((right != null) && right.isDeleted()) {
+              right = right.next_cl;
+            }
+            rightNode = null;
+            if (right.type !== 'Delimiter') {
+              rightNode = right.val().val();
+            }
+            return dont_proxy(function() {
+              return that.xml.insertBefore(newNode, rightNode);
+            });
+          }
+        });
+        this.elements.on('delete', function(event, op) {
+          var del_op, deleted;
+          del_op = op.deleted_by[0];
+          if ((del_op != null) && del_op.creator !== HB.getUserId() && this === that.elements) {
+            deleted = op.content.val();
+            return dont_proxy(function() {
+              return that.xml.removeChild(deleted);
+            });
+          }
+        });
+        this.attributes.on(['add', 'update'], function(event, property_name, op) {
+          if (op.creator !== HB.getUserId() && this === that.attributes) {
+            return dont_proxy(function() {
+              var newval;
+              newval = op.val().val();
+              if (newval != null) {
+                return that.xml.setAttribute(property_name, op.val().val());
+              } else {
+                return that.xml.removeAttribute(property_name);
+              }
+            });
+          }
+        });
+        findNode = function(child) {
+          var elem;
+          if (child == null) {
+            throw new Error("you must specify a parameter!");
+          }
+          child = child._yatta;
+          elem = that.elements.beginning.next_cl;
+          while (elem.type !== 'Delimiter' && elem.content !== child) {
+            elem = elem.next_cl;
+          }
+          if (elem.type === 'Delimiter') {
+            return false;
+          } else {
+            return elem;
+          }
+        };
+        insertBefore = function(insertedNode_s, adjacentNode) {
+          var child, element, inserted_nodes, next, prev, _results;
+          next = null;
+          if (adjacentNode != null) {
+            next = findNode(adjacentNode);
+          }
+          prev = null;
+          if (next) {
+            prev = next.prev_cl;
+          } else {
+            prev = this._yatta.elements.end.prev_cl;
+            while (prev.isDeleted()) {
+              prev = prev.prev_cl;
+            }
+          }
+          inserted_nodes = null;
+          if (insertedNode_s.nodeType === insertedNode_s.DOCUMENT_FRAGMENT_NODE) {
+            child = insertedNode_s.lastChild;
+            _results = [];
+            while (child != null) {
+              element = new XmlType(void 0, void 0, void 0, void 0, child);
+              HB.addOperation(element).execute();
+              that.elements.insertAfter(prev, element);
+              _results.push(child = child.previousSibling);
+            }
+            return _results;
+          } else {
+            element = new XmlType(void 0, void 0, void 0, void 0, insertedNode_s);
+            HB.addOperation(element).execute();
+            return that.elements.insertAfter(prev, element);
+          }
+        };
+        this.xml._proxy('insertBefore', insertBefore);
+        this.xml._proxy('appendChild', insertBefore);
+        this.xml._proxy('removeAttribute', function(name) {
+          return that.attributes.val(name, void 0);
+        });
+        this.xml._proxy('setAttribute', function(name, value) {
+          return that.attributes.val(name, value);
+        });
+        renewClassList = function(newclass) {
+          var dont_do_it, elem, value, _i, _len;
+          dont_do_it = false;
+          if (newclass != null) {
+            for (_i = 0, _len = this.length; _i < _len; _i++) {
+              elem = this[_i];
+              if (newclass === elem) {
+                dont_do_it = true;
+              }
+            }
+          }
+          value = Array.prototype.join.call(this, " ");
+          if ((newclass != null) && !dont_do_it) {
+            value += " " + newclass;
+          }
+          return that.attributes.val('class', value);
+        };
+        _proxy.call(this.xml.classList, 'add', renewClassList);
+        _proxy.call(this.xml.classList, 'remove', renewClassList);
+        this.xml.__defineSetter__('className', function(val) {
+          return this.setAttribute('class', val);
+        });
+        this.xml.__defineGetter__('className', function() {
+          return that.attributes.val('class');
+        });
+        this.xml.__defineSetter__('textContent', function(val) {
+          var elem, remove, text_node;
+          elem = that.xml.firstChild;
+          while (elem != null) {
+            remove = elem;
+            elem = elem.nextSibling;
+            that.xml.removeChild(remove);
+          }
+          if (val !== "") {
+            text_node = document.createTextNode(val);
+            return that.xml.appendChild(text_node);
+          }
+        });
+        removeChild = function(node) {
+          var d, elem;
+          elem = findNode(node);
+          if (!elem) {
+            throw new Error("You are only allowed to delete existing (direct) child elements!");
+          }
+          d = new types.Delete(void 0, elem);
+          HB.addOperation(d).execute();
+          return node._yatta = null;
+        };
+        this.xml._proxy('removeChild', removeChild);
+        return this.xml._proxy('replaceChild', function(insertedNode, replacedNode) {
+          insertBefore.call(this, insertedNode, replacedNode);
+          return removeChild.call(this, replacedNode);
+        });
+      };
+
+      XmlType.prototype.val = function(enforce) {
+        var a, attr, attr_name, e, n, text_node, value;
+        if (enforce == null) {
+          enforce = false;
+        }
+        if (typeof document !== "undefined" && document !== null) {
+          if ((this.xml == null) || enforce) {
+            this.xml = document.createElement(this.tagname);
+            attr = this.attributes.val();
+            for (attr_name in attr) {
+              value = attr[attr_name];
+              if (value != null) {
+                a = document.createAttribute(attr_name);
+                a.value = value;
+                this.xml.setAttributeNode(a);
+              }
+            }
+            e = this.elements.beginning.next_cl;
+            while (e.type !== "Delimiter") {
+              n = e.content;
+              if (!e.isDeleted() && (e.content != null)) {
+                if (n.type === "XmlType") {
+                  this.xml.appendChild(n.val(enforce));
+                } else if (n.type === "TextNodeType") {
+                  text_node = n.val();
+                  this.xml.appendChild(text_node);
+                } else {
+                  throw new Error("Internal structure cannot be transformed to dom");
+                }
+              }
+              e = e.next_cl;
+            }
+          }
+          this.setXmlProxy();
+          return this.xml;
+        }
+      };
+
+      XmlType.prototype.execute = function() {
+        return XmlType.__super__.execute.call(this);
+      };
+
+
+      /*
+        if not @validateSavedOperations()
+          return false
+        else
+      
+          return true
+       */
+
+      XmlType.prototype.getParent = function() {
+        return this.parent;
+      };
+
+      XmlType.prototype._encode = function() {
+        var json;
+        json = {
+          'type': this.type,
+          'attributes': this.attributes.getUid(),
+          'elements': this.elements.getUid(),
+          'tagname': this.tagname,
+          'uid': this.getUid()
+        };
+        return json;
+      };
+
+      return XmlType;
+
+    })(types.Insert);
+    parser['XmlType'] = function(json) {
+      var attributes, elements, tagname, uid;
+      uid = json['uid'], attributes = json['attributes'], elements = json['elements'], tagname = json['tagname'];
+      return new XmlType(uid, tagname, attributes, elements, void 0);
+    };
+    TextNodeType = (function(_super) {
+      __extends(TextNodeType, _super);
+
+      function TextNodeType(uid, content) {
+        var d;
+        if (content._yatta != null) {
+          d = new types.Delete(void 0, content._yatta);
+          HB.addOperation(d).execute();
+          content._yatta = null;
+        }
+        content._yatta = this;
+        TextNodeType.__super__.constructor.call(this, uid, content);
+      }
+
+      TextNodeType.prototype.applyDelete = function(op) {
+        if ((this.insert_parent != null) && !this.insert_parent.isDeleted()) {
+          return this.insert_parent.applyDelete(op);
+        } else {
+          return TextNodeType.__super__.applyDelete.apply(this, arguments);
+        }
+      };
+
+      TextNodeType.prototype.type = "TextNodeType";
+
+      TextNodeType.prototype._encode = function() {
+        var json;
+        json = {
+          'type': this.type,
+          'uid': this.getUid(),
+          'content': this.content.textContent
+        };
+        return json;
+      };
+
+      return TextNodeType;
+
+    })(types.ImmutableObject);
+    parser['TextNodeType'] = function(json) {
+      var content, textnode, uid;
+      uid = json['uid'], content = json['content'];
+      textnode = document.createTextNode(content);
+      return new TextNodeType(uid, textnode);
+    };
+    types['XmlType'] = XmlType;
+    return json_types;
+  };
+
+}).call(this);
+
+//# sourceMappingURL=../Types/XmlTypes.js.map

build/node/Yatta.js

@@ -1,5 +1,7 @@
 (function() {
-  var Engine, HistoryBuffer, Yatta, adaptConnector, json_types_uninitialized;
+  var Engine, HistoryBuffer, adaptConnector, createYatta, json_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; };
 
   json_types_uninitialized = require("./Types/JsonTypes");
 
@@ -9,89 +11,35 @@
 
   adaptConnector = require("./ConnectorAdapter");
 
-  Yatta = (function() {
-    function Yatta(connector) {
-      var beg, end, first_word, type_manager, uid_beg, uid_end, user_id;
-      this.connector = connector;
-      user_id = this.connector.id;
-      this.HB = new HistoryBuffer(user_id);
-      type_manager = json_types_uninitialized(this.HB);
-      this.types = type_manager.types;
-      this.engine = new Engine(this.HB, type_manager.parser);
-      this.HB.engine = this.engine;
-      adaptConnector(this.connector, this.engine, this.HB, type_manager.execution_listener);
-      first_word = new this.types.JsonType(this.HB.getReservedUniqueIdentifier()).execute();
-      uid_beg = this.HB.getReservedUniqueIdentifier();
-      uid_end = this.HB.getReservedUniqueIdentifier();
-      beg = (new this.types.Delimiter(uid_beg, void 0, uid_end)).execute();
-      end = (new this.types.Delimiter(uid_end, beg, void 0)).execute();
-      this.root_element = (new this.types.ReplaceManager(void 0, this.HB.getReservedUniqueIdentifier(), beg, end)).execute();
-      this.root_element.replace(first_word, this.HB.getReservedUniqueIdentifier());
-    }
+  createYatta = function(connector) {
+    var HB, Yatta, type_manager, types, user_id;
+    user_id = connector.id;
+    HB = new HistoryBuffer(user_id);
+    type_manager = json_types_uninitialized(HB);
+    types = type_manager.types;
+    Yatta = (function(_super) {
+      __extends(Yatta, _super);
 
-    Yatta.prototype.getSharedObject = function() {
-      return this.root_element.val();
-    };
-
-    Yatta.prototype.getConnector = function() {
-      return this.connector;
-    };
-
-    Yatta.prototype.getHistoryBuffer = function() {
-      return this.HB;
-    };
-
-    Yatta.prototype.setMutableDefault = function(mutable) {
-      return this.getSharedObject().setMutableDefault(mutable);
-    };
-
-    Yatta.prototype.getUserId = function() {
-      return this.HB.getUserId();
-    };
-
-    Yatta.prototype.toJson = function() {
-      return this.getSharedObject().toJson();
-    };
-
-    Yatta.prototype.val = function() {
-      var _ref;
-      return (_ref = this.getSharedObject()).val.apply(_ref, arguments);
-    };
-
-    Yatta.prototype.on = function() {
-      var _ref;
-      return (_ref = this.getSharedObject()).on.apply(_ref, arguments);
-    };
-
-    Yatta.prototype.deleteListener = function() {
-      var _ref;
-      return (_ref = this.getSharedObject()).deleteListener.apply(_ref, arguments);
-    };
-
-    Object.defineProperty(Yatta.prototype, 'value', {
-      get: function() {
-        return this.getSharedObject().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!");
-        }
+      function Yatta() {
+        this.connector = connector;
+        this.HB = HB;
+        this.types = types;
+        this.engine = new Engine(this.HB, type_manager.parser);
+        adaptConnector(this.connector, this.engine, this.HB, type_manager.execution_listener);
+        Yatta.__super__.constructor.apply(this, arguments);
       }
-    });
 
-    return Yatta;
+      Yatta.prototype.getConnector = function() {
+        return this.connector;
+      };
 
-  })();
+      return Yatta;
 
-  module.exports = Yatta;
+    })(types.JsonType);
+    return new Yatta(HB.getReservedUniqueIdentifier()).execute();
+  };
+
+  module.exports = createYatta;
 
   if ((typeof window !== "undefined" && window !== null) && (window.Yatta == null)) {
     window.Yatta = Yatta;

build/test/index.html

@@ -13,12 +13,13 @@
     mocha.ui('bdd');
     mocha.reporter('html');
   </script>
-  <!--script src="TextYatta_test.js"></script-->
+  <script src="TextYatta_test.js"></script>
   <script src="JsonYatta_test.js"></script>
   <!--script src="XmlYatta_test_browser.js"></script-->
   <script>
     //mocha.checkLeaks();
     //mocha.run();
+    window.onerror = null;
     if (window.mochaPhantomJS) { mochaPhantomJS.run(); }
     else { mocha.run(); }
   </script>