13.0.0-85

implement support for boolean values. fixes #151
remove examples. fixes #149
2019-05-25 03:13:54 +02:00 · 2019-05-25 03:12:56 +02:00 · 2019-05-22 17:32:51 +02:00 · 2019-05-22 01:26:13 +02:00 · 2019-05-19 21:49:36 +02:00 · 2019-05-19 21:48:09 +02:00
79 changed files with 14494 additions and 5554 deletions
--- a/.bowerrc
+++ b/.bowerrc
@@ -1,3 +0,0 @@
-{
- "directory": "../"
-}
--- a/.gitignore
+++ b/.gitignore
@@ -1,12 +1,4 @@
 node_modules
-bower_components
-build
-build_test
-.directory
-.codio
-.settings
-.jshintignore
-.jshintrc
-.validate.json
-/y.js
-/y.js.map
+dist
+.vscode
+docs
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,4 +0,0 @@
-[submodule "dist"]
-	path = dist
-	url = https://github.com/y-js/yjs.git
-	branch = dist
--- a/.jsdoc.json
+++ b/.jsdoc.json
@@ -0,0 +1,50 @@
+{
+  "sourceType": "module",
+  "tags": {
+    "allowUnknownTags": true,
+    "dictionaries": ["jsdoc"]
+  },
+  "source": {
+    "include": ["./src"],
+    "includePattern": ".js$"
+  },
+  "plugins": [
+    "plugins/markdown"
+  ],
+  "templates": {
+    "referenceTitle": "Yjs",
+    "disableSort": false,
+    "useCollapsibles": true,
+    "collapse": true,
+    "resources": {
+      "y-js.org": "yjs.website"
+    },
+    "logo": {
+      "url": "https://user-images.githubusercontent.com/5553757/48975307-61efb100-f06d-11e8-9177-ee895e5916e5.png",
+      "width": "162px",
+      "height": "162px",
+      "link": "/"
+    },
+    "tabNames": {
+      "api": "API",
+      "tutorials": "Examples"
+    },
+    "footerText": "Shared Editing",
+    "css": [
+      "./style.css"
+    ],
+    "default": {
+      "staticFiles": {
+          "include": ["examples/"]
+      }
+    }
+  },
+  "opts": {
+    "destination": "./docs/",
+    "encoding": "utf8",
+    "private": false,
+    "recurse": true,
+    "template": "./node_modules/tui-jsdoc-template",
+    "tutorials": "./examples"
+  }
+}
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,8 +0,0 @@
-language: node_js
-before_install:
-  - "npm install -g bower"
-node_js:
-  - "0.12"
-branches:
-  only:
-    - master
--- a/Examples/OfflineEditing/index.html
+++ b/Examples/OfflineEditing/index.html
@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<html>
-<body>
-  <button id="button">Disconnect</button>
-  <h1 id="contenteditable" contentEditable></h1>
-  <textarea style="width:80%;" rows=40 id="textfield"></textarea>
-
-  <script src="../../node_modules/simplewebrtc/simplewebrtc.bundle.js"></script>
-  <script src="../../y.js"></script>
-  <script src="./index.js"></script>
-</body>
-</html>
--- a/Examples/OfflineEditing/index.js
+++ b/Examples/OfflineEditing/index.js
@@ -1,50 +0,0 @@
-/* global Y */
-
-// create a shared object. This function call will return a promise!
-Y({
-  db: {
-    name: 'IndexedDB',
-    namespace: 'offlineEditingDemo'
-  },
-  connector: {
-    name: 'WebRTC',
-    room: 'offlineEditingDemo',
-    debug: true
-  }
-}).then(function (yconfig) {
-  // yconfig holds all the information about the shared object
-  window.yconfig = yconfig
-  // yconfig.root holds the shared element
-  window.y = yconfig.root
-
-  // now we bind the textarea and the contenteditable h1 element
-  // to a shared element
-  var textarea = document.getElementById('textfield')
-  var contenteditable = document.getElementById('contenteditable')
-  yconfig.root.observePath(['text'], function (text) {
-    // every time the 'text' property of the yconfig.root changes,
-    // this function is called. Then we bind it to the html elements
-    if (text != null) {
-      // when the text property is deleted, text may be undefined!
-      // This is why we have to check if text exists..
-      text.bind(textarea)
-      text.bind(contenteditable)
-    }
-  })
-  // create a shared TextBind
-  var textpromise = yconfig.root.get('text')
-  if (textpromise == null) {
-    yconfig.root.set('text', Y.TextBind)
-  }
-  // We also provide a button for disconnecting/reconnecting the shared element
-  var button = document.querySelector('#button')
-  button.onclick = function () {
-    if (button.innerText === 'Disconnect') {
-      yconfig.disconnect()
-      button.innerText = 'Reconnect'
-    } else {
-      yconfig.reconnect()
-      button.innerText = 'Disconnect'
-    }
-  }
-})
--- a/Examples/TextBind/index.html
+++ b/Examples/TextBind/index.html
@@ -1,12 +0,0 @@
-<!DOCTYPE html>
-<html>
-<body>
-  <button id="button">Disconnect</button>
-  <h1 id="contenteditable" contentEditable></h1>
-  <textarea style="width:80%;" rows=40 id="textfield"></textarea>
-
-  <script src="../../node_modules/simplewebrtc/simplewebrtc.bundle.js"></script>
-  <script src="../../y.js"></script>
-  <script src="./index.js"></script>
-</body>
-</html>
--- a/Examples/TextBind/index.js
+++ b/Examples/TextBind/index.js
@@ -1,47 +0,0 @@
-/* global Y */
-
-// create a shared object. This function call will return a promise!
-Y({
-  db: {
-    name: 'Memory'
-  },
-  connector: {
-    name: 'WebRTC',
-    room: 'TextBindDemo',
-    debug: true
-  }
-}).then(function (yconfig) {
-  // yconfig holds all the information about the shared object
-  window.yconfig = yconfig
-  // yconfig.root holds the shared element
-  window.y = yconfig.root
-
-  // now we bind the textarea and the contenteditable h1 element
-  // to a shared element
-  var textarea = document.getElementById('textfield')
-  var contenteditable = document.getElementById('contenteditable')
-  yconfig.root.observePath(['text'], function (text) {
-    // every time the 'text' property of the yconfig.root changes,
-    // this function is called. Then we bind it to the html elements
-    if (text != null) {
-      // when the text property is deleted, text may be undefined!
-      // This is why we have to check if text exists..
-      text.bind(textarea)
-      text.bind(contenteditable)
-    }
-  })
-  // create a shared TextBind
-  yconfig.root.set('text', Y.TextBind)
-
-  // We also provide a button for disconnecting/reconnecting the shared element
-  var button = document.querySelector('#button')
-  button.onclick = function () {
-    if (button.innerText === 'Disconnect') {
-      yconfig.disconnect()
-      button.innerText = 'Reconnect'
-    } else {
-      yconfig.reconnect()
-      button.innerText = 'Disconnect'
-    }
-  }
-})
--- a/README.md
+++ b/README.md
@@ -1,145 +1,300 @@

-# ![Yjs](http://y-js.org/files/layout/yjs.svg)
+# ![Yjs](https://user-images.githubusercontent.com/5553757/48975307-61efb100-f06d-11e8-9177-ee895e5916e5.png)

-[![Build Status](https://travis-ci.org/y-js/yjs.svg)](https://travis-ci.org/y-js/yjs)
+Yjs is a framework for offline-first p2p shared editing on structured data like
+text, richtext, json, or XML. It is fairly easy to get started, as Yjs hides
+most of the complexity of concurrent editing. For additional information, demos,
+and tutorials visit [y-js.org](http://y-js.org/).

-Yjs is a framework for optimistic concurrency control and automatic conflict resolution on shared data types. The framework implements a new OT-like concurrency algorithm and provides similar functionality as [ShareJs] and [OpenCoweb]. Yjs was designed to handle concurrent actions on arbitrary complex data types like Text, Json, and XML. We provide a tutorial and some applications for this framework on our [homepage](http://y-js.org/).
+:warning: Checkout the [v13 docs](./README.v13.md) for the upcoming release :warning:

-You can create you own shared types easily. Therefore, you can take matters into your own hand by defining the meaning of the shared types and ensure that it is valid, while Yjs ensures data consistency (everyone will eventually end up with the same data). We already provide data types for
+### Extensions
+Yjs only knows how to resolve conflicts on shared data. You have to choose a ..
+* *Connector* - a communication protocol that propagates changes to the clients
+* *Database* - a database to store your changes
+* one or more *Types* - that represent the shared data

-| Name                                                 | Description
-| ---------------------------------------------------- | ---------------------------------------------
-y-object | Add, update, and remove properties of an object. Circular references are supported. Included in Yjs
-[y-list](https://github.com/y-js/y-list) | A shared linked list implementation. Circular references are supported
-[y-selections](https://github.com/y-js/y-selections) | Manages selections on types that use linear structures (e.g. the y-list type). You can select a range of elements and assign meaning to them.
-[y-xml](https://github.com/y-js/y-xml) | An implementation of the DOM. You can create a two way binding to Browser DOM objects
-[y-text](https://github.com/y-js/y-text) | Collaborate on text. You can create a two way binding to textareas, input elements, or HTML elements (e.g. *h1*, or *p*)
-[y-richtext](https://github.com/y-js/y-richtext) | Collaborate on rich text. You can create a two way binding to several editors
+Connectors, Databases, and Types are available as modules that extend Yjs. Here
+is a list of the modules we know of:

-Unlike other frameworks, Yjs supports P2P message propagation and is not bound to a specific communication protocol. Therefore, Yjs is extremely scalable and can be used in a wide range of application scenarios.
+##### Connectors

-We support several communication protocols as so called *Connectors*. You can create your own connector too - read [this wiki page](https://github.com/y-js/yjs/wiki/Custom-Connectors). Currently, we support the following communication protocols:
+|Name            | Description               |
+|----------------|-----------------------------------|
+|[webrtc](https://github.com/y-js/y-webrtc) | Propagate updates Browser2Browser via WebRTC|
+|[websockets](https://github.com/y-js/y-websockets-client) | Set up [a central server](https://github.com/y-js/y-websockets-client), and connect to it via websockets |
+|[xmpp](https://github.com/y-js/y-xmpp) | Propagate updates in a XMPP multi-user-chat room ([XEP-0045](http://xmpp.org/extensions/xep-0045.html))|
+|[ipfs](https://github.com/ipfs-labs/y-ipfs-connector) | Connector for the [Interplanetary File System](https://ipfs.io/)!|
+|[test](https://github.com/y-js/y-test) | A Connector for testing purposes. It is designed to simulate delays that happen in worst case scenarios|

-Name                                     | Description
---------------------------------------- | -------------------------------------------------------
-[y-xmpp](https://github.com/y-js/y-xmpp) | Propagate updates in a XMPP multi-user-chat room ([XEP-0045](http://xmpp.org/extensions/xep-0045.html))
-[y-webrtc](https://github.com/y-js/y-webrtc) | Propagate updates Browser2Browser via WebRTC
-[y-test](https://github.com/y-js/y-test) | A Connector for testing purposes. It is designed to simulate delays that happen in worst case scenarios
+##### Database adapters
+
+|Name            | Description               |
+|----------------|-----------------------------------|
+|[memory](https://github.com/y-js/y-memory) | In-memory storage. |
+|[indexeddb](https://github.com/y-js/y-indexeddb) | Offline storage for the browser |
+|[leveldb](https://github.com/y-js/y-leveldb) | Persistent storage for node apps |


-You can use Yjs client-, and server- side. You can get it as via npm, and bower. We even provide polymer elements for Yjs!
+##### Types

-The advantages over similar frameworks are support for
-* .. P2P message propagation and arbitrary communication protocols
-* .. arbitrary complex data types
-* .. offline editing: Changes are stored persistently and only relevant changes are propagated on rejoin
-* .. AnyUndo: Undo *any* action that was executed in constant time (coming..)
-* .. Intention Preservation: When working on Text, the intention of your changes are preserved. This is particularily important when working offline. Every type has a notion on how we define Intention Preservation on it.
+| Name     | Description       |
+|----------|-------------------|
+|[map](https://github.com/y-js/y-map) | A shared Map implementation. Maps from text to any stringify-able object |
+|[array](https://github.com/y-js/y-array) | A shared Array implementation |
+|[xml](https://github.com/y-js/y-xml) | An implementation of the DOM. You can create a two way binding to Browser DOM objects |
+|[text](https://github.com/y-js/y-text) | Collaborate on text. Supports two way binding to the [Ace Editor](https://ace.c9.io), [CodeMirror](https://codemirror.net/), [Monaco](https://github.com/Microsoft/monaco-editor), textareas, input elements, and HTML elements (e.g. <*h1*>, or <*p*>) |
+|[richtext](https://github.com/y-js/y-richtext) | Collaborate on rich text. Supports two way binding to the [Quill Rich Text Editor](http://quilljs.com/)|

+##### Other
+
+| Name      | Description       |
+|-----------|-------------------|
+|[y-element](http://y-js.org/y-element/) | Yjs Polymer Element |

 ## Use it!
-You can find a tutorial, and examples on the [website](http://y-js.org). Furthermore, the [github wiki](https://github.com/y-js/yjs/wiki) offers more information about how you can use Yjs in your application.
-
-Either clone this git repository, install it with [bower](http://bower.io/), or install it with [npm](https://www.npmjs.org/package/yjs).
+Install Yjs, and its modules with [bower](http://bower.io/), or
+[npm](https://www.npmjs.org/package/yjs).

 ### Bower
 ```
-bower install y-js/yjs
+bower install --save yjs y-array % add all y-* modules you want to use
 ```
-Then you include the libraries directly from the installation folder.
+You only need to include the `y.js` file. Yjs is able to automatically require
+missing modules.  
 ```
 <script src="./bower_components/yjs/y.js"></script>
 ```

+### CDN
+```
+<script src="https://cdn.jsdelivr.net/npm/yjs@12/dist/y.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/y-array@10/dist/y-array.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/y-websockets-client@8/dist/y-websockets-client.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/y-memory@8/dist/y-memory.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/y-map@10/dist/y-map.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/y-text@9/dist/y-text.js"></script>
+// ..
+// do the same for all modules you want to use
+```
+
 ### Npm
 ```
-npm install yjs --save
+npm install --save yjs % add all y-* modules you want to use
 ```

-And use it like this with *npm*:
+If you don't include via script tag, you have to explicitly include all modules!
+(Same goes for other module systems)
 ```
-Y = require("yjs");
+var Y = require('yjs')
+require('y-array')(Y) // add the y-array type to Yjs
+require('y-websockets-client')(Y)
+require('y-memory')(Y)
+require('y-map')(Y)
+require('y-text')(Y)
+// ..
+// do the same for all modules you want to use
 ```

-# Y()
-In order to create an instance of Y, you need to have a connection object (instance of a Connector). Then, you can create a shared data type like this:
+### ES6 Syntax
 ```
-var y = new Y(connector);
+import Y from 'yjs'
+import yArray from 'y-array'
+import yWebsocketsClient from 'y-webrtc'
+import yMemory from 'y-memory'
+import yMap from 'y-map'
+import yText from 'y-text'
+// ..
+Y.extend(yArray, yWebsocketsClient, yMemory, yArray, yMap, yText /*, .. */)
 ```

-
-# Y.Map
-Yjs includes only one type by default - the Y.Map type. It mimics the behaviour of a javascript Object. You can create, update, and remove properies on the Y.Map type. Furthermore, you can observe changes on this type as you can observe changes on Javascript Objects with [Object.observe](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/observe) - an ECMAScript 7 proposal which is likely to become accepted by the committee. Until then, we have our own implementation.
-
-
-##### Reference
-* Create
+# Text editing example
+Install dependencies
 ```
-var map = y.set("new_map", Y.Map).then(function(map){
-  map // is my map type
-});
+bower i yjs y-memory y-webrtc y-array y-text
 ```
-* Every instance of Y is an Y.Map
+
+Here is a simple example of a shared textarea
+```HTML
+  <!DOCTYPE html>
+  <html>
+    <body>
+      <script src="./bower_components/yjs/y.js"></script>
+      <!-- Yjs automatically includes all missing dependencies (browser only) -->
+      <script>
+        Y({
+          db: {
+            name: 'memory' // use memory database adapter.
+            // name: 'indexeddb' // use indexeddb database adapter instead for offline apps
+          },
+          connector: {
+            name: 'webrtc', // use webrtc connector
+            // name: 'websockets-client'
+            // name: 'xmpp'
+            room: 'my-room' // clients connecting to the same room share data
+          },
+          sourceDir: './bower_components', // location of the y-* modules (browser only)
+          share: {
+            textarea: 'Text' // y.share.textarea is of type y-text
+          }
+        }).then(function (y) {
+          // The Yjs instance `y` is available
+          // y.share.* contains the shared types
+
+          // Bind `y.share.textarea` to `<textarea/>`
+          y.share.textarea.bind(document.querySelector('textarea'))
+        })
+      </script>
+      <textarea></textarea>
+    </body>
+  </html>
 ```
-var y = new Y(options);
+
+## Get Help & Give Help
+There are some friendly people on [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/y-js/yjs?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) who are eager to help, and answer questions. Please join!
+
+Report _any_ issues to the
+[Github issue page](https://github.com/y-js/yjs/issues)! I try to fix them very
+soon, if possible.
+
+# API
+
+### Y(options)
+* Y.extend(module1, module2, ..)
+  * Add extensions to Y
+  * `Y.extend(require('y-webrtc'))` has the same semantics as
+    `require('y-webrtc')(Y)`
+* options.db
+  * Will be forwarded to the database adapter. Specify the database adaper on
+    `options.db.name`.
+  * Have a look at the used database adapter repository to see all available
+    options.
+* options.connector
+  * Will be forwarded to the connector adapter. Specify the connector adaper on
+    `options.connector.name`.
+  * All our connectors implement a `room` property. Clients that specify the
+    same room share the same data.
+  * All of our connectors specify an `url` property that defines the connection
+    endpoint of the used connector.
+    * All of our connectors also have a default connection endpoint that you can
+      use for development.
+  * Set `options.connector.generateUserId = true` in order to genenerate a
+    userid, instead of receiving one from the server. This way the `Y(..)` is
+    immediately going to be resolved, without waiting for any confirmation from
+    the server. Use with caution.
+  * Have a look at the used connector repository to see all available options.
+  * *Only if you know what you are doing:* Set
+    `options.connector.preferUntransformed = true` in order receive the shared
+    data untransformed. This is very efficient as the database content is simply
+    copied to this client. This does only work if this client receives content
+    from only one client.
+* options.sourceDir (browser only)
+  * Path where all y-* modules are stored
+  * Defaults to `/bower_components`
+  * Not required when running on `nodejs` / `iojs`
+  * When using nodejs you need to manually extend Yjs:
 ```
-* .get(name)
-  * Retrieve the value of a property. If the value is a type, `.get(name)` returns a promise
-* .set(name, value)
-  * Set/update a property. `value` may be a primitive type, or a custom type definition (e.g. `Y.Map`)
-* .delete(name)
-  * Delete a property
-* .observe(observer)
-  * The `observer` is called whenever something on this object changes. Throws *add*, *update*, and *delete* events
-* .observePath(path, observer)
-  * `path` is an array of property names. `observer` is called when the property under `path` is set, deleted, or updated
-* .unobserve(f)
-  * Delete an observer
+var Y = require('yjs')
+// you have to require a db, connector, and *all* types you use!
+require('y-memory')(Y)
+require('y-webrtc')(Y)
+require('y-map')(Y)
+// ..
+```
+* options.share
+  * Specify on `options.share[arbitraryName]` types that are shared among all
+    users.
+  * E.g. Specify `options.share[arbitraryName] = 'Array'` to require y-array and
+    create an y-array type on `y.share[arbitraryName]`.
+  * If userA doesn't specify `options.share[arbitraryName]`, it won't be
+    available for userA.
+  * If userB specifies `options.share[arbitraryName]`, it still won't be
+    available for userA. But all the updates are send from userB to userA.
+  * In contrast to y-map, types on `y.share.*` cannot be overwritten or deleted.
+    Instead, they are merged among all users. This feature is only available on
+    `y.share.*`
+  * Weird behavior: It is supported that two users specify different types with
+    the same property name.
+     E.g. userA specifies `options.share.x = 'Array'`, and userB specifies
+     `options.share.x = 'Text'`. But they only share data if they specified the
+     same type with the same property name
+* options.type (browser only)
+  * Array of modules that Yjs needs to require, before instantiating a shared
+    type.
+  * By default Yjs requires the specified database adapter, the specified
+    connector, and all modules that are used in `options.share.*`
+  * Put all types here that you intend to use, but are not used in y.share.*

-# A note on intention preservation
-When users create/update/delete the same property concurrently, only one change will prevail. Changes on different properties do not conflict with each other.
+### Instantiated Y object (y)
+`Y(options)` returns a promise that is fulfilled when..

-# A note on time complexities
-* .get(name)
-  * O(1)
-* .set(name, value)
-  * O(1)
-* .delete(name)
-  * O(1)
-* Apply a delete operation from another user
-  * O(1)
-* Apply an update operation from another user (set/update a property)
-  * Yjs does not transform against operations that do not conflict with each other.
-  * An operation conflicts with another operation if it changes the same property.
-  * Overall worst case complexety: O(|conflicts|!)
+* All modules are loaded
+  * The specified database adapter is loaded
+  * The specified connector is loaded
+  * All types are included
+* The connector is initialized, and a unique user id is set (received from the
+  server)
+  * Note: When using y-indexeddb, a retrieved user id is stored on `localStorage`

-# Status
-Yjs is a work in progress. Different versions of the *y-* repositories may not work together. Just drop me a line if you run into troubles.
+The promise returns an instance of Y. We denote it with a lower case `y`.

-## Get help
-There are some friendly people on [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/y-js/yjs?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge) who may help you with your problem, and answer your questions.
+* y.share.*
+  * Instances of the types you specified on options.share.*
+  * y.share.* can only be defined once when you instantiate Y!
+* y.connector is an instance of Y.AbstractConnector
+* y.connector.onUserEvent(function (event) {..})
+  * Observe user events (event.action is either 'userLeft' or 'userJoined')
+* y.connector.whenSynced(listener)
+  * `listener` is executed when y synced with at least one user.
+  * `listener` is not called when no other user is in the same room.
+  * y-websockets-client aways waits to sync with the server
+* y.connector.disconnect()
+  * Force to disconnect this instance from the other instances
+* y.connector.connect()
+  * Try to reconnect to the other instances (needs to be supported by the
+    connector)
+  * Not supported by y-xmpp
+* y.close()
+  * Destroy this object.
+  * Destroys all types (they will throw weird errors if you still use them)
+  * Disconnects from the other instances (via connector)
+  * Returns a promise
+* y.destroy()
+  * calls y.close()
+  * Removes all data from the database
+  * Returns a promise
+* y.db.stopGarbageCollector()
+  * Stop the garbage collector. Call y.db.garbageCollect() to continue garbage
+    collection
+* y.db.gc :: Boolean
+  * Whether gc is turned on
+* y.db.gcTimeout :: Number (defaults to 50000 ms)
+  * Time interval between two garbage collect cycles
+  * It is required that all instances exchanged all messages after two garbage
+    collect cycles (after 100000 ms per default)
+* y.db.userId :: String
+  * The used user id for this client. **Never overwrite this**

-Please report _any_ issues to the [Github issue page](https://github.com/y-js/yjs/issues)! I try to fix them very soon, if possible.
+### Logging
+Yjs uses [debug](https://github.com/visionmedia/debug) for logging. The flag
+`y*` enables logging for all y-* components. You can selectively remove
+components you are not interested in: E.g. The flag `y*,-y:connector-message`
+will not log the long `y:connector-message` messages.

-## Changelog
-##### 1.0
-This is a complete rewrite of the 0.5 version of Yjs. Since Yjs 1.0 it is possible to work asynchronously on a persistent database, which enables offline support.
-* Switched to semver versioning
-* Requires a promise implementation in environment (es6 promises suffice, included in all the major browsers). Otherwise you have to include a polyfill
-* Y.Object has been renamed to Y.Map
-* Y.Map exchanges `.val(name [, value])` in favor of `.set(name, value)` and `.get(name)`
-* Y.Map `.get(name)` returns a promise, if the value is a custom type
-* The Connector definition slightly changed (I'll update the wiki)
-* The Type definitions completely changed, so you have to rewrite them (I'll rewrite the article in the wiki)
-* Support for several packaging systems
+##### Enable logging in Node.js
+```sh
+DEBUG=y* node app.js
+```

+Remove the colors in order to log to a file:
+```sh
+DEBUG_COLORS=0 DEBUG=y* node app.js > log
+```

-## Contribution
-I created this framework during my bachelor thesis at the chair of computer science 5 [(i5)](http://dbis.rwth-aachen.de/cms), RWTH University. Since December 2014 I'm working on Yjs as a part of my student worker job at the i5.
+##### Enable logging in the browser
+```js
+localStorage.debug = 'y*'
+```

 ## License
-Yjs is licensed under the [MIT License](./LICENSE.txt).
-
-<yjs@dbis.rwth-aachen.de>
-
-[ShareJs]: https://github.com/sh
+Yjs is licensed under the [MIT License](./LICENSE).
--- a/README.v13.md
+++ b/README.v13.md
@@ -0,0 +1,559 @@
+# ![Yjs](https://user-images.githubusercontent.com/5553757/48975307-61efb100-f06d-11e8-9177-ee895e5916e5.png)
+> A CRDT framework with a powerful abstraction of shared data
+
+Yjs is a [CRDT implementation](#Yjs-CRDT-Algorithm) that exposes its internal data structure as *shared types*. Shared types are common data types like `Map` or `Array` with superpowers: changes are automatically distributed to other peers and merged without merge conflicts.
+
+Yjs is **network agnostic** (p2p!), supports many existing **rich text editors**, **offline editing**, **version snapshots**, **undo/redo** and **shared cursors**. It scales well with an unlimited number of users and is well suited for even large documents.
+
+* Chat: [https://gitter.im/y-js/yjs](https://gitter.im/y-js/yjs)
+* Demos: [https://github.com/y-js/yjs-demos](https://github.com/y-js/yjs-demos)
+* Benchmarks: [https://github.com/dmonad/crdt-benchmarks](https://github.com/dmonad/crdt-benchmarks)
+
+# Table of Contents
+
+* [Overview](#Overview)
+  * [Bindings](#Bindings)
+  * [Providers](#Providers)
+* [Getting Started](#Getting-Started)
+* [API](#API)
+  * [Shared Types](#Shared-Types)
+  * [Y.Doc](#Y.Doc)
+  * [Document Updates](#Document-Updates)
+  * [Relative Positions](#Relative-Positions)
+* [Miscellaneous](#Miscellaneous)
+  * [Typescript Declarations](#Typescript-Declarations)
+* [Yjs CRDT Algorithm](#Yjs-CRDT-Algorithm)
+* [Evaluation](#Evaluation)
+  * [Existing shared editing libraries](#Exisisting-Javascript-Libraries)
+  * [CRDT Algorithms](#CRDT-Algorithms)
+  * [Comparison of CRDT with OT](#Comparing-CRDT-with-OT)
+  * [Comparison of CRDT Algorithms](#Comparing-CRDT-Algorithms)
+  * [Comparison of Yjs with other Implementations](#Comparing-Yjs-with-other-Implementations)
+* [License and Author](#License-and-Author)
+
+
+## Overview
+
+This repository contains a collection of shared types that can be observed for changes and manipulated concurrently. Network functionality and two-way-bindings are implemented in separate modules.
+
+### Bindings
+
+| Name &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; | Cursors | Binding |  Demo |
+|---|:-:|---|---|
+| [ProseMirror](https://prosemirror.net/) | ✔ | [y-prosemirror](http://github.com/y-js/y-prosemirror) | [demo](https://yjs-demos.now.sh/prosemirror/) |
+| [Quill](https://quilljs.com/) |  | [y-quill](http://github.com/y-js/y-quill) | [demo](https://yjs-demos.now.sh/quill/) |
+| [CodeMirror](https://codemirror.net/) | ✔ | [y-codemirror](http://github.com/y-js/y-codemirror) | [demo](https://yjs-demos.now.sh/codemirror/) |
+| [Monaco](https://microsoft.github.io/monaco-editor/) | ✔ | [y-monaco](http://github.com/y-js/y-monaco) | [demo](https://yjs-demos.now.sh/monaco/) |
+| [Ace](https://ace.c9.io/) | | [y-ace](http://github.com/y-js/y-ace) | [demo](https://yjs-demos.now.sh/ace/) |
+| [Textarea](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/textarea) | | [y-textarea](http://github.com/y-js/y-textarea) | [demo](https://yjs-demos.now.sh/textarea/) |
+| [DOM](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) | | [y-dom](http://github.com/y-js/y-dom) | [demo](https://yjs-demos.now.sh/dom/) |
+
+
+### Providers
+
+Setting up the communication between clients, managing awareness information, and storing shared data for offline usage is quite a hassle. **Providers** manage all that for you and are the perfect starting point for your collaborative app.
+
+<dl>
+  <dt><a href="http://github.com/y-js/y-websocket">y-websocket</a></dt>
+  <dd>A module that contains a simple websocket backend and a websocket client that connects to that backend. The backend can be extended to persist updates in a leveldb database.</dd>
+  <dt><a href="http://github.com/y-js/y-mesh">y-mesh</a></dt>
+  <dd>[WIP] Creates a connected graph of webrtc connections with a high <a href="https://en.wikipedia.org/wiki/Strength_of_a_graph">strength</a>. It requires a signalling server that connects a client to the first peer. But after that the network manages itself. It is well suited for large and small networks.</dd>
+  <dt><a href="http://github.com/y-js/y-dat">y-dat</a></dt>
+  <dd>[WIP] Write document updates effinciently to the dat network using <a href="https://github.com/kappa-db/multifeed">multifeed</a>. Each client has an append-only log of CRDT local updates (hypercore). Multifeed manages and sync hypercores and y-dat listens to changes and applies them to the Yjs document.</dd>
+</dl>
+
+## Getting Started
+
+Install Yjs and a provider with your favorite package manager.
+
+```sh
+npm i yjs@13.0.0-82 y-websocket@1.0.0-3 y-textarea
+```
+
+**Start the y-websocket server**
+
+```sh
+PORT=1234 node ./node_modules/y-websocket/bin/server.js
+```
+
+**Example: Textarea Binding**
+
+This is a complete example on how to create a connection to a [y-websocket](https://github.com/y-js/y-websocket) server instance, sync the shared document to all clients in a *room*, and bind a Y.Text type to a dom textarea. All changes to the textarea are automatically shared with everyone in the same room.
+
+```js
+import * as Y from 'yjs'
+import { WebsocketProvider } from 'y-websocket'
+import { TextareaBinding } from 'y-textarea'
+
+const doc = Y.Doc()
+const provider = new WebsocketProvider('http://localhost:1234', 'roomname')
+// sync all document updates through the websocket connection
+provider.sync('doc')
+
+// Define a shared type on the document.
+const ytext = doc.getText('my resume')
+
+// use data bindings to bind types to editors
+const binding = new TextareaBinding(ytext, document.querySelector('textarea'))
+```
+
+**Example: Observe types**
+
+```js
+const yarray = doc.getArray('my-array')
+yarray.observe(event => {
+  console.log('yarray was modified')
+})
+// every time a local or remote client modifies yarray, the observer is called
+yarray.insert(0, ['val']) // => "yarray was modified"
+```
+
+**Example: Nest types**
+
+Remember, shared types are just plain old data types. The only limitation is that a shared type must exist only once in the shared document.
+
+```js
+const ymap = doc.getMap('map')
+const foodArray = new Y.Array()
+foodArray.insert(0, ['apple', 'banana'])
+ymap.set('food', foodArray)
+ymap.get('food') === foodArray // => true
+ymap.set('fruit', foodArray) // => Error! foodArray is already defined on the shared document
+```
+
+Now you understand how types are defined on a shared document. Next you can jump to the [demo repository](https://github.com/y-js/yjs-demos) or continue reading the API docs.
+
+## API
+
+```js
+import * as Y from 'yjs'
+```
+
+### Shared Types
+
+<details>
+  <summary><b>Y.Array</b></summary>
+  <br>
+  <p>
+    A shareable Array-like type that supports efficient insert/delete of elements at any position. Internally it uses a linked list of Arrays that is split when necessary.
+  </p>
+  <pre>const yarray = new Y.Array()</pre>
+  <dl>
+    <b><code>insert(index:number, content:Array&lt;object|boolean|Array|string|number|Uint8Array|Y.Type&gt;)</code></b>
+    <dd>
+      Insert content at <var>index</var>. Note that content is an array of elements. I.e. <code>array.insert(0, [1]</code> splices the list and inserts 1 at position 0.
+    </dd>
+    <b><code>push(Array&lt;Object|boolean|Array|string|number|Uint8Array|Y.Type&gt;)</code></b>
+    <dd></dd>
+    <b><code>delete(index:number, length:number)</code></b>
+    <dd></dd>
+    <b><code>get(index:number)</code></b>
+    <dd></dd>
+    <b><code>length:number</code></b>
+    <dd></dd>
+    <b><code>map(function(T, number, YArray):M):Array&lt;M&gt;</code></b>
+    <dd></dd>
+    <b><code>toArray():Array&lt;object|boolean|Array|string|number|Uint8Array|Y.Type&gt;</code></b>
+    <dd>Copies the content of this YArray to a new Array.</dd>
+    <b><code>toJSON():Array&lt;Object|boolean|Array|string|number&gt;</code></b>
+    <dd>Copies the content of this YArray to a new Array. It transforms all child types to JSON using their <code>toJSON</code> method.</dd>
+    <b><code>[Symbol.Iterator]</code></b>
+    <dd>
+      Returns an YArray Iterator that contains the values for each index in the array.
+      <pre>for (let value of yarray) { .. }</pre>
+    </dd>
+    <b><code>observe(function(YArrayEvent, Transaction):void)</code></b>
+    <dd>
+      Adds an event listener to this type that will be called synchronously every time this type is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns.
+    </dd>
+    <b><code>unobserve(function(YArrayEvent, Transaction):void)</code></b>
+    <dd>
+      Removes an <code>observe</code> event listener from this type.
+    </dd>
+    <b><code>observeDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
+    <dd>
+      Adds an event listener to this type that will be called synchronously every time this type or any of its children is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns. The event listener receives all Events created by itself or any of its children.
+    </dd>
+    <b><code>unobserveDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
+    <dd>
+      Removes an <code>observeDeep</code> event listener from this type.
+    </dd>
+  </dl>
+</details>
+<details>
+  <summary><b>Y.Map</b></summary>
+  <br>
+  <p>
+    A shareable Map type.
+  </p>
+  <pre><code>const ymap = new Y.Map()</code></pre>
+  <dl>
+    <b><code>get(key:string):object|boolean|string|number|Uint8Array|Y.Type</code></b>
+    <dd></dd>
+    <b><code>set(key:string, value:object|boolean|string|number|Uint8Array|Y.Type)</code></b>
+    <dd></dd>
+    <b><code>delete(key:string)</code></b>
+    <dd></dd>
+    <b><code>has(key:string):boolean</code></b>
+    <dd></dd>
+    <b><code>get(index:number)</code></b>
+    <dd></dd>
+    <b><code>toJSON():Object&lt;string, Object|boolean|Array|string|number&gt;</code></b>
+    <dd>Copies the <code>[key,value]</code> pairs of this YMap to a new Object. It transforms all child types to JSON using their <code>toJSON</code> method.</dd>
+    <b><code>[Symbol.Iterator]</code></b>
+    <dd>
+      Returns an Iterator of <code>[key, value]</code> pairs.
+      <pre>for (let [key, value] of ymap) { .. }</pre>
+    </dd>
+    <b><code>entries()</code></b>
+    <dd>
+      Returns an Iterator of <code>[key, value]</code> pairs.
+    </dd>
+    <b><code>values()</code></b>
+    <dd>
+      Returns an Iterator of all values.
+    </dd>
+    <b><code>keys()</code></b>
+    <dd>
+      Returns an Iterator of all keys.
+    </dd>
+    <b><code>observe(function(YMapEvent, Transaction):void)</code></b>
+    <dd>
+      Adds an event listener to this type that will be called synchronously every time this type is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns.
+    </dd>
+    <b><code>unobserve(function(YMapEvent, Transaction):void)</code></b>
+    <dd>
+      Removes an <code>observe</code> event listener from this type.
+    </dd>
+    <b><code>observeDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
+    <dd>
+      Adds an event listener to this type that will be called synchronously every time this type or any of its children is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns. The event listener receives all Events created by itself or any of its children.
+    </dd>
+    <b><code>unobserveDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
+    <dd>
+      Removes an <code>observeDeep</code> event listener from this type.
+    </dd>
+  </dl>
+</details>
+
+<details>
+  <summary><b>Y.Text</b></summary>
+  <br>
+  <p>
+    A shareable type that is optimized for shared editing on text. It allows to assign properties to ranges in the text. This makes it possible to implement rich-text bindings to this type.
+  </p>
+  <p>
+    This type can also be transformed to the <a href="https://quilljs.com/docs/delta">delta format</a>. Similarly the YTextEvents compute changes as deltas.
+  </p>
+  <pre>const ytext = new Y.Text()</pre>
+  <dl>
+    <b><code>insert(index:number, content:string, [formattingAttributes:Object&lt;string,string&gt;])</code></b>
+    <dd>
+      Insert a string at <var>index</var> and assign formatting attributes to it.
+      <pre>ytext.insert(0, 'bold text', { bold: true })</pre>
+    </dd>
+    <b><code>delete(index:number, length:number)</code></b>
+    <dd></dd>
+    <b><code>format(index:number, length:number, formattingAttributes:Object&lt;string,string&gt;)</code></b>
+    <dd>Assign formatting attributes to a range in the text</dd>
+    <b><code>applyDelta(delta)</code></b>
+    <dd>See <a href="https://quilljs.com/docs/delta/">Quill Delta</a></dd>
+    <b><code>length:number</code></b>
+    <dd></dd>
+    <b><code>toString():string</code></b>
+    <dd>Transforms this type, without formatting options, into a string.</dd>
+    <b><code>toJSON():string</code></b>
+    <dd>See <code>toString</code></dd>
+    <b><code>toDelta():Delta</code></b>
+    <dd>Transforms this type to a <a href="https://quilljs.com/docs/delta/">Quill Delta</a></dd>
+    <b><code>observe(function(YTextEvent, Transaction):void)</code></b>
+    <dd>
+      Adds an event listener to this type that will be called synchronously every time this type is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns.
+    </dd>
+    <b><code>unobserve(function(YTextEvent, Transaction):void)</code></b>
+    <dd>
+      Removes an <code>observe</code> event listener from this type.
+    </dd>
+    <b><code>observeDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
+    <dd>
+      Adds an event listener to this type that will be called synchronously every time this type or any of its children is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns. The event listener receives all Events created by itself or any of its children.
+    </dd>
+    <b><code>unobserveDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
+    <dd>
+      Removes an <code>observeDeep</code> event listener from this type.
+    </dd>
+  </dl>
+</details>
+
+<details>
+  <summary><b>YXmlFragment</b></summary>
+  <br>
+  <p>
+    A container that holds an Array of Y.XmlElements.
+  </p>
+  <pre><code>const yxml = new Y.XmlFragment()</code></pre>
+  <dl>
+    <b><code>insert(index:number, content:Array&lt;Y.XmlElement|Y.XmlText&gt;)</code></b>
+    <dd></dd>
+    <b><code>delete(index:number, length:number)</code></b>
+    <dd></dd>
+    <b><code>get(index:number)</code></b>
+    <dd></dd>
+    <b><code>length:number</code></b>
+    <dd></dd>
+    <b><code>toArray():Array&lt;Y.XmlElement|Y.XmlText&gt;</code></b>
+    <dd>Copies the children to a new Array.</dd>
+    <b><code>toDOM():DocumentFragment</code></b>
+    <dd>Transforms this type and all children to new DOM elements.</dd>
+    <b><code>toString():string</code></b>
+    <dd>Get the XML serialization of all descendants.</dd>
+    <b><code>toJSON():string</code></b>
+    <dd>See <code>toString</code>.</dd>
+    <b><code>observe(function(YXmlEvent, Transaction):void)</code></b>
+    <dd>
+      Adds an event listener to this type that will be called synchronously every time this type is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns.
+    </dd>
+    <b><code>unobserve(function(YXmlEvent, Transaction):void)</code></b>
+    <dd>
+      Removes an <code>observe</code> event listener from this type.
+    </dd>
+    <b><code>observeDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
+    <dd>
+      Adds an event listener to this type that will be called synchronously every time this type or any of its children is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns. The event listener receives all Events created by itself or any of its children.
+    </dd>
+    <b><code>unobserveDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
+    <dd>
+      Removes an <code>observeDeep</code> event listener from this type.
+    </dd>
+  </dl>
+</details>
+
+<details>
+  <summary><b>Y.XmlElement</b></summary>
+  <br>
+  <p>
+    A shareable type that represents an XML Element. It has a <code>nodeName</code>, attributes, and a list of children. But it makes no effort to validate its content and be actually XML compliant.
+  </p>
+  <pre><code>const yxml = new Y.XmlElement()</code></pre>
+  <dl>
+    <b><code>insert(index:number, content:Array&lt;Y.XmlElement|Y.XmlText&gt;)</code></b>
+    <dd></dd>
+    <b><code>delete(index:number, length:number)</code></b>
+    <dd></dd>
+    <b><code>get(index:number)</code></b>
+    <dd></dd>
+    <b><code>length:number</code></b>
+    <dd></dd>
+    <b><code>setAttribute(attributeName:string, attributeValue:string)</code></b>
+    <dd></dd>
+    <b><code>removeAttribute(attributeName:string)</code></b>
+    <dd></dd>
+    <b><code>getAttribute(attributeName:string):string</code></b>
+    <dd></dd>
+    <b><code>getAttributes(attributeName:string):Object&lt;string,string&gt;</code></b>
+    <dd></dd>
+    <b><code>toArray():Array&lt;Y.XmlElement|Y.XmlText&gt;</code></b>
+    <dd>Copies the children to a new Array.</dd>
+    <b><code>toDOM():Element</code></b>
+    <dd>Transforms this type and all children to a new DOM element.</dd>
+    <b><code>toString():string</code></b>
+    <dd>Get the XML serialization of all descendants.</dd>
+    <b><code>toJSON():string</code></b>
+    <dd>See <code>toString</code>.</dd>
+    <b><code>observe(function(YXmlEvent, Transaction):void)</code></b>
+    <dd>
+      Adds an event listener to this type that will be called synchronously every time this type is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns.
+    </dd>
+    <b><code>unobserve(function(YXmlEvent, Transaction):void)</code></b>
+    <dd>
+      Removes an <code>observe</code> event listener from this type.
+    </dd>
+    <b><code>observeDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
+    <dd>
+      Adds an event listener to this type that will be called synchronously every time this type or any of its children is modified. In the case this type is modified in the event listener, the event listener will be called again after the current event listener returns. The event listener receives all Events created by itself or any of its children.
+    </dd>
+    <b><code>unobserveDeep(function(Array&lt;YEvent&gt;, Transaction):void)</code></b>
+    <dd>
+      Removes an <code>observeDeep</code> event listener from this type.
+    </dd>
+  </dl>
+</details>
+
+### Y.Doc
+
+```js
+const doc = new Y.Doc()
+```
+
+<dl>
+  <b><code>clientID</code></b>
+  <dd>A unique id that identifies this client. (readonly)</dd>
+  <b><code>transact(function(Transaction):void [, origin:any])</code></b>
+  <dd>Every change on the shared document happens in a transaction. Observer calls and the <code>update</code> event are called after each transaction. You should <i>bundle</i> changes into a single transaction to reduce the amount of event calls. I.e. <code>doc.transact(() => { yarray.insert(..); ymap.set(..) })</code> triggers a single change event. <br>You can specify an optional <code>origin</code> parameter that is stored on <code>transaction.origin</code> and <code>on('update', (update, origin) => ..)</code>.</dd>
+  <b><code>get(string, Y.[TypeClass]):[Type]</code></b>
+  <dd>Define a shared type.</dd>
+  <b><code>getArray(string):Y.Array</code></b>
+  <dd>Define a shared Y.Array type. Is equivalent to <code>y.get(string, Y.Array)</code>.</dd>
+  <b><code>getMap(string):Y.Map</code></b>
+  <dd>Define a shared Y.Map type. Is equivalent to <code>y.get(string, Y.Map)</code>.</dd>
+  <b><code>getXmlFragment(string):Y.XmlFragment</code></b>
+  <dd>Define a shared Y.XmlFragment type. Is equivalent to <code>y.get(string, Y.XmlFragment)</code>.</dd>
+  <b><code>on(string, function)</code></b>
+  <dd>Register an event listener on the shared type</dd>
+  <b><code>off(string, function)</code></b>
+  <dd>Unregister an event listener from the shared type</dd>
+</dl>
+
+
+#### Y.Doc Events
+<dl>
+  <b><code>on('update', function(updateMessage:Uint8Array, origin:any, Y.Doc):void)</code></b>
+  <dd>Listen to document updates. Document updates must be transmitted to all other peers. You can apply document updates in any order and multiple times.</dd>
+  <b><code>on('beforeTransaction', function(Y.Transaction, Y.Doc):void)</code></b>
+  <dd>Emitted before each transaction.</dd>
+  <b><code>on('afterTransaction', function(Y.Transaction, Y.Doc):void)</code></b>
+  <dd>Emitted after each transaction.</dd>
+</dl>
+
+### Document Updates
+
+Changes on the shared document are encoded into *document updates*. Document updates are *commutative* and *idempotent*. This means that they can be applied in any order and multiple times.
+
+**Example: Listen to update events and apply them on remote client**
+```js
+const doc1 = new Y.Doc()
+const doc2 = new Y.Doc()
+
+doc1.on('update', update => {
+  Y.applyUpdate(doc2, update)
+})
+
+doc2.on('update', update => {
+  Y.applyUpdate(doc1, update)
+})
+
+// All changes are also applied to the other document
+doc1.getArray('myarray').insert(0, ['Hello doc2, you got this?'])
+doc2.getArray('myarray').get(0) // => 'Hello doc2, you got this?'
+```
+
+Yjs internally maintains a [state vector](#State-Vector) that denotes the next expected clock from each client. In a different interpretation it holds the number of structs created by each client. When two clients sync, you can either exchange the complete document structure or only the differences by sending the state vector to compute the differences.
+
+**Example: Sync two clients by exchanging the complete document structure**
+
+```js
+const state1 = Y.encodeStateAsUpdate(ydoc1)
+const state2 = Y.encodeStateAsUpdate(ydoc2)
+Y.applyUpdate(ydoc1, state2)
+Y.applyUpdate(ydoc2, state1)
+```
+
+**Example: Sync two clients by computing the differences**
+
+This example shows how to sync two clients with the minimal amount of exchanged data by computing only the differences using the state vector of the remote client. Syncing clients using the state vector requires another roundtrip, but can safe a lot of bandwidth.
+
+```js
+const stateVector1 = Y.encodeStateVector(ydoc1)
+const stateVector2 = Y.encodeStateVector(ydoc2)
+const diff1 = Y.encodeStateAsUpdate(ydoc1, stateVector2)
+const diff2 = Y.encodeStateAsUpdate(ydoc2, stateVector1)
+Y.applyUpdate(ydoc1, diff2)
+Y.applyUpdate(ydoc2, diff1)
+```
+
+<dl>
+  <b><code>Y.applyUpdate(Y.Doc, update:Uint8Array, [transactionOrigin:any])</code></b>
+  <dd>Apply a document update on the shared document. Optionally you can specify <code>transactionOrigin</code> that will be stored on <code>transaction.origin</code> and <code>ydoc.on('update', (update, origin) => ..)</code>.</dd>
+  <b><code>Y.encodeStateAsUpdate(Y.Doc, [encodedTargetStateVector:Uint8Array]):Uint8Array</code></b>
+  <dd>Encode the document state as a single update message that can be applied on the remote document. Optionally specify the target state vector to only write the differences to the update message.</dd>
+  <b><code>Y.encodeStateVector(Y.Doc):Uint8Array</code></b>
+  <dd>Computes the state vector and encodes it into an Uint8Array.</dd>
+</dl>
+
+### Relative Positions
+> This API is not stable yet
+
+This feature is intended for managing selections / cursors. When working with other users that manipulate the shared document, you can't trust that an index position (an integer) will stay at the intended location. A *relative position* is fixated to an element in the shared document and is not affected by remote changes. I.e. given the document `"a|c"`, the relative position is attached to `c`. When a remote user modifies the document by inserting a character before the cursor, the cursor will stay attached to the character `c`. `insert(1, 'x')("a|c") = "ax|c"`. When the *relative position* is set to the end of the document, it will stay attached to the end of the document.
+
+**Example: Transform to RelativePosition and back**
+```js
+const relPos = Y.createRelativePositionFromTypeIndex(ytext, 2)
+const pos = Y.createAbsolutePositionFromRelativePosition(relPos, doc)
+pos.type === ytext // => true
+pos.index === 2 // => true
+```
+
+**Example: Send relative position to remote client (json)**
+```js
+const relPos = Y.createRelativePositionFromTypeIndex(ytext, 2)
+const encodedRelPos = JSON.stringify(relPos)
+// send encodedRelPos to remote client..
+const parsedRelPos = JSON.parse(encodedRelPos)
+const pos = Y.createAbsolutePositionFromRelativePosition(parsedRelPos, remoteDoc)
+pos.type === remoteytext // => true
+pos.index === 2 // => true
+```
+
+**Example: Send relative position to remote client (Uint8Array)**
+```js
+const relPos = Y.createRelativePositionFromTypeIndex(ytext, 2)
+const encodedRelPos = Y.encodeRelativePosition(relPos)
+// send encodedRelPos to remote client..
+const parsedRelPos = Y.decodeRelativePosition(encodedRelPos)
+const pos = Y.createAbsolutePositionFromRelativePosition(parsedRelPos, remoteDoc)
+pos.type === remoteytext // => true
+pos.index === 2 // => true
+```
+
+<dl>
+  <b><code>Y.createRelativePositionFromTypeIndex(Uint8Array|Y.Type, number)</code></b>
+  <dd></dd>
+  <b><code>Y.createAbsolutePositionFromRelativePosition(RelativePosition, Y.Doc)</code></b>
+  <dd></dd>
+  <b><code>Y.encodeRelativePosition(RelativePosition):Uint8Array</code></b>
+  <dd></dd>
+  <b><code>Y.decodeRelativePosition(Uint8Array):RelativePosition</code></b>
+  <dd></dd>
+</dl>
+
+## Miscellaneous
+
+### Typescript Declarations
+
+Yjs has type descriptions. But until [this ticket](https://github.com/Microsoft/TypeScript/issues/7546) is fixed, this is how you can make use of Yjs type declarations.
+
+```json
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "checkJs": true,
+  },
+  "maxNodeModuleJsDepth": 5
+}
+```
+
+## Yjs CRDT Algorithm
+
+*Conflict-free replicated data types* (CRDT) for collaborative editing are an alternative approach to *operational transformation* (OT). A very simple differenciation between the two approaches is that OT attempts to transform index positions to ensure convergence (all clients end up with the same content), while CRDTs use mathematical models that usually do not involve index transformations, like linked lists. OT is currently the de-facto standard for shared editing on text. OT approaches that support shared editing without a central source of truth (a central server) require too much bookkeeping to be viable in practice. CRDTs are better suited for distributed systems, provide additional guarantees that the document can be synced with remote clients, and do not require a central source of truth.
+
+Yjs implements a modified version of the algorithm described in [this paper](https://www.researchgate.net/publication/310212186_Near_Real-Time_Peer-to-Peer_Shared_Editing_on_Extensible_Data_Types). I will eventually publish a paper that describes why this approach works so well in practice. Note: Since operations make up the document structure, we prefer the term *struct* now.
+
+CRDTs suitable for shared text editing suffer from the fact that they only grow in size. There are CRDTs that do not grow in size, but they do not have the characteristics that are benificial for shared text editing (like intention preservation). Yjs implements many improvements to the original algorithm that diminish the trade-off that the document only grows in size. We can't garbage collect deleted structs (tombstones) while ensuring a unique order of the structs. But we can 1. merge preceeding structs into a single struct to reduce the amount of meta information, 2. we can delete content from the struct if it is deleted, and 3. we can garbage collect tombstones if we don't care about the order of the structs anymore (e.g. if the parent was deleted).
+
+**Examples:**
+1. If a user inserts elements in sequence, the struct will be merged into a single struct. E.g. `array.insert(0, ['a']), array.insert(0, ['b']);` is first represented as two structs (`[{id: {client, clock: 0}, content: 'a'}, {id: {client, clock: 1}, content: 'b'}`) and then merged into a single struct: `[{id: {client, clock: 0}, content: 'ab'}]`.
+2. When a struct that contains content (e.g. `ItemString`) is deleted, the struct will be replaced with an `ItemDeleted` that does not contain content anymore.
+3. When a type is deleted, all child elements are transformed to `GC` structs. A `GC` struct only denotes the existence of a struct and that it is deleted. `GC` structs can always be merged with other `GC` structs if the id's are adjacent.
+
+Especially when working on structured content (e.g. shared editing on ProseMirror), these improvements yield very good results when [benchmarking](https://github.com/dmonad/crdt-benchmarks) random document edits. In practice they show even better results, because users usually edit text in sequence, resulting in structs that can easily be merged. The benchmarks show that even in the worst case scenario that a user edits text from right to left, Yjs achieves good performance even for huge documents.
+
+#### State Vector
+Yjs has the ability to exchange only the differences when syncing two clients. We use lamport timestamps to identify structs and to track in which order a client created them. Each struct has an `struct.id = { client: number, clock: number}` that uniquely identifies a struct. We define the next expected `clock` by each client as the *state vector*. This data structure is similar to the [version vectors](https://en.wikipedia.org/wiki/Version_vector) data structure. But we use state vectors only to describe the state of the local document, so we can compute the missing struct of the remote client. We do not use it to track causality.
+
+## License and Author
+
+Yjs and all related projects are [**MIT licensed**](./LICENSE).
+
+Yjs is based on my research as a student at the [RWTH i5](http://dbis.rwth-aachen.de/). Now I am working on Yjs in my spare time.
+
+Fund this project by donating on [Patreon](https://www.patreon.com/dmonad) or hiring [me](https://github.com/dmonad) for professional support.
--- a/1
+++ b/1
--- a/gulpfile.js
+++ b/gulpfile.js
@@ -1,207 +0,0 @@
-/* eslint-env node */
-
-/** Gulp Commands
-
-  gulp command*
-    [--export ModuleType]
-    [--name ModuleName]
-    [--testport TestPort]
-    [--testfiles TestFiles]
-
-  Module name (ModuleName):
-    Compile this to "y.js" (default)
-
-  Supported module types (ModuleType):
-    - amd
-    - amdStrict
-    - common
-    - commonStrict
-    - ignore (default)
-    - system
-    - umd
-    - umdStrict
-
-  Test port (TestPort):
-    Serve the specs on port 8888 (default)
-
-  Test files (TestFiles):
-    Specify which specs to use!
-
-  Commands:
-    - build:deploy
-        Build this library for deployment (es6->es5, minified)
-    - dev:browser
-        Watch the ./src directory.
-        Builds the library on changes.
-        Starts an http-server and serves the test suite on http://127.0.0.1:8888.
-    - dev:node
-        Watch the ./src directory.
-        Builds and specs the library on changes.
-        Usefull to run with node-inspector.
-        `node-debug $(which gulp) dev:node
-    - test:
-        Test this library
-*/
-
-var gulp = require('gulp')
-var sourcemaps = require('gulp-sourcemaps')
-var babel = require('gulp-babel')
-var uglify = require('gulp-uglify')
-var minimist = require('minimist')
-var jasmine = require('gulp-jasmine')
-var jasmineBrowser = require('gulp-jasmine-browser')
-var concat = require('gulp-concat')
-var watch = require('gulp-watch')
-var shell = require('gulp-shell')
-var $ = require('gulp-load-plugins')()
-
-var options = minimist(process.argv.slice(2), {
-  string: ['export', 'name', 'testport', 'testfiles', 'regenerator'],
-  default: {
-    export: 'ignore',
-    name: 'y.js',
-    testport: '8888',
-    testfiles: 'src/**/*.js',
-    regenerator: process.version < 'v0.12'
-  }
-})
-
-var polyfills = [
-  './node_modules/gulp-babel/node_modules/babel-core/node_modules/regenerator/runtime.js'
-]
-
-var concatOrder = [
-  'y.js',
-  'Connector.js',
-  'Database.js',
-  'Transaction.js',
-  'Struct.js',
-  'Utils.js',
-  'Databases/RedBlackTree.js',
-  'Databases/Memory.js',
-  'Databases/IndexedDB.js',
-  'Connectors/Test.js',
-  'Connectors/WebRTC.js',
-  'Types/Array.js',
-  'Types/Map.js',
-  'Types/TextBind.js'
-]
-
-var files = {
-  src: polyfills.concat(concatOrder.map(function (f) {
-    return 'src/' + f
-  })),
-  test: ['build/Helper.spec.js'].concat(concatOrder.map(function (f) {
-    return 'build/' + f
-  }).concat(['build/**/*.spec.js']))
-}
-
-if (options.regenerator) {
-  files.test = polyfills.concat(files.test)
-}
-
-gulp.task('deploy:build', function () {
-  return gulp.src(files.src)
-    .pipe(sourcemaps.init())
-    .pipe(concat('y.js'))
-    .pipe(babel({
-      loose: 'all',
-      modules: 'ignore',
-      experimental: true
-    }))
-    .pipe(uglify())
-    .pipe(sourcemaps.write('.'))
-    .pipe(gulp.dest('.'))
-})
-
-gulp.task('deploy:updateSubmodule', function () {
-  return $.git.updateSubmodule({ args: '--init' })
-})
-
-gulp.task('deploy:copy', function () {
-  return gulp.src(['./y.js', './y.js.map', './README.md', 'package.json', 'LICENSE'])
-    .pipe(gulp.dest('./dist/'))
-})
-
-gulp.task('deploy:bump', function () {
-  return gulp.src('./package.json')
-    .pipe($.bump({type: 'patch'}))
-    .pipe(gulp.dest('./'))
-})
-
-gulp.task('deploy', ['deploy:updateSubmodule', 'deploy:bump', 'deploy:build', 'deploy:copy'], function () {
-  return gulp.src('./package.json', {read: false})
-    .pipe(shell([
-      'echo "Deploying version <%= getVersion(file.path) %>"',
-      'cd ./dist/',
-      'git add -A',
-      'git commit -am "Deploy <%= getVersion(file.path) %>" -n',
-      'git tag -a v<%= getVersion(file.path) %> -m "Release <%= getVersion(file.path) %>"',
-      'git push',
-      'git push origin --tags',
-      'cd ..',
-      'git commit -am "Release <%= getVersion(file.path) %>" -n',
-      'git push'
-    ], {
-      templateData: {
-        getVersion: function (s) {
-          return require(s).version
-        }
-      }
-    }))
-})
-
-gulp.task('build:test', function () {
-  var babelOptions = {
-    loose: 'all',
-    modules: 'ignore',
-    experimental: true
-  }
-  if (!options.regenerator) {
-    babelOptions.blacklist = 'regenerator'
-  }
-  gulp.src(files.src)
-    .pipe(sourcemaps.init())
-    .pipe(concat('y.js'))
-    .pipe(babel(babelOptions))
-    .pipe(sourcemaps.write())
-    .pipe(gulp.dest('.'))
-
-  return gulp.src('src/**/*.js')
-    .pipe(sourcemaps.init())
-    .pipe(babel(babelOptions))
-    .pipe(sourcemaps.write())
-    .pipe(gulp.dest('build'))
-})
-
-gulp.task('dev:node', ['test'], function () {
-  gulp.watch('src/**/*.js', ['test'])
-})
-
-gulp.task('dev:browser', ['build:test'], function () {
-  gulp.watch('src/**/*.js', ['build:test'])
-
-  gulp.src(files.test)
-    .pipe(watch(['build/**/*.js']))
-    .pipe(jasmineBrowser.specRunner())
-    .pipe(jasmineBrowser.server({port: options.testport}))
-})
-
-gulp.task('dev', ['build:test'], function () {
-  gulp.start('dev:browser')
-  gulp.start('dev:node')
-})
-
-gulp.task('test', ['build:test'], function () {
-  var testfiles = files.test
-  if (typeof Promise === 'undefined') {
-    testfiles.concat(['src/polyfills.js'])
-  }
-  return gulp.src(testfiles)
-    .pipe(jasmine({
-      verbose: true,
-      includeStuckTrace: true
-    }))
-})
-
-gulp.task('default', ['test'])
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,23 +1,39 @@
 {
  "name": "yjs",
-  "version": "0.6.20",
-  "description": "A framework for real-time p2p shared editing on arbitrary complex data types",
-  "main": "y.js",
+  "version": "13.0.0-85",
+  "description": "Shared Editing Library",
+  "main": "./dist/yjs.js",
+  "module": "./dist/yjs.mjs",
+  "sideEffects": false,
  "scripts": {
-    "test": "node --harmony ./node_modules/.bin/gulp test",
-    "lint": "./node_modules/.bin/standard",
-    "build": "./node_modules/.bin/standard build"
+    "test": "npm run dist && PRODUCTION=1 node ./dist/tests.js --repitition-time 50 --production",
+    "test-exhaustive": "npm run lint && npm run dist && node ./dist/tests.js --repitition-time 10000",
+    "dist": "rm -rf dist && rollup -c",
+    "watch": "rollup -wc",
+    "lint": "standard && tsc",
+    "docs": "rm -rf docs; jsdoc --configure ./.jsdoc.json --verbose --readme ./README.v13.md --package ./package.json || true",
+    "serve-docs": "npm run docs && serve ./docs/",
+    "preversion": "PRODUCTION=1 npm run dist && npm run docs && node ./dist/tests.js --repitition-time 1000",
+    "postversion": "git push && git push --tags",
+    "debug": "concurrently 'live-server --port=3443 --entry-file=test.html' 'npm run watch'",
+    "trace-deopt": "clear && rollup -c  && node --trace-deopt dist/test.js",
+    "trace-opt": "clear && rollup -c  && node --trace-opt dist/test.js"
  },
-  "pre-commit": [
-    "lint",
-    "test"
+  "files": [
+    "dist/*",
+    "src/*",
+    "tests/*",
+    "docs/*"
  ],
+  "dictionaries": {
+    "doc": "docs",
+    "test": "tests"
+  },
  "standard": {
-    "parser": "babel-eslint",
    "ignore": [
-      "build/**",
-      "./y.js",
-      "./y.js.map"
+      "/dist",
+      "/node_modules",
+      "/docs"
    ]
  },
  "repository": {
@@ -25,13 +41,7 @@
    "url": "https://github.com/y-js/yjs.git"
  },
  "keywords": [
-    "OT",
-    "Operational Transformation",
-    "collaboration",
-    "synchronization",
-    "ShareJs",
-    "OpenCoweb",
-    "concurrency"
+    "crdt"
  ],
  "author": "Kevin Jahns",
  "email": "kevin.jahns@rwth-aachen.de",
@@ -40,26 +50,21 @@
    "url": "https://github.com/y-js/yjs/issues"
  },
  "homepage": "http://y-js.org",
+  "dependencies": {
+    "lib0": "0.0.5"
+  },
  "devDependencies": {
-    "babel-eslint": "^4.1.2",
-    "gulp": "^3.9.0",
-    "gulp-babel": "^5.2.1",
-    "gulp-bump": "^1.0.0",
-    "gulp-concat": "^2.6.0",
-    "gulp-filter": "^3.0.1",
-    "gulp-git": "^1.6.0",
-    "gulp-jasmine": "^2.0.1",
-    "gulp-jasmine-browser": "^0.2.3",
-    "gulp-load-plugins": "^1.0.0",
-    "gulp-shell": "^0.5.1",
-    "gulp-sourcemaps": "^1.5.2",
-    "gulp-tag-version": "^1.3.0",
-    "gulp-uglify": "^1.4.1",
-    "gulp-util": "^3.0.6",
-    "gulp-watch": "^4.3.5",
-    "minimist": "^1.2.0",
-    "pre-commit": "^1.1.1",
-    "promise-polyfill": "^2.1.0",
-    "standard": "^5.2.2"
+    "concurrently": "^3.6.1",
+    "jsdoc": "^3.6.2",
+    "live-server": "^1.2.1",
+    "rollup": "^1.11.3",
+    "rollup-cli": "^1.0.9",
+    "rollup-plugin-commonjs": "^9.3.4",
+    "rollup-plugin-node-resolve": "^4.2.4",
+    "rollup-plugin-terser": "^4.0.4",
+    "standard": "^11.0.1",
+    "tui-jsdoc-template": "^1.2.2",
+    "typescript": "^3.4.5",
+    "y-protocols": "0.0.6"
  }
 }
--- a/rollup.config.js
+++ b/rollup.config.js
@@ -0,0 +1,89 @@
+import nodeResolve from 'rollup-plugin-node-resolve'
+import commonjs from 'rollup-plugin-commonjs'
+import { terser } from 'rollup-plugin-terser'
+
+const customModules = new Set([
+  'y-websocket',
+  'y-codemirror',
+  'y-ace',
+  'y-textarea',
+  'y-quill',
+  'y-dom',
+  'y-prosemirror'
+])
+/**
+ * @type {Set<any>}
+ */
+const customLibModules = new Set([
+  'lib0',
+  'y-protocols'
+])
+const debugResolve = {
+  resolveId (importee) {
+    if (importee === 'yjs') {
+      return `${process.cwd()}/src/index.js`
+    }
+    /*
+    if (customModules.has(importee.split('/')[0])) {
+      return `${process.cwd()}/../${importee}/src/${importee}.js`
+    }
+    if (customLibModules.has(importee.split('/')[0])) {
+      return `${process.cwd()}/../${importee}`
+    }
+    */
+    return null
+  }
+}
+
+const minificationPlugins = process.env.PRODUCTION ? [terser({
+  module: true,
+  compress: {
+    hoist_vars: true,
+    module: true,
+    passes: 5,
+    pure_getters: true,
+    unsafe_comps: true,
+    unsafe_undefined: true
+  },
+  mangle: {
+    toplevel: true
+  }
+})] : []
+
+export default [{
+  input: './src/index.js',
+  output: [{
+    name: 'Y',
+    file: 'dist/yjs.js',
+    format: 'cjs',
+    sourcemap: true,
+    paths: path => {
+      if (/^lib0\//.test(path)) {
+        return `lib0/dist/${path.slice(5)}`
+      }
+      return path
+    }
+  }, {
+    name: 'Y',
+    file: 'dist/yjs.mjs',
+    format: 'es',
+    sourcemap: true
+  }],
+  external: id => /^lib0\//.test(id)
+}, {
+  input: './tests/index.js',
+  output: {
+    name: 'test',
+    file: 'dist/tests.js',
+    format: 'iife',
+    sourcemap: true
+  },
+  plugins: [
+    debugResolve,
+    nodeResolve({
+      sourcemap: true,
+      mainFields: ['module', 'browser', 'main']
+    })
+    // commonjs()
+  ]
+}]
--- a/src/Connector.js
+++ b/src/Connector.js
@@ -1,328 +0,0 @@
-/* globals Y */
-'use strict'
-
-class AbstractConnector {
-  /*
-    opts contains the following information:
-     role : String Role of this client ("master" or "slave")
-     userId : String Uniquely defines the user.
-     debug: Boolean Whether to print debug messages (optional)
-  */
-  constructor (y, opts) {
-    this.y = y
-    if (opts == null) {
-      opts = {}
-    }
-    if (opts.role == null || opts.role === 'master') {
-      this.role = 'master'
-    } else if (opts.role === 'slave') {
-      this.role = 'slave'
-    } else {
-      throw new Error("Role must be either 'master' or 'slave'!")
-    }
-    this.role = opts.role
-    this.connections = {}
-    this.isSynced = false
-    this.userEventListeners = []
-    this.whenSyncedListeners = []
-    this.currentSyncTarget = null
-    this.syncingClients = []
-    this.forwardToSyncingClients = opts.forwardToSyncingClients !== false
-    this.debug = opts.debug === true
-    this.broadcastedHB = false
-    this.syncStep2 = Promise.resolve()
-  }
-  reconnect () {
-  }
-  disconnect () {
-    this.connections = {}
-    this.isSynced = false
-    this.currentSyncTarget = null
-    this.broadcastedHB = false
-    this.syncingClients = []
-    this.whenSyncedListeners = []
-    return this.y.db.stopGarbageCollector()
-  }
-  setUserId (userId) {
-    this.userId = userId
-    return this.y.db.setUserId(userId)
-  }
-  onUserEvent (f) {
-    this.userEventListeners.push(f)
-  }
-  userLeft (user) {
-    delete this.connections[user]
-    if (user === this.currentSyncTarget) {
-      this.currentSyncTarget = null
-      this.findNextSyncTarget()
-    }
-    this.syncingClients = this.syncingClients.filter(function (cli) {
-      return cli !== user
-    })
-    for (var f of this.userEventListeners) {
-      f({
-        action: 'userLeft',
-        user: user
-      })
-    }
-  }
-  userJoined (user, role) {
-    if (role == null) {
-      throw new Error('You must specify the role of the joined user!')
-    }
-    if (this.connections[user] != null) {
-      throw new Error('This user already joined!')
-    }
-    this.connections[user] = {
-      isSynced: false,
-      role: role
-    }
-    for (var f of this.userEventListeners) {
-      f({
-        action: 'userJoined',
-        user: user,
-        role: role
-      })
-    }
-    if (this.currentSyncTarget == null) {
-      this.findNextSyncTarget()
-    }
-  }
-  // Execute a function _when_ we are connected.
-  // If not connected, wait until connected
-  whenSynced (f) {
-    if (this.isSynced) {
-      f()
-    } else {
-      this.whenSyncedListeners.push(f)
-    }
-  }
-  /*
-
-   returns false, if there is no sync target
-   true otherwise
-  */
-  findNextSyncTarget () {
-    if (this.currentSyncTarget != null || this.isSynced) {
-      return // "The current sync has not finished!"
-    }
-
-    var syncUser = null
-    for (var uid in this.connections) {
-      if (!this.connections[uid].isSynced) {
-        syncUser = uid
-        break
-      }
-    }
-    if (syncUser != null) {
-      var conn = this
-      this.currentSyncTarget = syncUser
-      this.y.db.requestTransaction(function *() {
-        conn.send(syncUser, {
-          type: 'sync step 1',
-          stateSet: yield* this.getStateSet(),
-          deleteSet: yield* this.getDeleteSet()
-        })
-      })
-    } else {
-      this.isSynced = true
-      // call when synced listeners
-      for (var f of this.whenSyncedListeners) {
-        f()
-      }
-      this.whenSyncedListeners = []
-      this.y.db.requestTransaction(function *() {
-        yield* this.garbageCollectAfterSync()
-      })
-    }
-  }
-  send (uid, message) {
-    if (this.debug) {
-      console.log(`send ${this.userId} -> ${uid}: ${message.type}`, m) // eslint-disable-line
-    }
-  }
-  /*
-    You received a raw message, and you know that it is intended for Yjs. Then call this function.
-  */
-  receiveMessage (sender, m) {
-    if (sender === this.userId) {
-      return
-    }
-    if (this.debug) {
-      console.log(`receive ${sender} -> ${this.userId}: ${m.type}`, JSON.parse(JSON.stringify(m))) // eslint-disable-line
-    }
-    if (m.type === 'sync step 1') {
-      // TODO: make transaction, stream the ops
-      let conn = this
-      this.y.db.requestTransaction(function *() {
-        var currentStateSet = yield* this.getStateSet()
-        yield* this.applyDeleteSet(m.deleteSet)
-
-        var ds = yield* this.getDeleteSet()
-        var ops = yield* this.getOperations(m.stateSet)
-        conn.send(sender, {
-          type: 'sync step 2',
-          os: ops,
-          stateSet: currentStateSet,
-          deleteSet: ds
-        })
-        if (this.forwardToSyncingClients) {
-          conn.syncingClients.push(sender)
-          setTimeout(function () {
-            conn.syncingClients = conn.syncingClients.filter(function (cli) {
-              return cli !== sender
-            })
-            conn.send(sender, {
-              type: 'sync done'
-            })
-          }, conn.syncingClientDuration)
-        } else {
-          conn.send(sender, {
-            type: 'sync done'
-          })
-        }
-        conn._setSyncedWith(sender)
-      })
-    } else if (m.type === 'sync step 2') {
-      let conn = this
-      var broadcastHB = !this.broadcastedHB
-      this.broadcastedHB = true
-      var db = this.y.db
-      this.syncStep2 = new Promise(function (resolve) {
-        db.requestTransaction(function * () {
-          yield* this.applyDeleteSet(m.deleteSet)
-          this.store.apply(m.os)
-          db.requestTransaction(function * () {
-            var ops = yield* this.getOperations(m.stateSet)
-            if (ops.length > 0) {
-              m = {
-                type: 'update',
-                ops: ops
-              }
-              if (!broadcastHB) { // TODO: consider to broadcast here..
-                conn.send(sender, m)
-              } else {
-                // broadcast only once!
-                conn.broadcast(m)
-              }
-            }
-            resolve()
-          })
-        })
-      })
-    } else if (m.type === 'sync done') {
-      var self = this
-      this.syncStep2.then(function () {
-        self._setSyncedWith(sender)
-      })
-    } else if (m.type === 'update') {
-      if (this.forwardToSyncingClients) {
-        for (var client of this.syncingClients) {
-          this.send(client, m)
-        }
-      }
-      this.y.db.apply(m.ops)
-    }
-  }
-  _setSyncedWith (user) {
-    var conn = this.connections[user]
-    if (conn != null) {
-      conn.isSynced = true
-    }
-    if (user === this.currentSyncTarget) {
-      this.currentSyncTarget = null
-      this.findNextSyncTarget()
-    }
-  }
-  /*
-    Currently, the HB encodes operations as JSON. For the moment I want to keep it
-    that way. Maybe we support encoding in the HB as XML in the future, but for now I don't want
-    too much overhead. Y is very likely to get changed a lot in the future
-
-    Because we don't want to encode JSON as string (with character escaping, wich makes it pretty much unreadable)
-    we encode the JSON as XML.
-
-    When the HB support encoding as XML, the format should look pretty much like this.
-
-    does not support primitive values as array elements
-    expects an ltx (less than xml) object
-  */
-  parseMessageFromXml (m) {
-    function parseArray (node) {
-      for (var n of node.children) {
-        if (n.getAttribute('isArray') === 'true') {
-          return parseArray(n)
-        } else {
-          return parseObject(n)
-        }
-      }
-    }
-    function parseObject (node) {
-      var json = {}
-      for (var attrName in node.attrs) {
-        var value = node.attrs[attrName]
-        var int = parseInt(value, 10)
-        if (isNaN(int) || ('' + int) !== value) {
-          json[attrName] = value
-        } else {
-          json[attrName] = int
-        }
-      }
-      for (var n in node.children) {
-        var name = n.name
-        if (n.getAttribute('isArray') === 'true') {
-          json[name] = parseArray(n)
-        } else {
-          json[name] = parseObject(n)
-        }
-      }
-      return json
-    }
-    parseObject(m)
-  }
-  /*
-    encode message in xml
-    we use string because Strophe only accepts an "xml-string"..
-    So {a:4,b:{c:5}} will look like
-    <y a="4">
-      <b c="5"></b>
-    </y>
-    m - ltx element
-    json - Object
-  */
-  encodeMessageToXml (msg, obj) {
-    // attributes is optional
-    function encodeObject (m, json) {
-      for (var name in json) {
-        var value = json[name]
-        if (name == null) {
-          // nop
-        } else if (value.constructor === Object) {
-          encodeObject(m.c(name), value)
-        } else if (value.constructor === Array) {
-          encodeArray(m.c(name), value)
-        } else {
-          m.setAttribute(name, value)
-        }
-      }
-    }
-    function encodeArray (m, array) {
-      m.setAttribute('isArray', 'true')
-      for (var e of array) {
-        if (e.constructor === Object) {
-          encodeObject(m.c('array-element'), e)
-        } else {
-          encodeArray(m.c('array-element'), e)
-        }
-      }
-    }
-    if (obj.constructor === Object) {
-      encodeObject(msg.c('y', { xmlns: 'http://y.ninja/connector-stanza' }), obj)
-    } else if (obj.constructor === Array) {
-      encodeArray(msg.c('y', { xmlns: 'http://y.ninja/connector-stanza' }), obj)
-    } else {
-      throw new Error("I can't encode this json!")
-    }
-  }
-}
-Y.AbstractConnector = AbstractConnector
--- a/src/Connectors/Test.js
+++ b/src/Connectors/Test.js
@@ -1,136 +0,0 @@
-/* global getRandom, Y, wait, async */
-'use strict'
-
-var globalRoom = {
-  users: {},
-  buffers: {},
-  removeUser: function (user) {
-    for (var i in this.users) {
-      this.users[i].userLeft(user)
-    }
-    delete this.users[user]
-    delete this.buffers[user]
-  },
-  addUser: function (connector) {
-    this.users[connector.userId] = connector
-    this.buffers[connector.userId] = []
-    for (var uname in this.users) {
-      if (uname !== connector.userId) {
-        var u = this.users[uname]
-        u.userJoined(connector.userId, 'master')
-        connector.userJoined(u.userId, 'master')
-      }
-    }
-  }
-}
-Y.utils.globalRoom = globalRoom
-
-function flushOne () {
-  var bufs = []
-  for (var i in globalRoom.buffers) {
-    if (globalRoom.buffers[i].length > 0) {
-      bufs.push(i)
-    }
-  }
-  if (bufs.length > 0) {
-    var userId = getRandom(bufs)
-    var m = globalRoom.buffers[userId].shift()
-    var user = globalRoom.users[userId]
-    user.receiveMessage(m[0], m[1])
-    return true
-  } else {
-    return false
-  }
-}
-
-// setInterval(flushOne, 10)
-
-var userIdCounter = 0
-
-class Test extends Y.AbstractConnector {
-  constructor (y, options) {
-    if (options === undefined) {
-      throw new Error('Options must not be undefined!')
-    }
-    options.role = 'master'
-    options.forwardToSyncingClients = false
-    super(y, options)
-    this.setUserId((userIdCounter++) + '').then(() => {
-      globalRoom.addUser(this)
-    })
-    this.globalRoom = globalRoom
-    this.syncingClientDuration = 0
-  }
-  receiveMessage (sender, m) {
-    super.receiveMessage(sender, JSON.parse(JSON.stringify(m)))
-  }
-  send (userId, message) {
-    var buffer = globalRoom.buffers[userId]
-    if (buffer != null) {
-      buffer.push(JSON.parse(JSON.stringify([this.userId, message])))
-    }
-  }
-  broadcast (message) {
-    for (var key in globalRoom.buffers) {
-      globalRoom.buffers[key].push(JSON.parse(JSON.stringify([this.userId, message])))
-    }
-  }
-  isDisconnected () {
-    return globalRoom.users[this.userId] == null
-  }
-  reconnect () {
-    if (this.isDisconnected()) {
-      globalRoom.addUser(this)
-      super.reconnect()
-    }
-    return this.flushAll()
-  }
-  disconnect () {
-    if (!this.isDisconnected()) {
-      globalRoom.removeUser(this.userId)
-      super.disconnect()
-    }
-    return wait()
-  }
-  flush () {
-    var self = this
-    return async(function * () {
-      yield wait()
-      while (globalRoom.buffers[self.userId].length > 0) {
-        var m = globalRoom.buffers[self.userId].shift()
-        this.receiveMessage(m[0], m[1])
-        yield wait()
-      }
-    })
-  }
-  flushAll () {
-    return new Promise(function (resolve) {
-      // flushes may result in more created operations,
-      // flush until there is nothing more to flush
-      function nextFlush () {
-        var c = flushOne()
-        if (c) {
-          while (flushOne()) {
-            // nop
-          }
-          wait().then(nextFlush)
-        } else {
-          wait().then(function () {
-            resolve()
-          })
-        }
-      }
-      // in the case that there are
-      // still actions that want to be performed
-      wait().then(nextFlush)
-    })
-  }
-  /*
-    Flushes an operation for some user..
-  */
-  flushOne () {
-    flushOne()
-  }
-}
-
-Y.Test = Test
--- a/src/Connectors/WebRTC.js
+++ b/src/Connectors/WebRTC.js
@@ -1,94 +0,0 @@
-/* global Y, SimpleWebRTC */
-'use strict'
-
-class WebRTC extends Y.AbstractConnector {
-  constructor (y, options) {
-    if (options === undefined) {
-      throw new Error('Options must not be undefined!')
-    }
-    if (options.room == null) {
-      throw new Error('You must define a room name!')
-    }
-    options.role = 'slave'
-    super(y, options)
-    this.webrtcOptions = {
-      url: options.url || 'https://yatta.ninja:8888',
-      room: options.room
-    }
-    var swr = new SimpleWebRTC(this.webrtcOptions)
-    this.swr = swr
-    var self = this
-    swr.once('connectionReady', function (userId) {
-      // SimpleWebRTC (swr) is initialized
-      swr.joinRoom(self.webrtcOptions.room)
-
-      swr.once('joinedRoom', function () {
-        self.setUserId(userId)
-        /*
-        var i
-        // notify the connector class about all the users that already
-        // joined the session
-        for(i in self.swr.webrtc.peers){
-          self.userJoined(self.swr.webrtc.peers[i].id, "master")
-        }*/
-        swr.on('channelMessage', function (peer, room_, message) {
-          // The client received a message
-          // Check if the connector is already initialized,
-          // only then forward the message to the connector class
-          if (message.type != null) {
-            self.receiveMessage(peer.id, message.payload)
-          }
-        })
-      })
-
-      swr.on('createdPeer', function (peer) {
-        // a new peer/client joined the session.
-        // Notify the connector class, if the connector
-        // is already initialized
-        self.userJoined(peer.id, 'master')
-      })
-
-      swr.on('peerStreamRemoved', function (peer) {
-        // a client left the session.
-        // Notify the connector class, if the connector
-        // is already initialized
-        self.userLeft(peer.id)
-      })
-    })
-  }
-  disconnect () {
-    this.swr.leaveRoom()
-    super.disconnect()
-  }
-  reconnect () {
-    this.swr.joinRoom(this.webrtcOptions.room)
-    super.reconnect()
-  }
-  send (uid, message) {
-    var self = this
-    // we have to make sure that the message is sent under all circumstances
-    var send = function () {
-      // check if the clients still exists
-      var peer = self.swr.webrtc.getPeers(uid)[0]
-      var success
-      if (peer) {
-        // success is true, if the message is successfully sent
-        success = peer.sendDirectly('simplewebrtc', 'yjs', message)
-      }
-      if (!success) {
-        // resend the message if it didn't work
-        setTimeout(send, 500)
-      }
-    }
-    // try to send the message
-    send()
-  }
-  broadcast (message) {
-    this.swr.sendDirectlyToAll('simplewebrtc', 'yjs', message)
-  }
-  isDisconnected () {
-    return false
-  }
-}
-
-Y.WebRTC = WebRTC
--- a/src/Database.js
+++ b/src/Database.js
@@ -1,341 +0,0 @@
-/* global Y */
-'use strict'
-
-/*
-  Partial definition of an OperationStore.
-  TODO: name it Database, operation store only holds operations.
-
-  A database definition must alse define the following methods:
-  * logTable() (optional)
-    - show relevant information information in a table
-  * requestTransaction(makeGen)
-    - request a transaction
-  * destroy()
-    - destroy the database
-*/
-class AbstractDatabase {
-  constructor (y, opts) {
-    this.y = y
-    // E.g. this.listenersById[id] : Array<Listener>
-    this.listenersById = {}
-    // Execute the next time a transaction is requested
-    this.listenersByIdExecuteNow = []
-    // A transaction is requested
-    this.listenersByIdRequestPending = false
-    /* To make things more clear, the following naming conventions:
-       * ls : we put this.listenersById on ls
-       * l : Array<Listener>
-       * id : Id (can't use as property name)
-       * sid : String (converted from id via JSON.stringify
-                       so we can use it as a property name)
-
-      Always remember to first overwrite
-      a property before you iterate over it!
-    */
-    // TODO: Use ES7 Weak Maps. This way types that are no longer user,
-    // wont be kept in memory.
-    this.initializedTypes = {}
-    this.whenUserIdSetListener = null
-    this.waitingTransactions = []
-    this.transactionInProgress = false
-    if (typeof YConcurrency_TestingMode !== 'undefined') {
-      this.executeOrder = []
-    }
-    this.gc1 = [] // first stage
-    this.gc2 = [] // second stage -> after that, remove the op
-    this.gcTimeout = opts.gcTimeout || 5000
-    var os = this
-    function garbageCollect () {
-      return new Promise((resolve) => {
-        os.requestTransaction(function * () {
-          if (os.y.connector != null && os.y.connector.isSynced) {
-            for (var i in os.gc2) {
-              var oid = os.gc2[i]
-              yield* this.garbageCollectOperation(oid)
-            }
-            os.gc2 = os.gc1
-            os.gc1 = []
-          }
-          if (os.gcTimeout > 0) {
-            os.gcInterval = setTimeout(garbageCollect, os.gcTimeout)
-          }
-          resolve()
-        })
-      })
-    }
-    this.garbageCollect = garbageCollect
-    if (this.gcTimeout > 0) {
-      garbageCollect()
-    }
-  }
-  addToDebug () {
-    if (typeof YConcurrency_TestingMode !== 'undefined') {
-      var command = Array.prototype.map.call(arguments, function (s) {
-        if (typeof s === 'string') {
-          return s
-        } else {
-          return JSON.stringify(s)
-        }
-      }).join('').replace(/"/g, "'").replace(/,/g, ', ').replace(/:/g, ': ')
-      this.executeOrder.push(command)
-    }
-  }
-  getDebugData () {
-    console.log(this.executeOrder.join('\n'))
-  }
-  stopGarbageCollector () {
-    var self = this
-    return new Promise(function (resolve) {
-      self.requestTransaction(function * () {
-        var ungc = self.gc1.concat(self.gc2)
-        self.gc1 = []
-        self.gc2 = []
-        for (var i in ungc) {
-          var op = yield* this.getOperation(ungc[i])
-          delete op.gc
-          yield* this.setOperation(op)
-        }
-        resolve()
-      })
-    })
-  }
-  /*
-    Try to add to GC.
-
-    TODO: rename this function
-
-    Rulez:
-    * Only gc if this user is online
-    * The most left element in a list must not be gc'd.
-      => There is at least one element in the list
-
-    returns true iff op was added to GC
-  */
-  addToGarbageCollector (op, left) {
-    if (
-      op.gc == null &&
-      op.deleted === true &&
-      this.y.connector.isSynced &&
-      left != null &&
-      left.deleted === true
-    ) {
-      op.gc = true
-      this.gc1.push(op.id)
-      return true
-    } else {
-      return false
-    }
-  }
-  removeFromGarbageCollector (op) {
-    function filter (o) {
-      return !Y.utils.compareIds(o, op.id)
-    }
-    this.gc1 = this.gc1.filter(filter)
-    this.gc2 = this.gc2.filter(filter)
-    delete op.gc
-  }
-  destroy () {
-    clearInterval(this.gcInterval)
-    this.gcInterval = null
-  }
-  setUserId (userId) {
-    var self = this
-    return new Promise(function (resolve) {
-      self.requestTransaction(function * () {
-        self.userId = userId
-        self.opClock = (yield* this.getState(userId)).clock
-        if (self.whenUserIdSetListener != null) {
-          self.whenUserIdSetListener()
-          self.whenUserIdSetListener = null
-        }
-        resolve()
-      })
-    })
-  }
-  whenUserIdSet (f) {
-    if (this.userId != null) {
-      f()
-    } else {
-      this.whenUserIdSetListener = f
-    }
-  }
-  getNextOpId () {
-    if (this.userId == null) {
-      throw new Error('OperationStore not yet initialized!')
-    }
-    return [this.userId, this.opClock++]
-  }
-  /*
-    Apply a list of operations.
-
-    * get a transaction
-    * check whether all Struct.*.requiredOps are in the OS
-    * check if it is an expected op (otherwise wait for it)
-    * check if was deleted, apply a delete operation after op was applied
-  */
-  apply (ops) {
-    for (var key in ops) {
-      var o = ops[key]
-      var required = Y.Struct[o.struct].requiredOps(o)
-      this.whenOperationsExist(required, o)
-    }
-  }
-  /*
-    op is executed as soon as every operation requested is available.
-    Note that Transaction can (and should) buffer requests.
-  */
-  whenOperationsExist (ids, op) {
-    if (ids.length > 0) {
-      let listener = {
-        op: op,
-        missing: ids.length
-      }
-
-      for (let key in ids) {
-        let id = ids[key]
-        let sid = JSON.stringify(id)
-        let l = this.listenersById[sid]
-        if (l == null) {
-          l = []
-          this.listenersById[sid] = l
-        }
-        l.push(listener)
-      }
-    } else {
-      this.listenersByIdExecuteNow.push({
-        op: op
-      })
-    }
-
-    if (this.listenersByIdRequestPending) {
-      return
-    }
-
-    this.listenersByIdRequestPending = true
-    var store = this
-
-    this.requestTransaction(function * () {
-      var exeNow = store.listenersByIdExecuteNow
-      store.listenersByIdExecuteNow = []
-
-      var ls = store.listenersById
-      store.listenersById = {}
-
-      store.listenersByIdRequestPending = false
-
-      for (let key in exeNow) {
-        let o = exeNow[key].op
-        yield* store.tryExecute.call(this, o)
-      }
-
-      for (var sid in ls) {
-        var l = ls[sid]
-        var id = JSON.parse(sid)
-        if ((yield* this.getOperation(id)) == null) {
-          store.listenersById[sid] = l
-        } else {
-          for (let key in l) {
-            let listener = l[key]
-            let o = listener.op
-            if (--listener.missing === 0) {
-              yield* store.tryExecute.call(this, o)
-            }
-          }
-        }
-      }
-    })
-  }
-  /*
-    Actually execute an operation, when all expected operations are available.
-  */
-  * tryExecute (op) {
-    this.store.addToDebug('yield* this.store.tryExecute.call(this, ', JSON.stringify(op), ')')
-    if (op.struct === 'Delete') {
-      yield* Y.Struct.Delete.execute.call(this, op)
-      yield* this.store.operationAdded(this, op)
-    } else if ((yield* this.getOperation(op.id)) == null && !(yield* this.isGarbageCollected(op.id))) {
-      yield* Y.Struct[op.struct].execute.call(this, op)
-      yield* this.addOperation(op)
-      yield* this.store.operationAdded(this, op)
-    }
-  }
-  // called by a transaction when an operation is added
-  * operationAdded (transaction, op) {
-    if (op.struct === 'Delete') {
-      var target = yield* transaction.getOperation(op.target)
-      if (target != null) {
-        var type = transaction.store.initializedTypes[JSON.stringify(target.parent)]
-        if (type != null) {
-          yield* type._changed(transaction, {
-            struct: 'Delete',
-            target: op.target
-          })
-        }
-      }
-    } else {
-      // increase SS
-      var o = op
-      var state = yield* transaction.getState(op.id[0])
-      while (o != null && o.id[1] === state.clock && op.id[0] === o.id[0]) {
-        // either its a new operation (1. case), or it is an operation that was deleted, but is not yet in the OS
-        state.clock++
-        yield* transaction.checkDeleteStoreForState(state)
-        o = yield* transaction.os.findNext(o.id)
-      }
-      yield* transaction.setState(state)
-
-      // notify whenOperation listeners (by id)
-      var sid = JSON.stringify(op.id)
-      var l = this.listenersById[sid]
-      delete this.listenersById[sid]
-
-      if (l != null) {
-        for (var key in l) {
-          var listener = l[key]
-          if (--listener.missing === 0) {
-            this.whenOperationsExist([], listener.op)
-          }
-        }
-      }
-      var t = this.initializedTypes[JSON.stringify(op.parent)]
-      // notify parent, if it has been initialized as a custom type
-      if (t != null) {
-        yield* t._changed(transaction, Y.utils.copyObject(op))
-      }
-
-      // Delete if DS says this is actually deleted
-      if (!op.deleted && (yield* transaction.isDeleted(op.id))) {
-        var delop = {
-          struct: 'Delete',
-          target: op.id
-        }
-        yield* Y.Struct['Delete'].execute.call(transaction, delop)
-        if (t != null) {
-          yield* t._changed(transaction, delop)
-        }
-      }
-    }
-  }
-  getNextRequest () {
-    if (this.waitingTransactions.length === 0) {
-      this.transactionInProgress = false
-      return null
-    } else {
-      return this.waitingTransactions.shift()
-    }
-  }
-  requestTransaction (makeGen, callImmediately) {
-    if (callImmediately) {
-      this.transact(makeGen)
-    } else if (!this.transactionInProgress) {
-      this.transactionInProgress = true
-      var self = this
-      setTimeout(function () {
-        self.transact(makeGen)
-      }, 0)
-    } else {
-      this.waitingTransactions.push(makeGen)
-    }
-  }
-}
-Y.AbstractDatabase = AbstractDatabase
--- a/src/Database.spec.js
+++ b/src/Database.spec.js
@@ -1,351 +0,0 @@
-/* global Y, async, databases */
-/* eslint-env browser,jasmine,console */
-
-for (let database of databases) {
-  describe(`Database (${database})`, function () {
-    var store
-    describe('DeleteStore', function () {
-      describe('Basic', function () {
-        beforeEach(function () {
-          store = new Y[database](null, {
-            gcTimeout: -1,
-            namespace: 'testing'
-          })
-        })
-        afterEach(function (done) {
-          store.requestTransaction(function * () {
-            yield* this.store.destroy()
-            done()
-          })
-        })
-        it('Deleted operation is deleted', async(function * (done) {
-          store.requestTransaction(function * () {
-            yield* this.markDeleted(['u1', 10])
-            expect(yield* this.isDeleted(['u1', 10])).toBeTruthy()
-            expect(yield* this.getDeleteSet()).toEqual({'u1': [[10, 1, false]]})
-            done()
-          })
-        }))
-        it('Deleted operation extends other deleted operation', async(function * (done) {
-          store.requestTransaction(function * () {
-            yield* this.markDeleted(['u1', 10])
-            yield* this.markDeleted(['u1', 11])
-            expect(yield* this.isDeleted(['u1', 10])).toBeTruthy()
-            expect(yield* this.isDeleted(['u1', 11])).toBeTruthy()
-            expect(yield* this.getDeleteSet()).toEqual({'u1': [[10, 2, false]]})
-            done()
-          })
-        }))
-        it('Deleted operation extends other deleted operation', async(function * (done) {
-          store.requestTransaction(function * () {
-            yield* this.markDeleted(['0', 3])
-            yield* this.markDeleted(['0', 4])
-            yield* this.markDeleted(['0', 2])
-            expect(yield* this.getDeleteSet()).toEqual({'0': [[2, 3, false]]})
-            done()
-          })
-        }))
-        it('Debug #1', async(function * (done) {
-          store.requestTransaction(function * () {
-            yield* this.markDeleted(['166', 0])
-            yield* this.markDeleted(['166', 2])
-            yield* this.markDeleted(['166', 0])
-            yield* this.markDeleted(['166', 2])
-            yield* this.markGarbageCollected(['166', 2])
-            yield* this.markDeleted(['166', 1])
-            yield* this.markDeleted(['166', 3])
-            yield* this.markGarbageCollected(['166', 3])
-            yield* this.markDeleted(['166', 0])
-            expect(yield* this.getDeleteSet()).toEqual({'166': [[0, 2, false], [2, 2, true]]})
-            done()
-          })
-        }))
-        it('Debug #2', async(function * (done) {
-          store.requestTransaction(function * () {
-            yield* this.markDeleted(['293', 0])
-            yield* this.markDeleted(['291', 2])
-            yield* this.markDeleted(['291', 2])
-            yield* this.markGarbageCollected(['293', 0])
-            yield* this.markDeleted(['293', 1])
-            yield* this.markGarbageCollected(['291', 2])
-            expect(yield* this.getDeleteSet()).toEqual({'291': [[2, 1, true]], '293': [[0, 1, true], [1, 1, false]]})
-            done()
-          })
-        }))
-        it('Debug #3', async(function * (done) {
-          store.requestTransaction(function * () {
-            yield* this.markDeleted(['581', 0])
-            yield* this.markDeleted(['581', 1])
-            yield* this.markDeleted(['580', 0])
-            yield* this.markDeleted(['580', 0])
-            yield* this.markGarbageCollected(['581', 0])
-            yield* this.markDeleted(['581', 2])
-            yield* this.markDeleted(['580', 1])
-            yield* this.markDeleted(['580', 2])
-            yield* this.markDeleted(['580', 1])
-            yield* this.markDeleted(['580', 2])
-            yield* this.markGarbageCollected(['581', 2])
-            yield* this.markGarbageCollected(['581', 1])
-            yield* this.markGarbageCollected(['580', 1])
-            expect(yield* this.getDeleteSet()).toEqual({'580': [[0, 1, false], [1, 1, true], [2, 1, false]], '581': [[0, 3, true]]})
-            done()
-          })
-        }))
-        it('Debug #4', async(function * (done) {
-          store.requestTransaction(function * () {
-            yield* this.markDeleted(['544', 0])
-            yield* this.markDeleted(['543', 2])
-            yield* this.markDeleted(['544', 0])
-            yield* this.markDeleted(['543', 2])
-            yield* this.markGarbageCollected(['544', 0])
-            yield* this.markDeleted(['545', 1])
-            yield* this.markDeleted(['543', 4])
-            yield* this.markDeleted(['543', 3])
-            yield* this.markDeleted(['544', 1])
-            yield* this.markDeleted(['544', 2])
-            yield* this.markDeleted(['544', 1])
-            yield* this.markDeleted(['544', 2])
-            yield* this.markGarbageCollected(['543', 2])
-            yield* this.markGarbageCollected(['543', 4])
-            yield* this.markGarbageCollected(['544', 2])
-            yield* this.markGarbageCollected(['543', 3])
-            expect(yield* this.getDeleteSet()).toEqual({'543': [[2, 3, true]], '544': [[0, 1, true], [1, 1, false], [2, 1, true]], '545': [[1, 1, false]]})
-            done()
-          })
-        }))
-        it('Debug #5', async(function * (done) {
-          store.requestTransaction(function * () {
-            yield* this.applyDeleteSet({'16': [[1, 2, false]], '17': [[0, 1, true], [1, 3, false]]})
-            expect(yield* this.getDeleteSet()).toEqual({'16': [[1, 2, false]], '17': [[0, 1, true], [1, 3, false]]})
-            yield* this.applyDeleteSet({'16': [[1, 2, false]], '17': [[0, 4, true]]})
-            expect(yield* this.getDeleteSet()).toEqual({'16': [[1, 2, false]], '17': [[0, 4, true]]})
-            done()
-          })
-        }))
-        it('Debug #6', async(function * (done) {
-          store.requestTransaction(function * () {
-            yield* this.applyDeleteSet({'40': [[0, 3, false]]})
-            expect(yield* this.getDeleteSet()).toEqual({'40': [[0, 3, false]]})
-            yield* this.applyDeleteSet({'39': [[2, 2, false]], '40': [[0, 1, true], [1, 2, false]], '41': [[2, 1, false]]})
-            expect(yield* this.getDeleteSet()).toEqual({'39': [[2, 2, false]], '40': [[0, 1, true], [1, 2, false]], '41': [[2, 1, false]]})
-            done()
-          })
-        }))
-        it('Debug #7', async(function * (done) {
-          store.requestTransaction(function * () {
-            yield* this.markDeleted(['9', 2])
-            yield* this.markDeleted(['11', 2])
-            yield* this.markDeleted(['11', 4])
-            yield* this.markDeleted(['11', 1])
-            yield* this.markDeleted(['9', 4])
-            yield* this.markDeleted(['10', 0])
-            yield* this.markGarbageCollected(['11', 2])
-            yield* this.markDeleted(['11', 2])
-            yield* this.markGarbageCollected(['11', 3])
-            yield* this.markDeleted(['11', 3])
-            yield* this.markDeleted(['11', 3])
-            yield* this.markDeleted(['9', 4])
-            yield* this.markDeleted(['10', 0])
-            yield* this.markGarbageCollected(['11', 1])
-            yield* this.markDeleted(['11', 1])
-            expect(yield* this.getDeleteSet()).toEqual({'9': [[2, 1, false], [4, 1, false]], '10': [[0, 1, false]], '11': [[1, 3, true], [4, 1, false]]})
-            done()
-          })
-        }))
-      })
-    })
-    describe('OperationStore', function () {
-      describe('Basic Tests', function () {
-        beforeEach(function () {
-          store = new Y[database](null, {
-            gcTimeout: -1,
-            namespace: 'testing'
-          })
-        })
-        afterEach(function (done) {
-          store.requestTransaction(function * () {
-            yield* this.store.destroy()
-            done()
-          })
-        })
-        it('debug #1', function (done) {
-          store.requestTransaction(function * () {
-            yield* this.os.put({id: [2]})
-            yield* this.os.put({id: [0]})
-            yield* this.os.delete([2])
-            yield* this.os.put({id: [1]})
-            expect(yield* this.os.find([0])).toBeTruthy()
-            expect(yield* this.os.find([1])).toBeTruthy()
-            expect(yield* this.os.find([2])).toBeFalsy()
-            done()
-          })
-        })
-        it('can add&retrieve 5 elements', function (done) {
-          store.requestTransaction(function * () {
-            yield* this.os.put({val: 'four', id: [4]})
-            yield* this.os.put({val: 'one', id: [1]})
-            yield* this.os.put({val: 'three', id: [3]})
-            yield* this.os.put({val: 'two', id: [2]})
-            yield* this.os.put({val: 'five', id: [5]})
-            expect((yield* this.os.find([1])).val).toEqual('one')
-            expect((yield* this.os.find([2])).val).toEqual('two')
-            expect((yield* this.os.find([3])).val).toEqual('three')
-            expect((yield* this.os.find([4])).val).toEqual('four')
-            expect((yield* this.os.find([5])).val).toEqual('five')
-            done()
-          })
-        })
-        it('5 elements do not exist anymore after deleting them', function (done) {
-          store.requestTransaction(function * () {
-            yield* this.os.put({val: 'four', id: [4]})
-            yield* this.os.put({val: 'one', id: [1]})
-            yield* this.os.put({val: 'three', id: [3]})
-            yield* this.os.put({val: 'two', id: [2]})
-            yield* this.os.put({val: 'five', id: [5]})
-            yield* this.os.delete([4])
-            expect(yield* this.os.find([4])).not.toBeTruthy()
-            yield* this.os.delete([3])
-            expect(yield* this.os.find([3])).not.toBeTruthy()
-            yield* this.os.delete([2])
-            expect(yield* this.os.find([2])).not.toBeTruthy()
-            yield* this.os.delete([1])
-            expect(yield* this.os.find([1])).not.toBeTruthy()
-            yield* this.os.delete([5])
-            expect(yield* this.os.find([5])).not.toBeTruthy()
-            done()
-          })
-        })
-      })
-      var numberOfOSTests = 1000
-      describe(`Random Tests - after adding&deleting (0.8/0.2) ${numberOfOSTests} times`, function () {
-        var elements = []
-        beforeAll(function (done) {
-          store = new Y[database](null, {
-            gcTimeout: -1,
-            namespace: 'testing'
-          })
-          store.requestTransaction(function * () {
-            for (var i = 0; i < numberOfOSTests; i++) {
-              var r = Math.random()
-              if (r < 0.8) {
-                var obj = [Math.floor(Math.random() * numberOfOSTests * 10000)]
-                if (!(yield* this.os.find(obj))) {
-                  elements.push(obj)
-                  yield* this.os.put({id: obj})
-                }
-              } else if (elements.length > 0) {
-                var elemid = Math.floor(Math.random() * elements.length)
-                var elem = elements[elemid]
-                elements = elements.filter(function (e) {
-                  return !Y.utils.compareIds(e, elem)
-                })
-                yield* this.os.delete(elem)
-              }
-            }
-            done()
-          })
-        })
-        afterAll(function (done) {
-          store.requestTransaction(function * () {
-            yield* this.store.destroy()
-            done()
-          })
-        })
-        it('can find every object', function (done) {
-          store.requestTransaction(function * () {
-            for (var id of elements) {
-              expect((yield* this.os.find(id)).id).toEqual(id)
-            }
-            done()
-          })
-        })
-
-        it('can find every object with lower bound search', function (done) {
-          store.requestTransaction(function * () {
-            for (var id of elements) {
-              var e = yield* this.os.findWithLowerBound(id)
-              expect(e.id).toEqual(id)
-            }
-            done()
-          })
-        })
-
-        it('iterating over a tree with lower bound yields the right amount of results', function (done) {
-          var lowerBound = elements[Math.floor(Math.random() * elements.length)]
-          var expectedResults = elements.filter(function (e, pos) {
-            return (Y.utils.smaller(lowerBound, e) || Y.utils.compareIds(e, lowerBound)) && elements.indexOf(e) === pos
-          }).length
-
-          var actualResults = 0
-          store.requestTransaction(function * () {
-            yield* this.os.iterate(this, lowerBound, null, function * (val) {
-              expect(val).toBeDefined()
-              actualResults++
-            })
-            expect(expectedResults).toEqual(actualResults)
-            done()
-          })
-        })
-
-        it('iterating over a tree without bounds yield the right amount of results', function (done) {
-          var lowerBound = null
-          var expectedResults = elements.filter(function (e, pos) {
-            return elements.indexOf(e) === pos
-          }).length
-          var actualResults = 0
-          store.requestTransaction(function * () {
-            yield* this.os.iterate(this, lowerBound, null, function * (val) {
-              expect(val).toBeDefined()
-              actualResults++
-            })
-            expect(expectedResults).toEqual(actualResults)
-            done()
-          })
-        })
-
-        it('iterating over a tree with upper bound yields the right amount of results', function (done) {
-          var upperBound = elements[Math.floor(Math.random() * elements.length)]
-          var expectedResults = elements.filter(function (e, pos) {
-            return (Y.utils.smaller(e, upperBound) || Y.utils.compareIds(e, upperBound)) && elements.indexOf(e) === pos
-          }).length
-
-          var actualResults = 0
-          store.requestTransaction(function * () {
-            yield* this.os.iterate(this, null, upperBound, function * (val) {
-              expect(val).toBeDefined()
-              actualResults++
-            })
-            expect(expectedResults).toEqual(actualResults)
-            done()
-          })
-        })
-
-        it('iterating over a tree with upper and lower bounds yield the right amount of results', function (done) {
-          var b1 = elements[Math.floor(Math.random() * elements.length)]
-          var b2 = elements[Math.floor(Math.random() * elements.length)]
-          var upperBound, lowerBound
-          if (Y.utils.smaller(b1, b2)) {
-            lowerBound = b1
-            upperBound = b2
-          } else {
-            lowerBound = b2
-            upperBound = b1
-          }
-          var expectedResults = elements.filter(function (e, pos) {
-            return (Y.utils.smaller(lowerBound, e) || Y.utils.compareIds(e, lowerBound)) &&
-              (Y.utils.smaller(e, upperBound) || Y.utils.compareIds(e, upperBound)) && elements.indexOf(e) === pos
-          }).length
-          var actualResults = 0
-          store.requestTransaction(function * () {
-            yield* this.os.iterate(this, lowerBound, upperBound, function * (val) {
-              expect(val).toBeDefined()
-              actualResults++
-            })
-            expect(expectedResults).toEqual(actualResults)
-            done()
-          })
-        })
-      })
-    })
-  })
-}
--- a/src/Databases/IndexedDB.js
+++ b/src/Databases/IndexedDB.js
@@ -1,181 +0,0 @@
-/* global Y */
-
-'use strict'
-
-Y.IndexedDB = (function () {
-  class Store {
-    constructor (transaction, name) {
-      this.store = transaction.objectStore(name)
-    }
-    * find (id) {
-      return yield this.store.get(id)
-    }
-    * put (v) {
-      yield this.store.put(v)
-    }
-    * delete (id) {
-      yield this.store.delete(id)
-    }
-    * findWithLowerBound (start) {
-      return yield this.store.openCursor(window.IDBKeyRange.lowerBound(start))
-    }
-    * findWithUpperBound (end) {
-      return yield this.store.openCursor(window.IDBKeyRange.upperBound(end), 'prev')
-    }
-    * findNext (id) {
-      return yield* this.findWithLowerBound([id[0], id[1] + 1])
-    }
-    * findPrev (id) {
-      return yield* this.findWithUpperBound([id[0], id[1] - 1])
-    }
-    * iterate (t, start, end, gen) {
-      var range = null
-      if (start != null && end != null) {
-        range = window.IDBKeyRange.bound(start, end)
-      } else if (start != null) {
-        range = window.IDBKeyRange.lowerBound(start)
-      } else if (end != null) {
-        range = window.IDBKeyRange.upperBound(end)
-      }
-      var cursorResult = this.store.openCursor(range)
-      while ((yield cursorResult) != null) {
-        yield* gen.call(t, cursorResult.result.value)
-        cursorResult.result.continue()
-      }
-    }
-
-  }
-  class Transaction extends Y.Transaction {
-    constructor (store) {
-      super(store)
-      var transaction = store.db.transaction(['OperationStore', 'StateStore', 'DeleteStore'], 'readwrite')
-      this.store = store
-      this.ss = new Store(transaction, 'StateStore')
-      this.os = new Store(transaction, 'OperationStore')
-      this.ds = new Store(transaction, 'DeleteStore')
-    }
-  }
-  class OperationStore extends Y.AbstractDatabase {
-    constructor (y, opts) {
-      super(y, opts)
-      if (opts == null) {
-        opts = {}
-      }
-      if (opts.namespace == null || typeof opts.namespace !== 'string') {
-        throw new Error('IndexedDB: expect a string (opts.namespace)!')
-      } else {
-        this.namespace = opts.namespace
-      }
-      if (opts.idbVersion != null) {
-        this.idbVersion = opts.idbVersion
-      } else {
-        this.idbVersion = 5
-      }
-      var store = this
-      // initialize database!
-      this.requestTransaction(function * () {
-        store.db = yield window.indexedDB.open(opts.namespace, store.idbVersion)
-      })
-      if (opts.cleanStart) {
-        this.requestTransaction(function * () {
-          yield this.os.store.clear()
-          yield this.ds.store.clear()
-          yield this.ss.store.clear()
-        })
-      }
-      var operationsToAdd = []
-      window.addEventListener('storage', function (event) {
-        if (event.key === '__YJS__' + store.namespace) {
-          operationsToAdd.push(event.newValue)
-          if (operationsToAdd.length === 1) {
-            store.requestTransaction(function * () {
-              var add = operationsToAdd
-              operationsToAdd = []
-              for (var i in add) {
-                // don't call the localStorage event twice..
-                var op = JSON.parse(add[i])
-                if (op.struct !== 'Delete') {
-                  op = yield* this.getOperation(op.id)
-                }
-                yield* this.store.operationAdded(this, op, true)
-              }
-            })
-          }
-        }
-      }, false)
-    }
-    * operationAdded (transaction, op, noAdd) {
-      yield* super.operationAdded(transaction, op)
-      if (!noAdd) {
-        window.localStorage['__YJS__' + this.namespace] = JSON.stringify(op)
-      }
-    }
-    transact (makeGen) {
-      var transaction = this.db != null ? new Transaction(this) : null
-      var store = this
-
-      var gen = makeGen.call(transaction)
-      handleTransactions(gen.next())
-
-      function handleTransactions (result) {
-        var request = result.value
-        if (result.done) {
-          makeGen = store.getNextRequest()
-          if (makeGen != null) {
-            if (transaction == null && store.db != null) {
-              transaction = new Transaction(store)
-            }
-            gen = makeGen.call(transaction)
-            handleTransactions(gen.next())
-          } // else no transaction in progress!
-          return
-        }
-        if (request.constructor === window.IDBRequest) {
-          request.onsuccess = function () {
-            var res = request.result
-            if (res != null && res.constructor === window.IDBCursorWithValue) {
-              res = res.value
-            }
-            handleTransactions(gen.next(res))
-          }
-          request.onerror = function (err) {
-            gen.throw(err)
-          }
-        } else if (request.constructor === window.IDBCursor) {
-          request.onsuccess = function () {
-            handleTransactions(gen.next(request.result != null ? request.result.value : null))
-          }
-          request.onerror = function (err) {
-            gen.throw(err)
-          }
-        } else if (request.constructor === window.IDBOpenDBRequest) {
-          request.onsuccess = function (event) {
-            var db = event.target.result
-            handleTransactions(gen.next(db))
-          }
-          request.onerror = function () {
-            gen.throw("Couldn't open IndexedDB database!")
-          }
-          request.onupgradeneeded = function (event) {
-            var db = event.target.result
-            try {
-              db.createObjectStore('OperationStore', {keyPath: 'id'})
-              db.createObjectStore('DeleteStore', {keyPath: 'id'})
-              db.createObjectStore('StateStore', {keyPath: 'id'})
-            } catch (e) {
-              console.log('Store already exists!')
-            }
-          }
-        } else {
-          gen.throw('You must not yield this type!')
-        }
-      }
-    }
-    // TODO: implement "free"..
-    * destroy () {
-      this.db.close()
-      yield window.indexedDB.deleteDatabase(this.namespace)
-    }
-  }
-  return OperationStore
-})()
--- a/src/Databases/IndexedDB.spec.js
+++ b/src/Databases/IndexedDB.spec.js
@@ -1,19 +0,0 @@
-/* global Y */
-/* eslint-env browser,jasmine */
-
-if (typeof window !== 'undefined' && false) {
-  describe('IndexedDB', function () {
-    var ob
-    beforeAll(function () {
-      ob = new Y.IndexedDB(null, {namespace: 'Test', gcTimeout: -1})
-    })
-
-    afterAll(function (done) {
-      ob.requestTransaction(function *() {
-        yield* ob.removeDatabase()
-        ob = null
-        done()
-      })
-    })
-  })
-}
--- a/src/Databases/Memory.js
+++ b/src/Databases/Memory.js
@@ -1,63 +0,0 @@
-/* global Y */
-'use strict'
-
-Y.Memory = (function () {
-  class Transaction extends Y.Transaction {
-    constructor (store) {
-      super(store)
-      this.store = store
-      this.ss = store.ss
-      this.os = store.os
-      this.ds = store.ds
-    }
-  }
-  class Database extends Y.AbstractDatabase {
-    constructor (y, opts) {
-      super(y, opts)
-      this.os = new Y.utils.RBTree()
-      this.ds = new Y.utils.RBTree()
-      this.ss = new Y.utils.RBTree()
-    }
-    logTable () {
-      var self = this
-      self.requestTransaction(function * () {
-        console.log('User: ', this.store.y.connector.userId, "==============================") // eslint-disable-line
-        console.log("State Set (SS):", yield* this.getStateSet()) // eslint-disable-line
-        console.log("Operation Store (OS):") // eslint-disable-line
-        yield* this.os.logTable() // eslint-disable-line
-        console.log("Deletion Store (DS):") //eslint-disable-line
-        yield* this.ds.logTable() // eslint-disable-line
-        if (this.store.gc1.length > 0 || this.store.gc2.length > 0) {
-          console.warn('GC1|2 not empty!', this.store.gc1, this.store.gc2)
-        }
-        if (JSON.stringify(this.store.listenersById) !== '{}') {
-          console.warn('listenersById not empty!')
-        }
-        if (JSON.stringify(this.store.listenersByIdExecuteNow) !== '[]') {
-          console.warn('listenersByIdExecuteNow not empty!')
-        }
-        if (this.store.transactionInProgress) {
-          console.warn('Transaction still in progress!')
-        }
-      }, true)
-    }
-    transact (makeGen) {
-      var t = new Transaction(this)
-      while (makeGen !== null) {
-        var gen = makeGen.call(t)
-        var res = gen.next()
-        while (!res.done) {
-          res = gen.next(res.value)
-        }
-        makeGen = this.getNextRequest()
-      }
-    }
-    * destroy () {
-      super.destroy()
-      delete this.os
-      delete this.ss
-      delete this.ds
-    }
-  }
-  return Database
-})()
--- a/src/Databases/RedBlackTree.js
+++ b/src/Databases/RedBlackTree.js
@@ -1,489 +0,0 @@
-/* global Y */
-'use strict'
-
-/*
-  This file contains a not so fancy implemantion of a Red Black Tree.
-*/
-
-class N {
-  // A created node is always red!
-  constructor (val) {
-    this.val = val
-    this.color = true
-    this._left = null
-    this._right = null
-    this._parent = null
-    if (val.id === null) {
-      throw new Error('You must define id!')
-    }
-  }
-  isRed () { return this.color }
-  isBlack () { return !this.color }
-  redden () { this.color = true; return this }
-  blacken () { this.color = false; return this }
-  get grandparent () {
-    return this.parent.parent
-  }
-  get parent () {
-    return this._parent
-  }
-  get sibling () {
-    return (this === this.parent.left)
-      ? this.parent.right : this.parent.left
-  }
-  get left () {
-    return this._left
-  }
-  get right () {
-    return this._right
-  }
-  set left (n) {
-    if (n !== null) {
-      n._parent = this
-    }
-    this._left = n
-  }
-  set right (n) {
-    if (n !== null) {
-      n._parent = this
-    }
-    this._right = n
-  }
-  rotateLeft (tree) {
-    var parent = this.parent
-    var newParent = this.right
-    var newRight = this.right.left
-    newParent.left = this
-    this.right = newRight
-    if (parent === null) {
-      tree.root = newParent
-      newParent._parent = null
-    } else if (parent.left === this) {
-      parent.left = newParent
-    } else if (parent.right === this) {
-      parent.right = newParent
-    } else {
-      throw new Error('The elements are wrongly connected!')
-    }
-  }
-  next () {
-    if (this.right !== null) {
-      // search the most left node in the right tree
-      var o = this.right
-      while (o.left !== null) {
-        o = o.left
-      }
-      return o
-    } else {
-      var p = this
-      while (p.parent !== null && p !== p.parent.left) {
-        p = p.parent
-      }
-      return p.parent
-    }
-  }
-  prev () {
-    if (this.left !== null) {
-      // search the most right node in the left tree
-      var o = this.left
-      while (o.right !== null) {
-        o = o.right
-      }
-      return o
-    } else {
-      var p = this
-      while (p.parent !== null && p !== p.parent.right) {
-        p = p.parent
-      }
-      return p.parent
-    }
-  }
-  rotateRight (tree) {
-    var parent = this.parent
-    var newParent = this.left
-    var newLeft = this.left.right
-    newParent.right = this
-    this.left = newLeft
-    if (parent === null) {
-      tree.root = newParent
-      newParent._parent = null
-    } else if (parent.left === this) {
-      parent.left = newParent
-    } else if (parent.right === this) {
-      parent.right = newParent
-    } else {
-      throw new Error('The elements are wrongly connected!')
-    }
-  }
-  getUncle () {
-    // we can assume that grandparent exists when this is called!
-    if (this.parent === this.parent.parent.left) {
-      return this.parent.parent.right
-    } else {
-      return this.parent.parent.left
-    }
-  }
-}
-
-class RBTree {
-  constructor () {
-    this.root = null
-    this.length = 0
-  }
-  * findNext (id) {
-    return yield* this.findWithLowerBound([id[0], id[1] + 1])
-  }
-  * findPrev (id) {
-    return yield* this.findWithUpperBound([id[0], id[1] - 1])
-  }
-  findNodeWithLowerBound (from) {
-    if (from === void 0) {
-      throw new Error('You must define from!')
-    }
-    var o = this.root
-    if (o === null) {
-      return null
-    } else {
-      while (true) {
-        if ((from === null || Y.utils.smaller(from, o.val.id)) && o.left !== null) {
-          // o is included in the bound
-          // try to find an element that is closer to the bound
-          o = o.left
-        } else if (from !== null && Y.utils.smaller(o.val.id, from)) {
-          // o is not within the bound, maybe one of the right elements is..
-          if (o.right !== null) {
-            o = o.right
-          } else {
-            // there is no right element. Search for the next bigger element,
-            // this should be within the bounds
-            return o.next()
-          }
-        } else {
-          return o
-        }
-      }
-    }
-  }
-  findNodeWithUpperBound (to) {
-    if (to === void 0) {
-      throw new Error('You must define from!')
-    }
-    var o = this.root
-    if (o === null) {
-      return null
-    } else {
-      while (true) {
-        if ((to === null || Y.utils.smaller(o.val.id, to)) && o.right !== null) {
-          // o is included in the bound
-          // try to find an element that is closer to the bound
-          o = o.right
-        } else if (to !== null && Y.utils.smaller(to, o.val.id)) {
-          // o is not within the bound, maybe one of the left elements is..
-          if (o.left !== null) {
-            o = o.left
-          } else {
-            // there is no left element. Search for the prev smaller element,
-            // this should be within the bounds
-            return o.prev()
-          }
-        } else {
-          return o
-        }
-      }
-    }
-  }
-  * findWithLowerBound (from) {
-    var n = this.findNodeWithLowerBound(from)
-    return n == null ? null : n.val
-  }
-  * findWithUpperBound (to) {
-    var n = this.findNodeWithUpperBound(to)
-    return n == null ? null : n.val
-  }
-  * iterate (t, from, to, f) {
-    var o = this.findNodeWithLowerBound(from)
-    while (o !== null && (to === null || Y.utils.smaller(o.val.id, to) || Y.utils.compareIds(o.val.id, to))) {
-      yield* f.call(t, o.val)
-      o = o.next()
-    }
-    return true
-  }
-  * logTable (from, to, filter) {
-    if (filter == null) {
-      filter = function () {
-        return true
-      }
-    }
-    if (from == null) { from = null }
-    if (to == null) { to = null }
-    var os = []
-    yield* this.iterate(this, from, to, function * (o) {
-      if (filter(o)) {
-        var o_ = {}
-        for (var key in o) {
-          if (typeof o[key] === 'object') {
-            o_[key] = JSON.stringify(o[key])
-          } else {
-            o_[key] = o[key]
-          }
-        }
-        os.push(o_)
-      }
-    })
-    if (console.table != null) {
-      console.table(os)
-    }
-  }
-  * find (id) {
-    var n
-    return (n = this.findNode(id)) ? n.val : null
-  }
-  findNode (id) {
-    if (id == null || id.constructor !== Array) {
-      throw new Error('Expect id to be an array!')
-    }
-    var o = this.root
-    if (o === null) {
-      return false
-    } else {
-      while (true) {
-        if (o === null) {
-          return false
-        }
-        if (Y.utils.smaller(id, o.val.id)) {
-          o = o.left
-        } else if (Y.utils.smaller(o.val.id, id)) {
-          o = o.right
-        } else {
-          return o
-        }
-      }
-    }
-  }
-  * delete (id) {
-    if (id == null || id.constructor !== Array) {
-      throw new Error('id is expected to be an Array!')
-    }
-    var d = this.findNode(id)
-    if (d == null) {
-      throw new Error('Element does not exist!')
-    }
-    this.length--
-    if (d.left !== null && d.right !== null) {
-      // switch d with the greates element in the left subtree.
-      // o should have at most one child.
-      var o = d.left
-      // find
-      while (o.right !== null) {
-        o = o.right
-      }
-      // switch
-      d.val = o.val
-      d = o
-    }
-    // d has at most one child
-    // let n be the node that replaces d
-    var isFakeChild
-    var child = d.left || d.right
-    if (child === null) {
-      isFakeChild = true
-      child = new N({id: 0})
-      child.blacken()
-      d.right = child
-    } else {
-      isFakeChild = false
-    }
-
-    if (d.parent === null) {
-      if (!isFakeChild) {
-        this.root = child
-        child.blacken()
-        child._parent = null
-      } else {
-        this.root = null
-      }
-      return
-    } else if (d.parent.left === d) {
-      d.parent.left = child
-    } else if (d.parent.right === d) {
-      d.parent.right = child
-    } else {
-      throw new Error('Impossible!')
-    }
-    if (d.isBlack()) {
-      if (child.isRed()) {
-        child.blacken()
-      } else {
-        this._fixDelete(child)
-      }
-    }
-    this.root.blacken()
-    if (isFakeChild) {
-      if (child.parent.left === child) {
-        child.parent.left = null
-      } else if (child.parent.right === child) {
-        child.parent.right = null
-      } else {
-        throw new Error('Impossible #3')
-      }
-    }
-  }
-  _fixDelete (n) {
-    function isBlack (node) {
-      return node !== null ? node.isBlack() : true
-    }
-    function isRed (node) {
-      return node !== null ? node.isRed() : false
-    }
-    if (n.parent === null) {
-      // this can only be called after the first iteration of fixDelete.
-      return
-    }
-    // d was already replaced by the child
-    // d is not the root
-    // d and child are black
-    var sibling = n.sibling
-    if (isRed(sibling)) {
-      // make sibling the grandfather
-      n.parent.redden()
-      sibling.blacken()
-      if (n === n.parent.left) {
-        n.parent.rotateLeft(this)
-      } else if (n === n.parent.right) {
-        n.parent.rotateRight(this)
-      } else {
-        throw new Error('Impossible #2')
-      }
-      sibling = n.sibling
-    }
-    // parent, sibling, and children of n are black
-    if (n.parent.isBlack() &&
-      sibling.isBlack() &&
-      isBlack(sibling.left) &&
-      isBlack(sibling.right)
-    ) {
-      sibling.redden()
-      this._fixDelete(n.parent)
-    } else if (n.parent.isRed() &&
-      sibling.isBlack() &&
-      isBlack(sibling.left) &&
-      isBlack(sibling.right)
-    ) {
-      sibling.redden()
-      n.parent.blacken()
-    } else {
-      if (n === n.parent.left &&
-        sibling.isBlack() &&
-        isRed(sibling.left) &&
-        isBlack(sibling.right)
-      ) {
-        sibling.redden()
-        sibling.left.blacken()
-        sibling.rotateRight(this)
-        sibling = n.sibling
-      } else if (n === n.parent.right &&
-        sibling.isBlack() &&
-        isRed(sibling.right) &&
-        isBlack(sibling.left)
-      ) {
-        sibling.redden()
-        sibling.right.blacken()
-        sibling.rotateLeft(this)
-        sibling = n.sibling
-      }
-      sibling.color = n.parent.color
-      n.parent.blacken()
-      if (n === n.parent.left) {
-        sibling.right.blacken()
-        n.parent.rotateLeft(this)
-      } else {
-        sibling.left.blacken()
-        n.parent.rotateRight(this)
-      }
-    }
-  }
-  * put (v) {
-    if (v == null || v.id == null || v.id.constructor !== Array) {
-      throw new Error('v is expected to have an id property which is an Array!')
-    }
-    var node = new N(v)
-    if (this.root !== null) {
-      var p = this.root // p abbrev. parent
-      while (true) {
-        if (Y.utils.smaller(node.val.id, p.val.id)) {
-          if (p.left === null) {
-            p.left = node
-            break
-          } else {
-            p = p.left
-          }
-        } else if (Y.utils.smaller(p.val.id, node.val.id)) {
-          if (p.right === null) {
-            p.right = node
-            break
-          } else {
-            p = p.right
-          }
-        } else {
-          p.val = node.val
-          return p
-        }
-      }
-      this._fixInsert(node)
-    } else {
-      this.root = node
-    }
-    this.length++
-    this.root.blacken()
-    return node
-  }
-  _fixInsert (n) {
-    if (n.parent === null) {
-      n.blacken()
-      return
-    } else if (n.parent.isBlack()) {
-      return
-    }
-    var uncle = n.getUncle()
-    if (uncle !== null && uncle.isRed()) {
-      // Note: parent: red, uncle: red
-      n.parent.blacken()
-      uncle.blacken()
-      n.grandparent.redden()
-      this._fixInsert(n.grandparent)
-    } else {
-      // Note: parent: red, uncle: black or null
-      // Now we transform the tree in such a way that
-      // either of these holds:
-      //   1) grandparent.left.isRed
-      //     and grandparent.left.left.isRed
-      //   2) grandparent.right.isRed
-      //     and grandparent.right.right.isRed
-      if (n === n.parent.right && n.parent === n.grandparent.left) {
-        n.parent.rotateLeft(this)
-        // Since we rotated and want to use the previous
-        // cases, we need to set n in such a way that
-        // n.parent.isRed again
-        n = n.left
-      } else if (n === n.parent.left && n.parent === n.grandparent.right) {
-        n.parent.rotateRight(this)
-        // see above
-        n = n.right
-      }
-      // Case 1) or 2) hold from here on.
-      // Now traverse grandparent, make parent a black node
-      // on the highest level which holds two red nodes.
-      n.parent.blacken()
-      n.grandparent.redden()
-      if (n === n.parent.left) {
-        // Case 1
-        n.grandparent.rotateRight(this)
-      } else {
-        // Case 2
-        n.grandparent.rotateLeft(this)
-      }
-    }
-  }
-}
-
-Y.utils.RBTree = RBTree
--- a/src/Databases/RedBlackTree.spec.js
+++ b/src/Databases/RedBlackTree.spec.js
@@ -1,212 +0,0 @@
-/* global Y */
-/* eslint-env browser,jasmine,console */
-
-var numberOfRBTreeTests = 1000
-
-function itRedNodesDoNotHaveBlackChildren () {
-  it('Red nodes do not have black children', function () {
-    function traverse (n) {
-      if (n == null) {
-        return
-      }
-      if (n.isRed()) {
-        if (n.left != null) {
-          expect(n.left.isRed()).not.toBeTruthy()
-        }
-        if (n.right != null) {
-          expect(n.right.isRed()).not.toBeTruthy()
-        }
-      }
-      traverse(n.left)
-      traverse(n.right)
-    }
-    traverse(this.tree.root)
-  })
-}
-
-function itBlackHeightOfSubTreesAreEqual () {
-  it('Black-height of sub-trees are equal', function () {
-    function traverse (n) {
-      if (n == null) {
-        return 0
-      }
-      var sub1 = traverse(n.left)
-      var sub2 = traverse(n.right)
-      expect(sub1).toEqual(sub2)
-      if (n.isRed()) {
-        return sub1
-      } else {
-        return sub1 + 1
-      }
-    }
-    traverse(this.tree.root)
-  })
-}
-
-function itRootNodeIsBlack () {
-  it('root node is black', function () {
-    expect(this.tree.root == null || this.tree.root.isBlack()).toBeTruthy()
-  })
-}
-
-describe('RedBlack Tree', function () {
-  var tree, memory
-  describe('debug #2', function () {
-    beforeAll(function (done) {
-      this.memory = new Y.Memory(null, {
-        name: 'Memory',
-        gcTimeout: -1
-      })
-      this.tree = this.memory.os
-      tree = this.tree
-      memory = this.memory
-      memory.requestTransaction(function * () {
-        yield* tree.put({id: [8433]})
-        yield* tree.put({id: [12844]})
-        yield* tree.put({id: [1795]})
-        yield* tree.put({id: [30302]})
-        yield* tree.put({id: [64287]})
-        yield* tree.delete([8433])
-        yield* tree.put({id: [28996]})
-        yield* tree.delete([64287])
-        yield* tree.put({id: [22721]})
-        done()
-      })
-    })
-
-    itRootNodeIsBlack()
-    itBlackHeightOfSubTreesAreEqual([])
-  })
-
-  describe(`After adding&deleting (0.8/0.2) ${numberOfRBTreeTests} times`, function () {
-    var elements = []
-    beforeAll(function (done) {
-      this.memory = new Y.Memory(null, {
-        name: 'Memory',
-        gcTimeout: -1
-      })
-      this.tree = this.memory.os
-      tree = this.tree
-      memory = this.memory
-      memory.requestTransaction(function * () {
-        for (var i = 0; i < numberOfRBTreeTests; i++) {
-          var r = Math.random()
-          if (r < 0.8) {
-            var obj = [Math.floor(Math.random() * numberOfRBTreeTests * 10000)]
-            if (!tree.findNode(obj)) {
-              elements.push(obj)
-              yield* tree.put({id: obj})
-            }
-          } else if (elements.length > 0) {
-            var elemid = Math.floor(Math.random() * elements.length)
-            var elem = elements[elemid]
-            elements = elements.filter(function (e) {
-              return !Y.utils.compareIds(e, elem)
-            })
-            yield* tree.delete(elem)
-          }
-        }
-        done()
-      })
-    })
-
-    itRootNodeIsBlack()
-
-    it('can find every object', function (done) {
-      memory.requestTransaction(function * () {
-        for (var id of elements) {
-          expect((yield* tree.find(id)).id).toEqual(id)
-        }
-        done()
-      })
-    })
-
-    it('can find every object with lower bound search', function (done) {
-      this.memory.requestTransaction(function * () {
-        for (var id of elements) {
-          expect((yield* tree.findWithLowerBound(id)).id).toEqual(id)
-        }
-        done()
-      })
-    })
-    itRedNodesDoNotHaveBlackChildren()
-
-    itBlackHeightOfSubTreesAreEqual()
-
-    it('iterating over a tree with lower bound yields the right amount of results', function (done) {
-      var lowerBound = elements[Math.floor(Math.random() * elements.length)]
-      var expectedResults = elements.filter(function (e, pos) {
-        return (Y.utils.smaller(lowerBound, e) || Y.utils.compareIds(e, lowerBound)) && elements.indexOf(e) === pos
-      }).length
-
-      var actualResults = 0
-      this.memory.requestTransaction(function * () {
-        yield* tree.iterate(this, lowerBound, null, function * (val) {
-          expect(val).toBeDefined()
-          actualResults++
-        })
-        expect(expectedResults).toEqual(actualResults)
-        done()
-      })
-    })
-
-    it('iterating over a tree without bounds yield the right amount of results', function (done) {
-      var lowerBound = null
-      var expectedResults = elements.filter(function (e, pos) {
-        return elements.indexOf(e) === pos
-      }).length
-      var actualResults = 0
-      this.memory.requestTransaction(function * () {
-        yield* tree.iterate(this, lowerBound, null, function * (val) {
-          expect(val).toBeDefined()
-          actualResults++
-        })
-        expect(expectedResults).toEqual(actualResults)
-        done()
-      })
-    })
-
-    it('iterating over a tree with upper bound yields the right amount of results', function (done) {
-      var upperBound = elements[Math.floor(Math.random() * elements.length)]
-      var expectedResults = elements.filter(function (e, pos) {
-        return (Y.utils.smaller(e, upperBound) || Y.utils.compareIds(e, upperBound)) && elements.indexOf(e) === pos
-      }).length
-
-      var actualResults = 0
-      this.memory.requestTransaction(function * () {
-        yield* tree.iterate(this, null, upperBound, function * (val) {
-          expect(val).toBeDefined()
-          actualResults++
-        })
-        expect(expectedResults).toEqual(actualResults)
-        done()
-      })
-    })
-
-    it('iterating over a tree with upper and lower bounds yield the right amount of results', function (done) {
-      var b1 = elements[Math.floor(Math.random() * elements.length)]
-      var b2 = elements[Math.floor(Math.random() * elements.length)]
-      var upperBound, lowerBound
-      if (Y.utils.smaller(b1, b2)) {
-        lowerBound = b1
-        upperBound = b2
-      } else {
-        lowerBound = b2
-        upperBound = b1
-      }
-      var expectedResults = elements.filter(function (e, pos) {
-        return (Y.utils.smaller(lowerBound, e) || Y.utils.compareIds(e, lowerBound)) &&
-          (Y.utils.smaller(e, upperBound) || Y.utils.compareIds(e, upperBound)) && elements.indexOf(e) === pos
-      }).length
-      var actualResults = 0
-      this.memory.requestTransaction(function * () {
-        yield* tree.iterate(this, lowerBound, upperBound, function * (val) {
-          expect(val).toBeDefined()
-          actualResults++
-        })
-        expect(expectedResults).toEqual(actualResults)
-        done()
-      })
-    })
-  })
-})
--- a/src/Helper.spec.js
+++ b/src/Helper.spec.js
@@ -1,288 +0,0 @@
-/* global Y */
-/* eslint-env browser, jasmine */
-
-/*
-  This is just a compilation of functions that help to test this library!
-*/
-
-// When testing, you store everything on the global object. We call it g
-var g
-if (typeof global !== 'undefined') {
-  g = global
-} else if (typeof window !== 'undefined') {
-  g = window
-} else {
-  throw new Error('No global object?')
-}
-g.g = g
-
-g.YConcurrency_TestingMode = true
-
-jasmine.DEFAULT_TIMEOUT_INTERVAL = 20000
-
-g.describeManyTimes = function describeManyTimes (times, name, f) {
-  for (var i = 0; i < times; i++) {
-    describe(name, f)
-  }
-}
-
-/*
-  Wait for a specified amount of time (in ms). defaults to 5ms
-*/
-function wait (t) {
-  if (t == null) {
-    t = 80
-  }
-  return new Promise(function (resolve) {
-    setTimeout(function () {
-      resolve()
-    }, t * 2)
-  })
-}
-g.wait = wait
-
-g.databases = ['Memory']
-if (typeof window !== 'undefined') {
-  g.databases.push('IndexedDB')
-}
-
-/*
-  returns a random element of o.
-  works on Object, and Array
-*/
-function getRandom (o) {
-  if (o instanceof Array) {
-    return o[Math.floor(Math.random() * o.length)]
-  } else if (o.constructor === Object) {
-    var ks = []
-    for (var key in o) {
-      ks.push(key)
-    }
-    return o[getRandom(ks)]
-  }
-}
-g.getRandom = getRandom
-
-function getRandomNumber (n) {
-  if (n == null) {
-    n = 9999
-  }
-  return Math.floor(Math.random() * n)
-}
-g.getRandomNumber = getRandomNumber
-
-function * applyTransactions (relAmount, numberOfTransactions, objects, users, transactions) {
-  function randomTransaction (root) {
-    var f = getRandom(transactions)
-    f(root)
-  }
-  for (var i = 0; i < numberOfTransactions * relAmount + 1; i++) {
-    var r = Math.random()
-    if (r >= 0.5) {
-      // 50% chance to flush
-      users[0].connector.flushOne() // flushes for some user.. (not necessarily 0)
-    } else if (r >= 0.05) {
-      // 45% chance to create operation
-      randomTransaction(getRandom(objects))
-    } else {
-      // 5% chance to disconnect/reconnect
-      var u = getRandom(users)
-      if (u.connector.isDisconnected()) {
-        yield u.reconnect()
-      } else {
-        yield u.disconnect()
-      }
-    }
-    yield wait()
-  }
-}
-
-g.applyRandomTransactionsAllRejoinNoGC = async(function * applyRandomTransactions (users, objects, transactions, numberOfTransactions) {
-  yield* applyTransactions(1, numberOfTransactions, objects, users, transactions)
-  yield users[0].connector.flushAll()
-  yield wait()
-  for (var u in users) {
-    yield users[u].reconnect()
-  }
-  yield wait(100)
-  yield users[0].connector.flushAll()
-  yield g.garbageCollectAllUsers(users)
-})
-
-g.applyRandomTransactionsWithGC = async(function * applyRandomTransactions (users, objects, transactions, numberOfTransactions) {
-  yield* applyTransactions(1, numberOfTransactions, objects, users.slice(1), transactions)
-  yield users[0].connector.flushAll()
-  yield g.garbageCollectAllUsers(users)
-  yield wait(100)
-  for (var u in users) {
-    // TODO: here, we enforce that two users never sync at the same time with u[0]
-    //       enforce that in the connector itself!
-    yield users[u].reconnect()
-  }
-  yield wait(100)
-  yield users[0].connector.flushAll()
-  yield wait(100)
-  yield g.garbageCollectAllUsers(users)
-})
-
-g.garbageCollectAllUsers = async(function * garbageCollectAllUsers (users) {
-  // gc two times because of the two gc phases (really collect everything)
-  yield wait(100)
-  for (var i in users) {
-    yield users[i].db.garbageCollect()
-    yield users[i].db.garbageCollect()
-  }
-  yield wait(100)
-})
-
-g.compareAllUsers = async(function * compareAllUsers (users) {
-  var s1, s2 // state sets
-  var ds1, ds2 // delete sets
-  var allDels1, allDels2 // all deletions
-  var db1 = [] // operation store of user1
-
-  // t1 and t2 basically do the same. They define t[1,2], ds[1,2], and allDels[1,2]
-  function * t1 () {
-    s1 = yield* this.getStateSet()
-    ds1 = yield* this.getDeleteSet()
-    allDels1 = []
-    yield* this.ds.iterate(this, null, null, function * (d) {
-      allDels1.push(d)
-    })
-  }
-  function * t2 () {
-    s2 = yield* this.getStateSet()
-    ds2 = yield* this.getDeleteSet()
-    allDels2 = []
-    yield* this.ds.iterate(this, null, null, function * (d) {
-      allDels2.push(d)
-    })
-  }
-  yield users[0].connector.flushAll()
-  yield wait()
-  yield g.garbageCollectAllUsers(users)
-
-  for (var uid = 0; uid < users.length; uid++) {
-    var u = users[uid]
-    u.db.requestTransaction(function * () {
-      // compare deleted ops against deleteStore
-      yield* this.os.iterate(this, null, null, function * (o) {
-        if (o.deleted === true) {
-          expect(yield* this.isDeleted(o.id)).toBeTruthy()
-        }
-      })
-      // compare deleteStore against deleted ops
-      var ds = []
-      yield* this.ds.iterate(this, null, null, function * (d) {
-        ds.push(d)
-      })
-      for (var j in ds) {
-        var d = ds[j]
-        for (var i = 0; i < d.len; i++) {
-          var o = yield* this.getOperation([d.id[0], d.id[1] + i])
-          // gc'd or deleted
-          if (d.gc) {
-            expect(o).toBeFalsy()
-          } else {
-            expect(o.deleted).toBeTruthy()
-          }
-        }
-      }
-    })
-    // compare allDels tree
-    yield wait()
-    if (s1 == null) {
-      u.db.requestTransaction(function * () {
-        yield* t1.call(this)
-        yield* this.os.iterate(this, null, null, function * (o) {
-          o = Y.utils.copyObject(o)
-          delete o.origin
-          db1.push(o)
-        })
-      })
-      yield wait()
-    } else {
-      // TODO: make requestTransaction return a promise..
-      u.db.requestTransaction(function * () {
-        yield* t2.call(this)
-        expect(s1).toEqual(s2)
-        expect(allDels1).toEqual(allDels2) // inner structure
-        expect(ds1).toEqual(ds2) // exported structure
-        var count = 0
-        yield* this.os.iterate(this, null, null, function * (o) {
-          o = Y.utils.copyObject(o)
-          delete o.origin
-          expect(db1[count++]).toEqual(o)
-        })
-      })
-      yield wait()
-    }
-  }
-})
-
-g.createUsers = async(function * createUsers (self, numberOfUsers, database) {
-  if (Y.utils.globalRoom.users[0] != null) {
-    yield Y.utils.globalRoom.users[0].flushAll()
-  }
-  // destroy old users
-  for (var u in Y.utils.globalRoom.users) {
-    Y.utils.globalRoom.users[u].y.destroy()
-  }
-  self.users = null
-
-  var promises = []
-  for (var i = 0; i < numberOfUsers; i++) {
-    promises.push(Y({
-      db: {
-        name: database,
-        namespace: 'User ' + i,
-        cleanStart: true,
-        gcTimeout: -1
-      },
-      connector: {
-        name: 'Test',
-        debug: false
-      }
-    }))
-  }
-  self.users = yield Promise.all(promises)
-  return self.users
-})
-
-/*
-  Until async/await arrives in js, we use this function to wait for promises
-  by yielding them.
-*/
-function async (makeGenerator) {
-  return function (arg) {
-    var generator = makeGenerator.apply(this, arguments)
-
-    function handle (result) {
-      if (result.done) return Promise.resolve(result.value)
-
-      return Promise.resolve(result.value).then(function (res) {
-        return handle(generator.next(res))
-      }, function (err) {
-        return handle(generator.throw(err))
-      })
-    }
-    try {
-      return handle(generator.next())
-    } catch (ex) {
-      generator.throw(ex)
-      // return Promise.reject(ex)
-    }
-  }
-}
-g.async = async
-
-function logUsers (self) {
-  if (self.constructor === Array) {
-    self = {users: self}
-  }
-  self.users[0].db.logTable()
-  self.users[1].db.logTable()
-  self.users[2].db.logTable()
-}
-
-g.logUsers = logUsers
--- a/src/Notes.md
+++ b/src/Notes.md
@@ -1,12 +0,0 @@
-
-# Notes
-
-### Terminology
-
-* DB: DataBase that holds all the information of the shared object. It is devided into the OS, DS, and SS. This can be a persistent database or an in-memory database. Depending on the type of database, it could make sense to store OS, DS, and SS in different tables, or maybe different databases.
-* OS: OperationStore holds all the operations. An operation is a js object with a fixed number of name fields.
-* DS: DeleteStore holds the information about which operations are deleted and which operations were garbage collected (no longer available in the OS).
-* SS: StateSet holds the current state of the OS. SS.getState(username) refers to the amount of operations that were received by that respective user.
-* Op: Operation defines an action on a shared type. But it is also the format in which we store the model of a type. This is why it is also called a Struct/Structure.
-* Type and Structure: We crearly distinguish between type and structure. Short explanation: A type (e.g. Strings, Numbers) have a number of functions that you can apply on them. (+) is well defined on both of them. They are *modeled* by a structure - the functions really change the structure of a type. Types can be implemented differently but still provide the same functionality. In Yjs, almost all types are realized as a doubly linked list (on which Yjs can provide eventual convergence)
-*
--- a/src/Struct.js
+++ b/src/Struct.js
@@ -1,336 +0,0 @@
-/* global Y */
-'use strict'
-
-/*
- An operation also defines the structure of a type. This is why operation and
- structure are used interchangeably here.
-
- It must be of the type Object. I hope to achieve some performance
- improvements when working on databases that support the json format.
-
- An operation must have the following properties:
-
- * encode
-     - Encode the structure in a readable format (preferably string- todo)
- * decode (todo)
-     - decode structure to json
- * execute
-     - Execute the semantics of an operation.
- * requiredOps
-     - Operations that are required to execute this operation.
-*/
-
-var Struct = {
-  /* This is the only operation that is actually not a structure, because
-  it is not stored in the OS. This is why it _does not_ have an id
-
-  op = {
-    target: Id
-  }
-  */
-  Delete: {
-    encode: function (op) {
-      return op
-    },
-    requiredOps: function (op) {
-      return [] // [op.target]
-    },
-    execute: function * (op) {
-      return yield* this.deleteOperation(op.target)
-    }
-  },
-  Insert: {
-    /* {
-        content: any,
-        id: Id,
-        left: Id,
-        origin: Id,
-        right: Id,
-        parent: Id,
-        parentSub: string (optional), // child of Map type
-      }
-    */
-    encode: function (op) {
-      // TODO: you could not send the "left" property, then you also have to
-      // "op.left = null" in $execute or $decode
-      var e = {
-        id: op.id,
-        left: op.left,
-        right: op.right,
-        origin: op.origin,
-        parent: op.parent,
-        struct: op.struct
-      }
-      if (op.parentSub != null) {
-        e.parentSub = op.parentSub
-      }
-      if (op.opContent != null) {
-        e.opContent = op.opContent
-      } else {
-        e.content = op.content
-      }
-
-      return e
-    },
-    requiredOps: function (op) {
-      var ids = []
-      if (op.left != null) {
-        ids.push(op.left)
-      }
-      if (op.right != null) {
-        ids.push(op.right)
-      }
-      if (op.origin != null && !Y.utils.compareIds(op.left, op.origin)) {
-        ids.push(op.origin)
-      }
-      // if (op.right == null && op.left == null) {
-      ids.push(op.parent)
-
-      if (op.opContent != null) {
-        ids.push(op.opContent)
-      }
-      return ids
-    },
-    getDistanceToOrigin: function * (op) {
-      if (op.left == null) {
-        return 0
-      } else {
-        var d = 0
-        var o = yield* this.getOperation(op.left)
-        while (!Y.utils.compareIds(op.origin, (o ? o.id : null))) {
-          d++
-          if (o.left == null) {
-            break
-          } else {
-            o = yield* this.getOperation(o.left)
-          }
-        }
-        return d
-      }
-    },
-    /*
-    # $this has to find a unique position between origin and the next known character
-    # case 1: $origin equals $o.origin: the $creator parameter decides if left or right
-    #         let $OL= [o1,o2,o3,o4], whereby $this is to be inserted between o1 and o4
-    #         o2,o3 and o4 origin is 1 (the position of o2)
-    #         there is the case that $this.creator < o2.creator, but o3.creator < $this.creator
-    #         then o2 knows o3. Since on another client $OL could be [o1,o3,o4] the problem is complex
-    #         therefore $this would be always to the right of o3
-    # case 2: $origin < $o.origin
-    #         if current $this insert_position > $o origin: $this ins
-    #         else $insert_position will not change
-    #         (maybe we encounter case 1 later, then this will be to the right of $o)
-    # case 3: $origin > $o.origin
-    #         $this insert_position is to the left of $o (forever!)
-    */
-    execute: function *(op) {
-      var i // loop counter
-      var distanceToOrigin = i = yield* Struct.Insert.getDistanceToOrigin.call(this, op) // most cases: 0 (starts from 0)
-      var o
-      var parent
-      var start
-
-      // find o. o is the first conflicting operation
-      if (op.left != null) {
-        o = yield* this.getOperation(op.left)
-        o = (o.right == null) ? null : yield* this.getOperation(o.right)
-      } else { // left == null
-        parent = yield* this.getOperation(op.parent)
-        let startId = op.parentSub ? parent.map[op.parentSub] : parent.start
-        start = startId == null ? null : yield* this.getOperation(startId)
-        o = start
-      }
-
-      // handle conflicts
-      while (true) {
-        if (o != null && !Y.utils.compareIds(o.id, op.right)) {
-          var oOriginDistance = yield* Struct.Insert.getDistanceToOrigin.call(this, o)
-          if (oOriginDistance === i) {
-            // case 1
-            if (o.id[0] < op.id[0]) {
-              op.left = o.id
-              distanceToOrigin = i + 1
-            }
-          } else if (oOriginDistance < i) {
-            // case 2
-            if (i - distanceToOrigin <= oOriginDistance) {
-              op.left = o.id
-              distanceToOrigin = i + 1
-            }
-          } else {
-            break
-          }
-          i++
-          o = o.right ? yield* this.getOperation(o.right) : null
-        } else {
-          break
-        }
-      }
-
-      // reconnect..
-      var left = null
-      var right = null
-      parent = parent || (yield* this.getOperation(op.parent))
-
-      // reconnect left and set right of op
-      if (op.left != null) {
-        left = yield* this.getOperation(op.left)
-        op.right = left.right
-        left.right = op.id
-
-        yield* this.setOperation(left)
-      } else {
-        op.right = op.parentSub ? parent.map[op.parentSub] || null : parent.start
-      }
-      // reconnect right
-      if (op.right != null) {
-        right = yield* this.getOperation(op.right)
-        right.left = op.id
-
-        // if right exists, and it is supposed to be gc'd. Remove it from the gc
-        if (right.gc != null) {
-          this.store.removeFromGarbageCollector(right)
-        }
-        yield* this.setOperation(right)
-      }
-
-      // update parents .map/start/end properties
-      if (op.parentSub != null) {
-        if (left == null) {
-          parent.map[op.parentSub] = op.id
-          yield* this.setOperation(parent)
-        }
-        // is a child of a map struct.
-        // Then also make sure that only the most left element is not deleted
-        if (op.right != null) {
-          yield* this.deleteOperation(op.right, true)
-        }
-        if (op.left != null) {
-          yield* this.deleteOperation(op.id, true)
-        }
-      } else {
-        if (right == null || left == null) {
-          if (right == null) {
-            parent.end = op.id
-          }
-          if (left == null) {
-            parent.start = op.id
-          }
-          yield* this.setOperation(parent)
-        }
-      }
-    }
-  },
-  List: {
-    /*
-    {
-      start: null,
-      end: null,
-      struct: "List",
-      type: "",
-      id: this.os.getNextOpId()
-    }
-    */
-    encode: function (op) {
-      return {
-        struct: 'List',
-        id: op.id,
-        type: op.type
-      }
-    },
-    requiredOps: function () {
-      /*
-      var ids = []
-      if (op.start != null) {
-        ids.push(op.start)
-      }
-      if (op.end != null){
-        ids.push(op.end)
-      }
-      return ids
-      */
-      return []
-    },
-    execute: function * (op) {
-      op.start = null
-      op.end = null
-    },
-    ref: function * (op, pos) {
-      if (op.start == null) {
-        return null
-      }
-      var res = null
-      var o = yield* this.getOperation(op.start)
-
-      while (true) {
-        if (!o.deleted) {
-          res = o
-          pos--
-        }
-        if (pos >= 0 && o.right != null) {
-          o = (yield* this.getOperation(o.right))
-        } else {
-          break
-        }
-      }
-      return res
-    },
-    map: function * (o, f) {
-      o = o.start
-      var res = []
-      while (o != null) { // TODO: change to != (at least some convention)
-        var operation = yield* this.getOperation(o)
-        if (!operation.deleted) {
-          res.push(f(operation))
-        }
-        o = operation.right
-      }
-      return res
-    }
-  },
-  Map: {
-    /*
-      {
-        map: {},
-        struct: "Map",
-        type: "",
-        id: this.os.getNextOpId()
-      }
-    */
-    encode: function (op) {
-      return {
-        struct: 'Map',
-        type: op.type,
-        id: op.id,
-        map: {} // overwrite map!!
-      }
-    },
-    requiredOps: function () {
-      return []
-    },
-    execute: function * () {},
-    /*
-      Get a property by name
-    */
-    get: function * (op, name) {
-      var oid = op.map[name]
-      if (oid != null) {
-        var res = yield* this.getOperation(oid)
-        return (res == null || res.deleted) ? void 0 : (res.opContent == null
-          ? res.content : yield* this.getType(res.opContent))
-      }
-    },
-    /*
-      Delete a property by name
-    */
-    delete: function * (op, name) {
-      var v = op.map[name] || null
-      if (v != null) {
-        yield* Struct.Delete.create.call(this, {
-          target: v
-        })
-      }
-    }
-  }
-}
-Y.Struct = Struct
--- a/src/Transaction.js
+++ b/src/Transaction.js
@@ -1,653 +0,0 @@
-/* global Y */
-'use strict'
-
-/*
-  Partial definition of a transaction
-
-  A transaction provides all the the async functionality on a database.
-
-  By convention, a transaction has the following properties:
-  * ss for StateSet
-  * os for OperationStore
-  * ds for DeleteStore
-
-  A transaction must also define the following methods:
-  * checkDeleteStoreForState(state)
-    - When increasing the state of a user, an operation with an higher id
-      may already be garbage collected, and therefore it will never be received.
-      update the state to reflect this knowledge. This won't call a method to save the state!
-  * getDeleteSet(id)
-    - Get the delete set in a readable format:
-      {
-        "userX": [
-          [5,1], // starting from position 5, one operations is deleted
-          [9,4]  // starting from position 9, four operations are deleted
-        ],
-        "userY": ...
-      }
-  * getOpsFromDeleteSet(ds) -- TODO: just call this.deleteOperation(id) here
-    - get a set of deletions that need to be applied in order to get to
-      achieve the state of the supplied ds
-  * setOperation(op)
-    - write `op` to the database.
-      Note: this is allowed to return an in-memory object.
-      E.g. the Memory adapter returns the object that it has in-memory.
-      Changing values on this object will be stored directly in the database
-      without calling this function. Therefore,
-      setOperation may have no functionality in some adapters. This also has
-      implications on the way we use operations that were served from the database.
-      We try not to call copyObject, if not necessary.
-  * addOperation(op)
-    - add an operation to the database.
-      This may only be called once for every op.id
-      Must return a function that returns the next operation in the database (ordered by id)
-  * getOperation(id)
-  * removeOperation(id)
-    - remove an operation from the database. This is called when an operation
-      is garbage collected.
-  * setState(state)
-    - `state` is of the form
-      {
-        user: "1",
-        clock: 4
-      } <- meaning that we have four operations from user "1"
-           (with these id's respectively: 0, 1, 2, and 3)
-  * getState(user)
-  * getStateVector()
-    - Get the state of the OS in the form
-    [{
-      user: "userX",
-      clock: 11
-    },
-     ..
-    ]
-  * getStateSet()
-    - Get the state of the OS in the form
-    {
-      "userX": 11,
-      "userY": 22
-    }
-   * getOperations(startSS)
-     - Get the all the operations that are necessary in order to achive the
-       stateSet of this user, starting from a stateSet supplied by another user
-   * makeOperationReady(ss, op)
-     - this is called only by `getOperations(startSS)`. It makes an operation
-       applyable on a given SS.
-*/
-class Transaction {
-  /*
-    Get a type based on the id of its model.
-    If it does not exist yes, create it.
-    TODO: delete type from store.initializedTypes[id] when corresponding id was deleted!
-  */
-  * getType (id) {
-    var sid = JSON.stringify(id)
-    var t = this.store.initializedTypes[sid]
-    if (t == null) {
-      var op = yield* this.getOperation(id)
-      if (op != null) {
-        t = yield* Y[op.type].initType.call(this, this.store, op)
-        this.store.initializedTypes[sid] = t
-      }
-    }
-    return t
-  }
-  /*
-    Apply operations that this user created (no remote ones!)
-      * does not check for Struct.*.requiredOps()
-      * also broadcasts it through the connector
-  */
-  * applyCreatedOperations (ops) {
-    var send = []
-    for (var i = 0; i < ops.length; i++) {
-      var op = ops[i]
-      yield* this.store.tryExecute.call(this, op)
-      send.push(Y.Struct[op.struct].encode(op))
-    }
-    if (!this.store.y.connector.isDisconnected()) {
-      this.store.y.connector.broadcast({
-        type: 'update',
-        ops: send
-      })
-    }
-  }
-
-  * deleteList (start) {
-    if (this.store.y.connector.isSynced) {
-      while (start != null && this.store.y.connector.isSynced) {
-        start = (yield* this.getOperation(start))
-        start.gc = true
-        yield* this.setOperation(start)
-        // TODO: will always reset the parent..
-        this.store.gc1.push(start.id)
-        start = start.right
-      }
-    } else {
-      // TODO: when not possible??? do later in (gcWhenSynced)
-    }
-  }
-
-  /*
-    Mark an operation as deleted, and add it to the GC, if possible.
-  */
-  * deleteOperation (targetId, preventCallType) {
-    var target = yield* this.getOperation(targetId)
-    var callType = false
-
-    if (target == null || !target.deleted) {
-      yield* this.markDeleted(targetId)
-    }
-
-    if (target != null && target.gc == null) {
-      if (!target.deleted) {
-        callType = true
-        // set deleted & notify type
-        target.deleted = true
-        /*
-        if (!preventCallType) {
-          var type = this.store.initializedTypes[JSON.stringify(target.parent)]
-          if (type != null) {
-            yield* type._changed(this, {
-              struct: 'Delete',
-              target: targetId
-            })
-          }
-        }
-        */
-        // delete containing lists
-        if (target.start != null) {
-          // TODO: don't do it like this .. -.-
-          yield* this.deleteList(target.start)
-          yield* this.deleteList(target.id)
-        }
-        if (target.map != null) {
-          for (var name in target.map) {
-            yield* this.deleteList(target.map[name])
-          }
-          // TODO: here to..  (see above)
-          yield* this.deleteList(target.id)
-        }
-        if (target.opContent != null) {
-          yield* this.deleteOperation(target.opContent)
-          target.opContent = null
-        }
-      }
-      var left = target.left != null ? yield* this.getOperation(target.left) : null
-
-      this.store.addToGarbageCollector(target, left)
-
-      // set here because it was deleted and/or gc'd
-      yield* this.setOperation(target)
-
-      /*
-        Check if it is possible to add right to the gc.
-        Because this delete can't be responsible for left being gc'd,
-        we don't have to add left to the gc..
-      */
-      var right = target.right != null ? yield* this.getOperation(target.right) : null
-      if (
-        right != null &&
-        this.store.addToGarbageCollector(right, target)
-      ) {
-        yield* this.setOperation(right)
-      }
-      return callType
-    }
-  }
-  /*
-    Mark an operation as deleted&gc'd
-  */
-  * markGarbageCollected (id) {
-    // this.mem.push(["gc", id]);
-    var n = yield* this.markDeleted(id)
-    if (!n.gc) {
-      if (n.id[1] < id[1]) {
-        // un-extend left
-        var newlen = n.len - (id[1] - n.id[1])
-        n.len -= newlen
-        yield* this.ds.put(n)
-        n = {id: id, len: newlen, gc: false}
-        yield* this.ds.put(n)
-      }
-      // get prev&next before adding a new operation
-      var prev = yield* this.ds.findPrev(id)
-      var next = yield* this.ds.findNext(id)
-
-      if (id[1] < n.id[1] + n.len - 1) {
-        // un-extend right
-        yield* this.ds.put({id: [id[0], id[1] + 1], len: n.len - 1, gc: false})
-        n.len = 1
-      }
-      // set gc'd
-      n.gc = true
-      // can extend left?
-      if (
-        prev != null &&
-        prev.gc &&
-        Y.utils.compareIds([prev.id[0], prev.id[1] + prev.len], n.id)
-      ) {
-        prev.len += n.len
-        yield* this.ds.delete(n.id)
-        n = prev
-        // ds.put n here?
-      }
-      // can extend right?
-      if (
-        next != null &&
-        next.gc &&
-        Y.utils.compareIds([n.id[0], n.id[1] + n.len], next.id)
-      ) {
-        n.len += next.len
-        yield* this.ds.delete(next.id)
-      }
-      yield* this.ds.put(n)
-    }
-  }
-  /*
-    Mark an operation as deleted.
-
-    returns the delete node
-  */
-  * markDeleted (id) {
-    // this.mem.push(["del", id]);
-    var n = yield* this.ds.findWithUpperBound(id)
-    if (n != null && n.id[0] === id[0]) {
-      if (n.id[1] <= id[1] && id[1] < n.id[1] + n.len) {
-        // already deleted
-        return n
-      } else if (n.id[1] + n.len === id[1] && !n.gc) {
-        // can extend existing deletion
-        n.len++
-      } else {
-        // cannot extend left
-        n = {id: id, len: 1, gc: false}
-        yield* this.ds.put(n)
-      }
-    } else {
-      // cannot extend left
-      n = {id: id, len: 1, gc: false}
-      yield* this.ds.put(n)
-    }
-    // can extend right?
-    var next = yield* this.ds.findNext(n.id)
-    if (
-      next != null &&
-      Y.utils.compareIds([n.id[0], n.id[1] + n.len], next.id) &&
-      !next.gc
-    ) {
-      n.len = n.len + next.len
-      yield* this.ds.delete(next.id)
-    }
-    yield* this.ds.put(n)
-    return n
-  }
-  /*
-    Call this method when the client is connected&synced with the
-    other clients (e.g. master). This will query the database for
-    operations that can be gc'd and add them to the garbage collector.
-  */
-  * garbageCollectAfterSync () {
-    yield* this.os.iterate(this, null, null, function * (op) {
-      if (op.deleted && op.left != null) {
-        var left = yield* this.getOperation(op.left)
-        this.store.addToGarbageCollector(op, left)
-      }
-    })
-  }
-  /*
-    Really remove an op and all its effects.
-    The complicated case here is the Insert operation:
-    * reset left
-    * reset right
-    * reset parent.start
-    * reset parent.end
-    * reset origins of all right ops
-  */
-  * garbageCollectOperation (id) {
-    this.store.addToDebug('yield* this.garbageCollectOperation(', id, ')')
-    // check to increase the state of the respective user
-    var state = yield* this.getState(id[0])
-    if (state.clock === id[1]) {
-      state.clock++
-      // also check if more expected operations were gc'd
-      yield* this.checkDeleteStoreForState(state)
-      // then set the state
-      yield* this.setState(state)
-    }
-    yield* this.markGarbageCollected(id)
-
-    // if op exists, then clean that mess up..
-    var o = yield* this.getOperation(id)
-    if (o != null) {
-      /*
-      if (!o.deleted) {
-        yield* this.deleteOperation(id)
-        o = yield* this.getOperation(id)
-      }
-      */
-
-      // remove gc'd op from the left op, if it exists
-      if (o.left != null) {
-        var left = yield* this.getOperation(o.left)
-        left.right = o.right
-        yield* this.setOperation(left)
-      }
-      // remove gc'd op from the right op, if it exists
-      // also reset origins of right ops
-      if (o.right != null) {
-        var right = yield* this.getOperation(o.right)
-        right.left = o.left
-        if (Y.utils.compareIds(right.origin, o.id)) { // rights origin is o
-          // find new origin of right ops
-          // origin is the first left deleted operation
-          var neworigin = o.left
-          while (neworigin != null) {
-            var neworigin_ = yield* this.getOperation(neworigin)
-            if (neworigin_.deleted) {
-              break
-            }
-            neworigin = neworigin_.left
-          }
-
-          // reset origin of right
-          right.origin = neworigin
-
-          // reset origin of all right ops (except first right - duh!),
-          // until you find origin pointer to the left of o
-          var i = right.right == null ? null : yield* this.getOperation(right.right)
-          var ids = [o.id, o.right]
-          while (i != null && ids.some(function (id) {
-            return Y.utils.compareIds(id, i.origin)
-          })) {
-            if (Y.utils.compareIds(i.origin, o.id)) {
-              // reset origin of i
-              i.origin = neworigin
-              yield* this.setOperation(i)
-            }
-            // get next i
-            i = i.right == null ? null : yield* this.getOperation(i.right)
-          }
-        } /* otherwise, rights origin is to the left of o,
-             then there is no right op (from o), that origins in o */
-        yield* this.setOperation(right)
-      }
-
-      if (o.parent != null) {
-        // remove gc'd op from parent, if it exists
-        var parent = yield* this.getOperation(o.parent)
-        var setParent = false // whether to save parent to the os
-        if (o.parentSub != null) {
-          if (Y.utils.compareIds(parent.map[o.parentSub], o.id)) {
-            setParent = true
-            parent.map[o.parentSub] = o.right
-          }
-        } else {
-          if (Y.utils.compareIds(parent.start, o.id)) {
-            // gc'd op is the start
-            setParent = true
-            parent.start = o.right
-          }
-          if (Y.utils.compareIds(parent.end, o.id)) {
-            // gc'd op is the end
-            setParent = true
-            parent.end = o.left
-          }
-        }
-        if (setParent) {
-          yield* this.setOperation(parent)
-        }
-      }
-      // finally remove it from the os
-      yield* this.removeOperation(o.id)
-    }
-  }
-  * checkDeleteStoreForState (state) {
-    var n = yield* this.ds.findWithUpperBound([state.user, state.clock])
-    if (n != null && n.id[0] === state.user && n.gc) {
-      state.clock = Math.max(state.clock, n.id[1] + n.len)
-    }
-  }
-  /*
-    apply a delete set in order to get
-    the state of the supplied ds
-  */
-  * applyDeleteSet (ds) {
-    var deletions = []
-    function createDeletions (user, start, len, gc) {
-      for (var c = start; c < start + len; c++) {
-        deletions.push([user, c, gc])
-      }
-    }
-
-    for (var user in ds) {
-      var dv = ds[user]
-      var pos = 0
-      var d = dv[pos]
-      yield* this.ds.iterate(this, [user, 0], [user, Number.MAX_VALUE], function * (n) {
-        // cases:
-        // 1. d deletes something to the right of n
-        //  => go to next n (break)
-        // 2. d deletes something to the left of n
-        //  => create deletions
-        //  => reset d accordingly
-        //  *)=> if d doesn't delete anything anymore, go to next d (continue)
-        // 3. not 2) and d deletes something that also n deletes
-        //  => reset d so that it doesn't contain n's deletion
-        //  *)=> if d does not delete anything anymore, go to next d (continue)
-        while (d != null) {
-          var diff = 0 // describe the diff of length in 1) and 2)
-          if (n.id[1] + n.len <= d[0]) {
-            // 1)
-            break
-          } else if (d[0] < n.id[1]) {
-            // 2)
-            // delete maximum the len of d
-            // else delete as much as possible
-            diff = Math.min(n.id[1] - d[0], d[1])
-            createDeletions(user, d[0], diff, d[2])
-          } else {
-            // 3)
-            diff = n.id[1] + n.len - d[0] // never null (see 1)
-            if (d[2] && !n.gc) {
-              // d marks as gc'd but n does not
-              // then delete either way
-              createDeletions(user, d[0], Math.min(diff, d[1]), d[2])
-            }
-          }
-          if (d[1] <= diff) {
-            // d doesn't delete anything anymore
-            d = dv[++pos]
-          } else {
-            d[0] = d[0] + diff // reset pos
-            d[1] = d[1] - diff // reset length
-          }
-        }
-      })
-      // for the rest.. just apply it
-      for (; pos < dv.length; pos++) {
-        d = dv[pos]
-        createDeletions(user, d[0], d[1], d[2])
-      }
-    }
-    for (var i in deletions) {
-      var del = deletions[i]
-      var id = [del[0], del[1]]
-      // always try to delete..
-      var addOperation = yield* this.deleteOperation(id)
-      if (addOperation) {
-        // TODO:.. really .. here? You could prevent calling all these functions in operationAdded
-        yield* this.store.operationAdded(this, {struct: 'Delete', target: id})
-      }
-      if (del[2]) {
-        // gc
-        yield* this.garbageCollectOperation(id)
-      }
-    }
-  }
-  * isGarbageCollected (id) {
-    var n = yield* this.ds.findWithUpperBound(id)
-    return n != null && n.id[0] === id[0] && id[1] < n.id[1] + n.len && n.gc
-  }
-  /*
-    A DeleteSet (ds) describes all the deleted ops in the OS
-  */
-  * getDeleteSet () {
-    var ds = {}
-    yield* this.ds.iterate(this, null, null, function * (n) {
-      var user = n.id[0]
-      var counter = n.id[1]
-      var len = n.len
-      var gc = n.gc
-      var dv = ds[user]
-      if (dv === void 0) {
-        dv = []
-        ds[user] = dv
-      }
-      dv.push([counter, len, gc])
-    })
-    return ds
-  }
-  * isDeleted (id) {
-    var n = yield* this.ds.findWithUpperBound(id)
-    return n != null && n.id[0] === id[0] && id[1] < n.id[1] + n.len
-  }
-  * setOperation (op) {
-    yield* this.os.put(op)
-    return op
-  }
-  * addOperation (op) {
-    yield* this.os.put(op)
-  }
-  * getOperation (id) {
-    return yield* this.os.find(id)
-  }
-  * removeOperation (id) {
-    yield* this.os.delete(id)
-  }
-  * setState (state) {
-    var val = {
-      id: [state.user],
-      clock: state.clock
-    }
-    // TODO: find a way to skip this step.. (after implementing some dbs..)
-    if (yield* this.ss.find([state.user])) {
-      yield* this.ss.put(val)
-    } else {
-      yield* this.ss.put(val)
-    }
-  }
-  * getState (user) {
-    var n
-    var clock = (n = yield* this.ss.find([user])) == null ? null : n.clock
-    if (clock == null) {
-      clock = 0
-    }
-    return {
-      user: user,
-      clock: clock
-    }
-  }
-  * getStateVector () {
-    var stateVector = []
-    yield* this.ss.iterate(this, null, null, function * (n) {
-      stateVector.push({
-        user: n.id[0],
-        clock: n.clock
-      })
-    })
-    return stateVector
-  }
-  * getStateSet () {
-    var ss = {}
-    yield* this.ss.iterate(this, null, null, function * (n) {
-      ss[n.id[0]] = n.clock
-    })
-    return ss
-  }
-  * getOperations (startSS) {
-    // TODO: use bounds here!
-    if (startSS == null) {
-      startSS = {}
-    }
-    var ops = []
-
-    var endSV = yield* this.getStateVector()
-    for (var endState of endSV) {
-      var user = endState.user
-      if (user === '_') {
-        continue
-      }
-      var startPos = startSS[user] || 0
-
-      yield* this.os.iterate(this, [user, startPos], [user, Number.MAX_VALUE], function * (op) {
-        ops.push(op)
-      })
-    }
-    var res = []
-    for (var op of ops) {
-      res.push(yield* this.makeOperationReady(startSS, op))
-    }
-    return res
-  }
-  /*
-    Here, we make op executable for the receiving user.
-
-    Notes:
-      startSS: denotes to the SV that the remote user sent
-      currSS:  denotes to the state vector that the user should have if he
-               applies all already sent operations (increases is each step)
-
-    We face several problems:
-    * Execute op as is won't work because ops depend on each other
-     -> find a way so that they do not anymore
-    * When changing left, must not go more to the left than the origin
-    * When changing right, you have to consider that other ops may have op
-      as their origin, this means that you must not set one of these ops
-      as the new right (interdependencies of ops)
-    * can't just go to the right until you find the first known operation,
-      With currSS
-        -> interdependency of ops is a problem
-      With startSS
-        -> leads to inconsistencies when two users join at the same time.
-           Then the position depends on the order of execution -> error!
-
-      Solution:
-      -> re-create originial situation
-        -> set op.left = op.origin (which never changes)
-        -> set op.right
-             to the first operation that is known (according to startSS)
-             or to the first operation that has an origin that is not to the
-             right of op.
-        -> Enforces unique execution order -> happy user
-
-      Improvements: TODO
-        * Could set left to origin, or the first known operation
-          (startSS or currSS.. ?)
-          -> Could be necessary when I turn GC again.
-          -> Is a bad(ish) idea because it requires more computation
-  */
-  * makeOperationReady (startSS, op) {
-    op = Y.Struct[op.struct].encode(op)
-    op = Y.utils.copyObject(op)
-    var o = op
-    var ids = [op.id]
-    // search for the new op.right
-    // it is either the first known op (according to startSS)
-    // or the o that has no origin to the right of op
-    // (this is why we use the ids array)
-    while (o.right != null) {
-      var right = yield* this.getOperation(o.right)
-      if (o.right[1] < (startSS[o.right[0]] || 0) || !ids.some(function (id) {
-        return Y.utils.compareIds(id, right.origin)
-      })) {
-        break
-      }
-      ids.push(o.right)
-      o = right
-    }
-    op.right = o.right
-    op.left = op.origin
-    return op
-  }
-}
-Y.Transaction = Transaction
--- a/src/Types/Array.js
+++ b/src/Types/Array.js
@@ -1,192 +0,0 @@
-/* global Y */
-'use strict'
-
-;(function () {
-  class YArray {
-    constructor (os, _model, idArray, valArray) {
-      this.os = os
-      this._model = _model
-      // Array of all the operation id's
-      this.idArray = idArray
-      // Array of all the values
-      this.valArray = valArray
-      this.eventHandler = new Y.utils.EventHandler(ops => {
-        var userEvents = []
-        for (var i in ops) {
-          var op = ops[i]
-          if (op.struct === 'Insert') {
-            let pos
-            // we check op.left only!,
-            // because op.right might not be defined when this is called
-            if (op.left === null) {
-              pos = 0
-            } else {
-              var sid = JSON.stringify(op.left)
-              pos = this.idArray.indexOf(sid) + 1
-              if (pos <= 0) {
-                throw new Error('Unexpected operation!')
-              }
-            }
-            this.idArray.splice(pos, 0, JSON.stringify(op.id))
-            this.valArray.splice(pos, 0, op.content)
-            userEvents.push({
-              type: 'insert',
-              object: this,
-              index: pos,
-              length: 1
-            })
-          } else if (op.struct === 'Delete') {
-            let pos = this.idArray.indexOf(JSON.stringify(op.target))
-            if (pos >= 0) {
-              this.idArray.splice(pos, 1)
-              this.valArray.splice(pos, 1)
-              userEvents.push({
-                type: 'delete',
-                object: this,
-                index: pos,
-                length: 1
-              })
-            }
-          } else {
-            throw new Error('Unexpected struct!')
-          }
-        }
-        this.eventHandler.callEventListeners(userEvents)
-      })
-    }
-    get length () {
-      return this.idArray.length
-    }
-    get (pos) {
-      if (pos == null || typeof pos !== 'number') {
-        throw new Error('pos must be a number!')
-      }
-      return this.valArray[pos]
-    }
-    toArray () {
-      return this.valArray.slice()
-    }
-    insert (pos, contents) {
-      if (typeof pos !== 'number') {
-        throw new Error('pos must be a number!')
-      }
-      if (!(contents instanceof Array)) {
-        throw new Error('contents must be an Array of objects!')
-      }
-      if (contents.length === 0) {
-        return
-      }
-      if (pos > this.idArray.length || pos < 0) {
-        throw new Error('This position exceeds the range of the array!')
-      }
-      var mostLeft = pos === 0 ? null : JSON.parse(this.idArray[pos - 1])
-
-      var ops = []
-      var prevId = mostLeft
-      for (var i = 0; i < contents.length; i++) {
-        var op = {
-          left: prevId,
-          origin: prevId,
-          // right: mostRight,
-          // NOTE: I intentionally do not define right here, because it could be deleted
-          // at the time of creating this operation, and is therefore not defined in idArray
-          parent: this._model,
-          content: contents[i],
-          struct: 'Insert',
-          id: this.os.getNextOpId()
-        }
-        ops.push(op)
-        prevId = op.id
-      }
-      var eventHandler = this.eventHandler
-      eventHandler.awaitAndPrematurelyCall(ops)
-      this.os.requestTransaction(function *() {
-        // now we can set the right reference.
-        var mostRight
-        if (mostLeft != null) {
-          mostRight = (yield* this.getOperation(mostLeft)).right
-        } else {
-          mostRight = (yield* this.getOperation(ops[0].parent)).start
-        }
-        for (var j in ops) {
-          ops[j].right = mostRight
-        }
-        yield* this.applyCreatedOperations(ops)
-        eventHandler.awaitedInserts(ops.length)
-      })
-    }
-    delete (pos, length) {
-      if (length == null) { length = 1 }
-      if (typeof length !== 'number') {
-        throw new Error('pos must be a number!')
-      }
-      if (typeof pos !== 'number') {
-        throw new Error('pos must be a number!')
-      }
-      if (pos + length > this.idArray.length || pos < 0 || length < 0) {
-        throw new Error('The deletion range exceeds the range of the array!')
-      }
-      if (length === 0) {
-        return
-      }
-      var eventHandler = this.eventHandler
-      var newLeft = pos > 0 ? JSON.parse(this.idArray[pos - 1]) : null
-      var dels = []
-      for (var i = 0; i < length; i++) {
-        dels.push({
-          target: JSON.parse(this.idArray[pos + i]),
-          struct: 'Delete'
-        })
-      }
-      eventHandler.awaitAndPrematurelyCall(dels)
-      this.os.requestTransaction(function *() {
-        yield* this.applyCreatedOperations(dels)
-        eventHandler.awaitedDeletes(dels.length, newLeft)
-      })
-    }
-    observe (f) {
-      this.eventHandler.addEventListener(f)
-    }
-    * _changed (transaction, op) {
-      if (!op.deleted) {
-        if (op.struct === 'Insert') {
-          var l = op.left
-          var left
-          while (l != null) {
-            left = yield* transaction.getOperation(l)
-            if (!left.deleted) {
-              break
-            }
-            l = left.left
-          }
-          op.left = l
-        }
-        this.eventHandler.receivedOp(op)
-      }
-    }
-  }
-
-  Y.Array = new Y.utils.CustomType({
-    class: YArray,
-    createType: function * YArrayCreator () {
-      var modelid = this.store.getNextOpId()
-      var model = {
-        struct: 'List',
-        type: 'Array',
-        start: null,
-        end: null,
-        id: modelid
-      }
-      yield* this.applyCreatedOperations([model])
-      return modelid
-    },
-    initType: function * YArrayInitializer (os, model) {
-      var valArray = []
-      var idArray = yield* Y.Struct.List.map.call(this, model, function (c) {
-        valArray.push(c.content)
-        return JSON.stringify(c.id)
-      })
-      return new YArray(os, model.id, idArray, valArray)
-    }
-  })
-})()
--- a/src/Types/Array.spec.js
+++ b/src/Types/Array.spec.js
@@ -1,310 +0,0 @@
-/* global createUsers, databases, wait, Y, compareAllUsers, getRandomNumber, applyRandomTransactionsAllRejoinNoGC, applyRandomTransactionsWithGC, async, garbageCollectAllUsers, describeManyTimes */
-/* eslint-env browser,jasmine */
-
-var numberOfYArrayTests = 50
-var repeatArrayTests = 2
-
-for (let database of databases) {
-  describe(`Array Type (DB: ${database})`, function () {
-    var y1, y2, y3, yconfig1, yconfig2, yconfig3, flushAll
-
-    beforeEach(async(function * (done) {
-      yield createUsers(this, 3, database)
-      y1 = (yconfig1 = this.users[0]).root
-      y2 = (yconfig2 = this.users[1]).root
-      y3 = (yconfig3 = this.users[2]).root
-      flushAll = this.users[0].connector.flushAll
-      yield wait(10)
-      done()
-    }))
-    afterEach(async(function * (done) {
-      yield compareAllUsers(this.users)
-      done()
-    }))
-
-    describe('Basic tests', function () {
-      it('insert three elements, try re-get property', async(function * (done) {
-        var array = yield y1.set('Array', Y.Array)
-        array.insert(0, [1, 2, 3])
-        array = yield y1.get('Array') // re-get property
-        expect(array.toArray()).toEqual([1, 2, 3])
-        done()
-      }))
-      it('Basic insert in array (handle three conflicts)', async(function * (done) {
-        yield y1.set('Array', Y.Array)
-        yield flushAll()
-        var l1 = yield y1.get('Array')
-        l1.insert(0, [0])
-        var l2 = yield y2.get('Array')
-        l2.insert(0, [1])
-        var l3 = yield y3.get('Array')
-        l3.insert(0, [2])
-        yield flushAll()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        expect(l2.toArray()).toEqual(l3.toArray())
-        done()
-      }))
-      it('Basic insert&delete in array (handle three conflicts)', async(function * (done) {
-        var l1, l2, l3
-        l1 = yield y1.set('Array', Y.Array)
-        l1.insert(0, ['x', 'y', 'z'])
-        yield flushAll()
-        l1.insert(1, [0])
-        l2 = yield y2.get('Array')
-        l2.delete(0)
-        l2.delete(1)
-        l3 = yield y3.get('Array')
-        l3.insert(1, [2])
-        yield flushAll()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        expect(l2.toArray()).toEqual(l3.toArray())
-        expect(l2.toArray()).toEqual([0, 2, 'y'])
-        done()
-      }))
-      it('Handles getOperations ascending ids bug in late sync', async(function * (done) {
-        var l1, l2
-        l1 = yield y1.set('Array', Y.Array)
-        l1.insert(0, ['x', 'y'])
-        yield flushAll()
-        yconfig3.disconnect()
-        yconfig2.disconnect()
-        yield wait()
-        l2 = yield y2.get('Array')
-        l2.insert(1, [2])
-        l2.insert(1, [3])
-        yield yconfig2.reconnect()
-        yield yconfig3.reconnect()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        done()
-      }))
-      it('Handles deletions in late sync', async(function * (done) {
-        var l1, l2
-        l1 = yield y1.set('Array', Y.Array)
-        l1.insert(0, ['x', 'y'])
-        yield flushAll()
-        yield yconfig2.disconnect()
-        yield wait()
-        l2 = yield y2.get('Array')
-        l2.delete(1, 1)
-        l1.delete(0, 2)
-        yield yconfig2.reconnect()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        done()
-      }))
-      it('Handles deletions in late sync (2)', async(function * (done) {
-        var l1, l2
-        l1 = yield y1.set('Array', Y.Array)
-        yield flushAll()
-        l2 = yield y2.get('Array')
-        l1.insert(0, ['x', 'y'])
-        l1.delete(0, 2)
-        yield flushAll()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        done()
-      }))
-      it('Basic insert. Then delete the whole array', async(function * (done) {
-        var l1, l2, l3
-        l1 = yield y1.set('Array', Y.Array)
-        l1.insert(0, ['x', 'y', 'z'])
-        yield flushAll()
-        l1.delete(0, 3)
-        l2 = yield y2.get('Array')
-        l3 = yield y3.get('Array')
-        yield flushAll()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        expect(l2.toArray()).toEqual(l3.toArray())
-        expect(l2.toArray()).toEqual([])
-        done()
-      }))
-      it('Basic insert. Then delete the whole array (merge listeners on late sync)', async(function * (done) {
-        var l1, l2, l3
-        l1 = yield y1.set('Array', Y.Array)
-        l1.insert(0, ['x', 'y', 'z'])
-        yield flushAll()
-        yconfig2.disconnect()
-        l1.delete(0, 3)
-        l2 = yield y2.get('Array')
-        yield wait()
-        yield yconfig2.reconnect()
-        yield wait()
-        l3 = yield y3.get('Array')
-        yield flushAll()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        expect(l2.toArray()).toEqual(l3.toArray())
-        expect(l2.toArray()).toEqual([])
-        done()
-      }))
-      // TODO?
-      /* it('Basic insert. Then delete the whole array (merge deleter on late sync)', async(function * (done) {
-        var l1, l2, l3
-        l1 = yield y1.set('Array', Y.Array)
-        l1.insert(0, ['x', 'y', 'z'])
-        yield flushAll()
-        yconfig1.disconnect()
-        l1.delete(0, 3)
-        l2 = yield y2.get('Array')
-        yield yconfig1.reconnect()
-        l3 = yield y3.get('Array')
-        yield flushAll()
-        expect(l1.toArray()).toEqual(l2.toArray())
-        expect(l2.toArray()).toEqual(l3.toArray())
-        expect(l2.toArray()).toEqual([])
-        done()
-      })) */
-      it('throw insert & delete events', async(function * (done) {
-        var array = yield this.users[0].root.set('array', Y.Array)
-        var event
-        array.observe(function (e) {
-          event = e
-        })
-        array.insert(0, [0])
-        expect(event).toEqual([{
-          type: 'insert',
-          object: array,
-          index: 0,
-          length: 1
-        }])
-        array.delete(0)
-        expect(event).toEqual([{
-          type: 'delete',
-          object: array,
-          index: 0,
-          length: 1
-        }])
-        yield wait(50)
-        done()
-      }))
-      it('garbage collects', async(function * (done) {
-        var l1, l2, l3
-        l1 = yield y1.set('Array', Y.Array)
-        l1.insert(0, ['x', 'y', 'z'])
-        yield flushAll()
-        yconfig1.disconnect()
-        l1.delete(0, 3)
-        l2 = yield y2.get('Array')
-        yield wait()
-        yield yconfig1.reconnect()
-        yield wait()
-        l3 = yield y3.get('Array')
-        yield flushAll()
-        yield garbageCollectAllUsers(this.users)
-        expect(l1.toArray()).toEqual(l2.toArray())
-        expect(l2.toArray()).toEqual(l3.toArray())
-        expect(l2.toArray()).toEqual([])
-        done()
-      }))
-      it('debug right not existend in Insert.execute', async(function * (done) {
-        yconfig1.db.requestTransaction(function * () {
-          var ops = [{'struct':'Map','type':'Map','id':['130',0],'map':{}},{'id':['130',1],'left':null,'right':null,'origin':null,'parent':['_',0],'struct':'Insert','parentSub':'Map','opContent':['130',0]},{'struct':'Map','type':'Map','id':['130',0],'map':{}},{'id':['130',1],'left':null,'right':null,'origin':null,'parent':['_',0],'struct':'Insert','parentSub':'Map','opContent':['130',0]},{'struct':'Map','type':'Map','id':['130',0],'map':{}},{'id':['130',1],'left':null,'right':null,'origin':null,'parent':['_',0],'struct':'Insert','parentSub':'Map','opContent':['130',0]},{'left':null,'right':null,'origin':null,'parent':['130',0],'parentSub':'somekey','struct':'Insert','content':512,'id':['133',0]},{'id':['130',2],'left':null,'right':null,'origin':null,'parent':['130',0],'struct':'Insert','parentSub':'somekey','content':1131},{'id':['130',3],'left':null,'right':['130',2],'origin':null,'parent':['130',0],'struct':'Insert','parentSub':'somekey','content':4196},{'id':['131',3],'left':null,'right':null,'origin':null,'parent':['130',0],'struct':'Insert','parentSub':'somekey','content':5022}]//eslint-disable-line
-
-          for (var o of ops) {
-            yield* this.store.tryExecute.call(this, o)
-          }
-        })
-        yield wait()
-        yield yconfig3.disconnect()
-        yield yconfig2.disconnect()
-        yield flushAll()
-        wait()
-        yield yconfig3.reconnect()
-        yield yconfig2.reconnect()
-        yield wait()
-        yield flushAll()
-        done()
-      }))
-      it('debug right not existend in Insert.execute (2)', async(function * (done) {
-        yconfig1.db.requestTransaction(function * () {
-          yield* this.store.tryExecute.call(this, {'struct': 'Map', 'type': 'Map', 'id': ['153', 0], 'map': {}})
-          yield* this.store.tryExecute.call(this, {'id': ['153', 1], 'left': null, 'right': null, 'origin': null, 'parent': ['_', 0], 'struct': 'Insert', 'parentSub': 'Map', 'opContent': ['153', 0]})
-          yield* this.store.tryExecute.call(this, {'struct': 'Map', 'type': 'Map', 'id': ['153', 0], 'map': {}})
-          yield* this.store.tryExecute.call(this, {'id': ['153', 1], 'left': null, 'right': null, 'origin': null, 'parent': ['_', 0], 'struct': 'Insert', 'parentSub': 'Map', 'opContent': ['153', 0]})
-          yield* this.store.tryExecute.call(this, {'struct': 'Map', 'type': 'Map', 'id': ['153', 0], 'map': {}})
-          yield* this.store.tryExecute.call(this, {'id': ['153', 1], 'left': null, 'right': null, 'origin': null, 'parent': ['_', 0], 'struct': 'Insert', 'parentSub': 'Map', 'opContent': ['153', 0]})
-          yield* this.store.tryExecute.call(this, {'left': null, 'right': null, 'origin': null, 'parent': ['153', 0], 'parentSub': 'somekey', 'struct': 'Insert', 'content': 3784, 'id': ['154', 0]})
-          yield* this.store.tryExecute.call(this, {'left': null, 'right': ['154', 0], 'origin': null, 'parent': ['153', 0], 'parentSub': 'somekey', 'struct': 'Insert', 'content': 8217, 'id': ['154', 1]})
-          yield* this.store.tryExecute.call(this, {'left': null, 'right': ['154', 1], 'origin': null, 'parent': ['153', 0], 'parentSub': 'somekey', 'struct': 'Insert', 'content': 5036, 'id': ['154', 2]})
-          yield* this.store.tryExecute.call(this, {'id': ['153', 2], 'left': null, 'right': null, 'origin': null, 'parent': ['153', 0], 'struct': 'Insert', 'parentSub': 'somekey', 'content': 417})
-          yield* this.store.tryExecute.call(this, {'id': ['155', 0], 'left': null, 'right': null, 'origin': null, 'parent': ['153', 0], 'struct': 'Insert', 'parentSub': 'somekey', 'content': 2202})
-          yield* this.garbageCollectOperation(['153', 2])
-          yield* this.garbageCollectOperation(['154', 0])
-          yield* this.garbageCollectOperation(['154', 1])
-          yield* this.garbageCollectOperation(['154', 2])
-          yield* this.garbageCollectOperation(['155', 0])
-          yield* this.garbageCollectOperation(['156', 0])
-          yield* this.garbageCollectOperation(['157', 0])
-          yield* this.garbageCollectOperation(['157', 1])
-          yield* this.store.tryExecute.call(this, {'id': ['153', 3], 'left': null, 'right': null, 'origin': null, 'parent': ['153', 0], 'struct': 'Insert', 'parentSub': 'somekey', 'content': 4372})
-        })
-        yield wait()
-        yield yconfig3.disconnect()
-        yield yconfig2.disconnect()
-        yield flushAll()
-        wait()
-        yield yconfig3.reconnect()
-        yield yconfig2.reconnect()
-        yield wait()
-        yield flushAll()
-        done()
-      }))
-    })
-    describeManyTimes(repeatArrayTests, `Random tests`, function () {
-      var randomArrayTransactions = [
-        function insert (array) {
-          array.insert(getRandomNumber(array.toArray().length), [getRandomNumber()])
-        },
-        function _delete (array) {
-          var length = array.toArray().length
-          if (length > 0) {
-            array.delete(getRandomNumber(length - 1))
-          }
-        }
-      ]
-      function compareArrayValues (arrays) {
-        var firstArray
-        for (var l of arrays) {
-          var val = l.toArray()
-          if (firstArray == null) {
-            firstArray = val
-          } else {
-            expect(val).toEqual(firstArray)
-          }
-        }
-      }
-      beforeEach(async(function * (done) {
-        yield this.users[0].root.set('Array', Y.Array)
-        yield flushAll()
-
-        var promises = []
-        for (var u = 0; u < this.users.length; u++) {
-          promises.push(this.users[u].root.get('Array'))
-        }
-        this.arrays = yield Promise.all(promises)
-        done()
-      }))
-      it('arrays.length equals users.length', async(function * (done) {
-        expect(this.arrays.length).toEqual(this.users.length)
-        done()
-      }))
-      it(`succeed after ${numberOfYArrayTests} actions, no GC, all users disconnecting/reconnecting`, async(function * (done) {
-        for (var u of this.users) {
-          u.connector.debug = true
-        }
-        yield applyRandomTransactionsAllRejoinNoGC(this.users, this.arrays, randomArrayTransactions, numberOfYArrayTests)
-        yield flushAll()
-        yield compareArrayValues(this.arrays)
-        yield compareAllUsers(this.users)
-        done()
-      }))
-      it(`succeed after ${numberOfYArrayTests} actions, GC, user[0] is not disconnecting`, async(function * (done) {
-        for (var u of this.users) {
-          u.connector.debug = true
-        }
-        yield applyRandomTransactionsWithGC(this.users, this.arrays, randomArrayTransactions, numberOfYArrayTests)
-        yield flushAll()
-        yield compareArrayValues(this.arrays)
-        yield compareAllUsers(this.users)
-        done()
-      }))
-    })
-  })
-}
--- a/src/Types/Map.js
+++ b/src/Types/Map.js
@@ -1,295 +0,0 @@
-/* global Y */
-'use strict'
-
-;(function () {
-  class YMap {
-    constructor (os, model, contents, opContents) {
-      this._model = model.id
-      this.os = os
-      this.map = Y.utils.copyObject(model.map)
-      this.contents = contents
-      this.opContents = opContents
-      this.eventHandler = new Y.utils.EventHandler(ops => {
-        var userEvents = []
-        for (var i in ops) {
-          var op = ops[i]
-          var oldValue
-          // key is the name to use to access (op)content
-          var key = op.struct === 'Delete' ? op.key : op.parentSub
-
-          // compute oldValue
-          if (this.opContents[key] != null) {
-            let prevType = this.opContents[key]
-            oldValue = () => {// eslint-disable-line
-              return new Promise((resolve) => {
-                this.os.requestTransaction(function *() {// eslint-disable-line
-                  resolve(yield* this.getType(prevType))
-                })
-              })
-            }
-          } else {
-            oldValue = this.contents[key]
-          }
-          // compute op event
-          if (op.struct === 'Insert') {
-            if (op.left === null) {
-              if (op.opContent != null) {
-                delete this.contents[key]
-                if (op.deleted) {
-                  delete this.opContents[key]
-                } else {
-                  this.opContents[key] = op.opContent
-                }
-              } else {
-                delete this.opContents[key]
-                if (op.deleted) {
-                  delete this.contents[key]
-                } else {
-                  this.contents[key] = op.content
-                }
-              }
-              this.map[key] = op.id
-              var insertEvent = {
-                name: key,
-                object: this
-              }
-              if (oldValue === undefined) {
-                insertEvent.type = 'add'
-              } else {
-                insertEvent.type = 'update'
-                insertEvent.oldValue = oldValue
-              }
-              userEvents.push(insertEvent)
-            }
-          } else if (op.struct === 'Delete') {
-            if (Y.utils.compareIds(this.map[key], op.target)) {
-              delete this.opContents[key]
-              delete this.contents[key]
-              var deleteEvent = {
-                name: key,
-                object: this,
-                oldValue: oldValue,
-                type: 'delete'
-              }
-              userEvents.push(deleteEvent)
-            }
-          } else {
-            throw new Error('Unexpected Operation!')
-          }
-        }
-        this.eventHandler.callEventListeners(userEvents)
-      })
-    }
-    get (key) {
-      // return property.
-      // if property does not exist, return null
-      // if property is a type, return a promise
-      if (key == null) {
-        throw new Error('You must specify key!')
-      }
-      if (this.opContents[key] == null) {
-        return this.contents[key]
-      } else {
-        return new Promise((resolve) => {
-          var oid = this.opContents[key]
-          this.os.requestTransaction(function *() {
-            resolve(yield* this.getType(oid))
-          })
-        })
-      }
-    }
-    /*
-      If there is a primitive (not a custom type), then return it.
-      Returns all primitive values, if propertyName is specified!
-      Note: modifying the return value could result in inconsistencies!
-        -- so make sure to copy it first!
-    */
-    getPrimitive (key) {
-      if (key == null) {
-        return Y.utils.copyObject(this.contents)
-      } else {
-        return this.contents[key]
-      }
-    }
-    delete (key) {
-      var right = this.map[key]
-      if (right != null) {
-        var del = {
-          target: right,
-          struct: 'Delete'
-        }
-        var eventHandler = this.eventHandler
-        var modDel = Y.utils.copyObject(del)
-        modDel.key = key
-        eventHandler.awaitAndPrematurelyCall([modDel])
-        this.os.requestTransaction(function *() {
-          yield* this.applyCreatedOperations([del])
-          eventHandler.awaitedDeletes(1)
-        })
-      }
-    }
-    set (key, value) {
-      // set property.
-      // if property is a type, return a promise
-      // if not, apply immediately on this type an call event
-
-      var right = this.map[key] || null
-      var insert = {
-        left: null,
-        right: right,
-        origin: null,
-        parent: this._model,
-        parentSub: key,
-        struct: 'Insert'
-      }
-      return new Promise((resolve) => {
-        if (value instanceof Y.utils.CustomType) {
-          // construct a new type
-          this.os.requestTransaction(function *() {
-            var typeid = yield* value.createType.call(this)
-            var type = yield* this.getType(typeid)
-            insert.opContent = typeid
-            insert.id = this.store.getNextOpId()
-            yield* this.applyCreatedOperations([insert])
-            resolve(type)
-          })
-        } else {
-          insert.content = value
-          insert.id = this.os.getNextOpId()
-          var eventHandler = this.eventHandler
-          eventHandler.awaitAndPrematurelyCall([insert])
-
-          this.os.requestTransaction(function *() {
-            yield* this.applyCreatedOperations([insert])
-            eventHandler.awaitedInserts(1)
-          })
-          resolve(value)
-        }
-      })
-    }
-    observe (f) {
-      this.eventHandler.addEventListener(f)
-    }
-    unobserve (f) {
-      this.eventHandler.removeEventListener(f)
-    }
-    /*
-      Observe a path.
-
-      E.g.
-      ```
-      o.set('textarea', Y.TextBind)
-      o.observePath(['textarea'], function(t){
-        // is called whenever textarea is replaced
-        t.bind(textarea)
-      })
-
-      returns a Promise that contains a function that removes the observer from the path.
-    */
-    observePath (path, f) {
-      var self = this
-      function observeProperty (events) {
-        // call f whenever path changes
-        for (var i = 0; i < events.length; i++) {
-          var event = events[i]
-          if (event.name === propertyName) {
-            // call this also for delete events!
-            var property = self.get(propertyName)
-            if (property instanceof Promise) {
-              property.then(f)
-            } else {
-              f(property)
-            }
-          }
-        }
-      }
-
-      if (path.length < 1) {
-        throw new Error('Path must contain at least one element!')
-      } else if (path.length === 1) {
-        var propertyName = path[0]
-        var property = self.get(propertyName)
-        if (property instanceof Promise) {
-          property.then(f)
-        } else {
-          f(property)
-        }
-        this.observe(observeProperty)
-        return Promise.resolve(function () {
-          self.unobserve(f)
-        })
-      } else {
-        var deleteChildObservers
-        var resetObserverPath = function () {
-          var promise = self.get(path[0])
-          if (!promise instanceof Promise) {
-            // its either not defined or a primitive value
-            promise = self.set(path[0], Y.Map)
-          }
-          return promise.then(function (map) {
-            return map.observePath(path.slice(1), f)
-          }).then(function (_deleteChildObservers) {
-            // update deleteChildObservers
-            deleteChildObservers = _deleteChildObservers
-            return Promise.resolve() // Promise does not return anything
-          })
-        }
-        var observer = function (events) {
-          for (var e in events) {
-            var event = events[e]
-            if (event.name === path[0]) {
-              deleteChildObservers()
-              if (event.type === 'add' || event.type === 'update') {
-                resetObserverPath()
-              }
-              // TODO: what about the delete events?
-            }
-          }
-        }
-        self.observe(observer)
-        return resetObserverPath().then(
-          // this promise contains a function that deletes all the child observers
-          // and how to unobserve the observe from this object
-          Promise.resolve(function () {
-            deleteChildObservers()
-            self.unobserve(observer)
-          })
-        )
-      }
-    }
-    * _changed (transaction, op) {
-      if (op.struct === 'Delete') {
-        op.key = (yield* transaction.getOperation(op.target)).parentSub
-      }
-      this.eventHandler.receivedOp(op)
-    }
-  }
-  Y.Map = new Y.utils.CustomType({
-    class: YMap,
-    createType: function * YMapCreator () {
-      var modelid = this.store.getNextOpId()
-      var model = {
-        map: {},
-        struct: 'Map',
-        type: 'Map',
-        id: modelid
-      }
-      yield* this.applyCreatedOperations([model])
-      return modelid
-    },
-    initType: function * YMapInitializer (os, model) {
-      var contents = {}
-      var opContents = {}
-      var map = model.map
-      for (var name in map) {
-        var op = yield* this.getOperation(map[name])
-        if (op.opContent != null) {
-          opContents[name] = op.opContent
-        } else {
-          contents[name] = op.content
-        }
-      }
-      return new YMap(os, model, contents, opContents)
-    }
-  })
-})()
--- a/src/Types/Map.spec.js
+++ b/src/Types/Map.spec.js
@@ -1,219 +0,0 @@
-/* global createUsers, Y, databases, compareAllUsers, getRandomNumber, applyRandomTransactionsAllRejoinNoGC, applyRandomTransactionsWithGC, async, describeManyTimes */
-/* eslint-env browser,jasmine */
-
-var numberOfYMapTests = 40
-var repeatMapTeasts = 2
-
-for (let database of databases) {
-  describe(`Map Type (DB: ${database})`, function () {
-    var y1, y2, y3, y4, flushAll
-
-    beforeEach(async(function * (done) {
-      yield createUsers(this, 5, database)
-      y1 = this.users[0].root
-      y2 = this.users[1].root
-      y3 = this.users[2].root
-      y4 = this.users[3].root
-      flushAll = this.users[0].connector.flushAll
-      done()
-    }))
-    afterEach(async(function * (done) {
-      yield compareAllUsers(this.users)
-      done()
-    }), 5000)
-
-    describe('Basic tests', function () {
-      it('Basic get&set of Map property (converge via sync)', async(function * (done) {
-        y1.set('stuff', 'stuffy')
-        expect(y1.get('stuff')).toEqual('stuffy')
-        yield flushAll()
-        for (var key in this.users) {
-          var u = this.users[key].root
-          expect(u.get('stuff')).toEqual('stuffy')
-        }
-        done()
-      }))
-      it('Map can set custom types (Map)', async(function * (done) {
-        var map = yield y1.set('Map', Y.Map)
-        map.set('one', 1)
-        map = yield y1.get('Map')
-        expect(map.get('one')).toEqual(1)
-        done()
-      }))
-      it('Map can set custom types (Array)', async(function * (done) {
-        var array = yield y1.set('Array', Y.Array)
-        array.insert(0, [1, 2, 3])
-        array = yield y1.get('Array')
-        expect(array.toArray()).toEqual([1, 2, 3])
-        done()
-      }))
-      it('Basic get&set of Map property (converge via update)', async(function * (done) {
-        yield flushAll()
-        y1.set('stuff', 'stuffy')
-        expect(y1.get('stuff')).toEqual('stuffy')
-
-        yield flushAll()
-        for (var key in this.users) {
-          var r = this.users[key].root
-          expect(r.get('stuff')).toEqual('stuffy')
-        }
-        done()
-      }))
-      it('Basic get&set of Map property (handle conflict)', async(function * (done) {
-        yield flushAll()
-        y1.set('stuff', 'c0')
-        y2.set('stuff', 'c1')
-
-        yield flushAll()
-        for (var key in this.users) {
-          var u = this.users[key]
-          expect(u.root.get('stuff')).toEqual('c0')
-        }
-        done()
-      }))
-      it('Basic get&set&delete of Map property (handle conflict)', async(function * (done) {
-        yield flushAll()
-        y1.set('stuff', 'c0')
-        y1.delete('stuff')
-        y2.set('stuff', 'c1')
-        yield flushAll()
-
-        for (var key in this.users) {
-          var u = this.users[key]
-          expect(u.root.get('stuff')).toBeUndefined()
-        }
-        done()
-      }))
-      it('Basic get&set of Map property (handle three conflicts)', async(function * (done) {
-        yield flushAll()
-        y1.set('stuff', 'c0')
-        y2.set('stuff', 'c1')
-        y2.set('stuff', 'c2')
-        y3.set('stuff', 'c3')
-        yield flushAll()
-
-        for (var key in this.users) {
-          var u = this.users[key]
-          expect(u.root.get('stuff')).toEqual('c0')
-        }
-        done()
-      }))
-      it('Basic get&set&delete of Map property (handle three conflicts)', async(function * (done) {
-        yield flushAll()
-        y1.set('stuff', 'c0')
-        y2.set('stuff', 'c1')
-        y2.set('stuff', 'c2')
-        y3.set('stuff', 'c3')
-        yield flushAll()
-        y1.set('stuff', 'deleteme')
-        y1.delete('stuff')
-        y2.set('stuff', 'c1')
-        y3.set('stuff', 'c2')
-        y4.set('stuff', 'c3')
-        yield flushAll()
-
-        for (var key in this.users) {
-          var u = this.users[key]
-          expect(u.root.get('stuff')).toBeUndefined()
-        }
-        done()
-      }))
-      it('observePath properties', async(function * (done) {
-        y1.observePath(['map'], function (map) {
-          if (map != null) {
-            map.set('yay', 4)
-          }
-        })
-        yield y2.set('map', Y.Map)
-        yield flushAll()
-        var map = yield y3.get('map')
-        expect(map.get('yay')).toEqual(4)
-        done()
-      }))
-      it('throws add & update & delete events (with type and primitive content)', async(function * (done) {
-        var event
-        yield flushAll()
-        y1.observe(function (e) {
-          event = e // just put it on event, should be thrown synchronously anyway
-        })
-        y1.set('stuff', 4)
-        expect(event).toEqual([{
-          type: 'add',
-          object: y1,
-          name: 'stuff'
-        }])
-        // update, oldValue is in contents
-        yield y1.set('stuff', Y.Array)
-        expect(event).toEqual([{
-          type: 'update',
-          object: y1,
-          name: 'stuff',
-          oldValue: 4
-        }])
-        y1.get('stuff').then(function (replacedArray) {
-          // update, oldValue is in opContents
-          y1.set('stuff', 5)
-          var getYArray = event[0].oldValue
-          expect(typeof getYArray.constructor === 'function').toBeTruthy()
-          getYArray().then(function (array) {
-            expect(array).toEqual(replacedArray)
-
-            // delete
-            y1.delete('stuff')
-            expect(event).toEqual([{
-              type: 'delete',
-              name: 'stuff',
-              object: y1,
-              oldValue: 5
-            }])
-            done()
-          })
-        })
-      }))
-    })
-    describeManyTimes(repeatMapTeasts, `${numberOfYMapTests} Random tests`, function () {
-      var randomMapTransactions = [
-        function set (map) {
-          map.set('somekey', getRandomNumber())
-        },
-        function delete_ (map) {
-          map.delete('somekey')
-        }
-      ]
-      function compareMapValues (maps) {
-        var firstMap
-        for (var map of maps) {
-          var val = map.getPrimitive()
-          if (firstMap == null) {
-            firstMap = val
-          } else {
-            expect(val).toEqual(firstMap)
-          }
-        }
-      }
-      beforeEach(async(function * (done) {
-        yield y1.set('Map', Y.Map)
-        yield flushAll()
-
-        var promises = []
-        for (var u = 0; u < this.users.length; u++) {
-          promises.push(this.users[u].root.get('Map'))
-        }
-        this.maps = yield Promise.all(promises)
-        done()
-      }))
-      it(`succeed after ${numberOfYMapTests} actions, no GC, all users disconnecting/reconnecting`, async(function * (done) {
-        yield applyRandomTransactionsAllRejoinNoGC(this.users, this.maps, randomMapTransactions, numberOfYMapTests)
-        yield flushAll()
-        yield compareMapValues(this.maps)
-        done()
-      }))
-      it(`succeed after ${numberOfYMapTests} actions, GC, user[0] is not disconnecting`, async(function * (done) {
-        yield applyRandomTransactionsWithGC(this.users, this.maps, randomMapTransactions, numberOfYMapTests)
-        yield flushAll()
-        yield compareMapValues(this.maps)
-        done()
-      }))
-    })
-  })
-}
--- a/src/Types/TextBind.js
+++ b/src/Types/TextBind.js
@@ -1,290 +0,0 @@
-/* global Y */
-'use strict'
-
-;(function () {
-  class YTextBind extends Y.Array['class'] {
-    constructor (os, _model, idArray, valArray) {
-      super(os, _model, idArray, valArray)
-      this.textfields = []
-    }
-    toString () {
-      return this.valArray.join('')
-    }
-    insert (pos, content) {
-      super.insert(pos, content.split(''))
-    }
-    bind (textfield, domRoot) {
-      domRoot = domRoot || window; // eslint-disable-line
-      if (domRoot.getSelection == null) {
-        domRoot = window;// eslint-disable-line
-      }
-
-      // don't duplicate!
-      for (var t in this.textfields) {
-        if (this.textfields[t] === textfield) {
-          return
-        }
-      }
-      var creatorToken = false
-
-      var word = this
-      textfield.value = this.toString()
-      this.textfields.push(textfield)
-      var createRange, writeRange, writeContent
-      if (textfield.selectionStart != null && textfield.setSelectionRange != null) {
-        createRange = function (fix) {
-          var left = textfield.selectionStart
-          var right = textfield.selectionEnd
-          if (fix != null) {
-            left = fix(left)
-            right = fix(right)
-          }
-          return {
-            left: left,
-            right: right
-          }
-        }
-        writeRange = function (range) {
-          writeContent(word.toString())
-          textfield.setSelectionRange(range.left, range.right)
-        }
-        writeContent = function (content) {
-          textfield.value = content
-        }
-      } else {
-        createRange = function (fix) {
-          var range = {}
-          var s = domRoot.getSelection()
-          var clength = textfield.textContent.length
-          range.left = Math.min(s.anchorOffset, clength)
-          range.right = Math.min(s.focusOffset, clength)
-          if (fix != null) {
-            range.left = fix(range.left)
-            range.right = fix(range.right)
-          }
-          var editedElement = s.focusNode
-          if (editedElement === textfield || editedElement === textfield.childNodes[0]) {
-            range.isReal = true
-          } else {
-            range.isReal = false
-          }
-          return range
-        }
-
-        writeRange = function (range) {
-          writeContent(word.toString())
-          var textnode = textfield.childNodes[0]
-          if (range.isReal && textnode != null) {
-            if (range.left < 0) {
-              range.left = 0
-            }
-            range.right = Math.max(range.left, range.right)
-            if (range.right > textnode.length) {
-              range.right = textnode.length
-            }
-            range.left = Math.min(range.left, range.right)
-            var r = document.createRange(); // eslint-disable-line
-            r.setStart(textnode, range.left)
-            r.setEnd(textnode, range.right)
-            var s = window.getSelection(); // eslint-disable-line
-            s.removeAllRanges()
-            s.addRange(r)
-          }
-        }
-        writeContent = function (content) {
-          var contentArray = content.replace(new RegExp('\n', 'g'), ' ').split(' ');// eslint-disable-line
-          textfield.innerText = ''
-          for (var i in contentArray) {
-            var c = contentArray[i]
-            textfield.innerText += c
-            if (i !== contentArray.length - 1) {
-              textfield.innerHTML += '&nbsp;'
-            }
-          }
-        }
-      }
-      writeContent(this.toString())
-
-      this.observe(function (events) {
-        for (var e in events) {
-          var event = events[e]
-          if (!creatorToken) {
-            var oPos, fix
-            if (event.type === 'insert') {
-              oPos = event.index
-              fix = function (cursor) {// eslint-disable-line
-                if (cursor <= oPos) {
-                  return cursor
-                } else {
-                  cursor += 1
-                  return cursor
-                }
-              }
-              var r = createRange(fix)
-              writeRange(r)
-            } else if (event.type === 'delete') {
-              oPos = event.index
-              fix = function (cursor) {// eslint-disable-line
-                if (cursor < oPos) {
-                  return cursor
-                } else {
-                  cursor -= 1
-                  return cursor
-                }
-              }
-              r = createRange(fix)
-              writeRange(r)
-            }
-          }
-        }
-      })
-      // consume all text-insert changes.
-      textfield.onkeypress = function (event) {
-        if (word.is_deleted) {
-          // if word is deleted, do not do anything ever again
-          textfield.onkeypress = null
-          return true
-        }
-        creatorToken = true
-        var char
-        if (event.keyCode === 13) {
-          char = '\n'
-        } else if (event.key != null) {
-          if (event.charCode === 32) {
-            char = ' '
-          } else {
-            char = event.key
-          }
-        } else {
-          char = window.String.fromCharCode(event.keyCode); // eslint-disable-line
-        }
-        if (char.length > 1) {
-          return true
-        } else if (char.length > 0) {
-          var r = createRange()
-          var pos = Math.min(r.left, r.right, word.length)
-          var diff = Math.abs(r.right - r.left)
-          word.delete(pos, diff)
-          word.insert(pos, char)
-          r.left = pos + char.length
-          r.right = r.left
-          writeRange(r)
-        }
-        event.preventDefault()
-        creatorToken = false
-        return false
-      }
-      textfield.onpaste = function (event) {
-        if (word.is_deleted) {
-          // if word is deleted, do not do anything ever again
-          textfield.onpaste = null
-          return true
-        }
-        event.preventDefault()
-      }
-      textfield.oncut = function (event) {
-        if (word.is_deleted) {
-          // if word is deleted, do not do anything ever again
-          textfield.oncut = null
-          return true
-        }
-        event.preventDefault()
-      }
-      //
-      // consume deletes. Note that
-      //   chrome: won't consume deletions on keypress event.
-      //   keyCode is deprecated. BUT: I don't see another way.
-      //     since event.key is not implemented in the current version of chrome.
-      //     Every browser supports keyCode. Let's stick with it for now..
-      //
-      textfield.onkeydown = function (event) {
-        creatorToken = true
-        if (word.is_deleted) {
-          // if word is deleted, do not do anything ever again
-          textfield.onkeydown = null
-          return true
-        }
-        var r = createRange()
-        var pos = Math.min(r.left, r.right, word.toString().length)
-        var diff = Math.abs(r.left - r.right)
-        if (event.keyCode != null && event.keyCode === 8) { // Backspace
-          if (diff > 0) {
-            word.delete(pos, diff)
-            r.left = pos
-            r.right = pos
-            writeRange(r)
-          } else {
-            if (event.ctrlKey != null && event.ctrlKey) {
-              var val = word.toString()
-              var newPos = pos
-              var delLength = 0
-              if (pos > 0) {
-                newPos--
-                delLength++
-              }
-              while (newPos > 0 && val[newPos] !== ' ' && val[newPos] !== '\n') {
-                newPos--
-                delLength++
-              }
-              word.delete(newPos, pos - newPos)
-              r.left = newPos
-              r.right = newPos
-              writeRange(r)
-            } else {
-              if (pos > 0) {
-                word.delete(pos - 1, 1)
-                r.left = pos - 1
-                r.right = pos - 1
-                writeRange(r)
-              }
-            }
-          }
-          event.preventDefault()
-          creatorToken = false
-          return false
-        } else if (event.keyCode != null && event.keyCode === 46) { // Delete
-          if (diff > 0) {
-            word.delete(pos, diff)
-            r.left = pos
-            r.right = pos
-            writeRange(r)
-          } else {
-            word.delete(pos, 1)
-            r.left = pos
-            r.right = pos
-            writeRange(r)
-          }
-          event.preventDefault()
-          creatorToken = false
-          return false
-        } else {
-          creatorToken = false
-          return true
-        }
-      }
-    }
-  }
-  Y.TextBind = new Y.utils.CustomType({
-    class: YTextBind,
-    createType: function * YTextBindCreator () {
-      var modelid = this.store.getNextOpId()
-      var model = {
-        start: null,
-        end: null,
-        struct: 'List',
-        type: 'TextBind',
-        id: modelid
-      }
-      yield* this.applyCreatedOperations([model])
-      return modelid
-    },
-    initType: function * YTextBindInitializer (os, model) {
-      var valArray = []
-      var idArray = yield* Y.Struct.List.map.call(this, model, function (c) {
-        valArray.push(c.content)
-        return JSON.stringify(c.id)
-      })
-      return new YTextBind(os, model.id, idArray, valArray)
-    }
-  })
-})()
--- a/src/Utils.js
+++ b/src/Utils.js
@@ -1,198 +0,0 @@
-/* global Y */
-'use strict'
-
-/*
-  EventHandler is an helper class for constructing custom types.
-
-  Why: When constructing custom types, you sometimes want your types to work
-  synchronous: E.g.
-  ``` Synchronous
-  mytype.setSomething("yay")
-  mytype.getSomething() === "yay"
-  ```
-  ``` Asynchronous
-  mytype.setSomething("yay")
-  mytype.getSomething() === undefined
-  mytype.waitForSomething().then(function(){
-    mytype.getSomething() === "yay"
-  })
-
-  The structures usually work asynchronously (you have to wait for the
-  database request to finish). EventHandler will help you to make your type
-  synchronously.
-*/
-class EventHandler {
-  /*
-    onevent: is called when the structure changes.
-
-    Note: "awaiting opertations" is used to denote operations that were
-    prematurely called. Events for received operations can not be executed until
-    all prematurely called operations were executed ("waiting operations")
-  */
-  constructor (onevent) {
-    this.waiting = []
-    this.awaiting = 0
-    this.onevent = onevent
-    this.eventListeners = []
-  }
-  /*
-    Call this when a new operation arrives. It will be executed right away if
-    there are no waiting operations, that you prematurely executed
-  */
-  receivedOp (op) {
-    if (this.awaiting <= 0) {
-      this.onevent([op])
-    } else {
-      this.waiting.push(Y.utils.copyObject(op))
-    }
-  }
-  /*
-    You created some operations, and you want the `onevent` function to be
-    called right away. Received operations will not be executed untill all
-    prematurely called operations are executed
-  */
-  awaitAndPrematurelyCall (ops) {
-    this.awaiting++
-    this.onevent(ops)
-  }
-  /*
-    Basic event listener boilerplate...
-    TODO: maybe put this in a different type..
-  */
-  addEventListener (f) {
-    this.eventListeners.push(f)
-  }
-  removeEventListener (f) {
-    this.eventListeners = this.eventListeners.filter(function (g) {
-      return f !== g
-    })
-  }
-  removeAllEventListeners () {
-    this.eventListeners = []
-  }
-  callEventListeners (event) {
-    for (var i in this.eventListeners) {
-      try {
-        this.eventListeners[i](event)
-      } catch (e) {
-        console.log('User events must not throw Errors!') // eslint-disable-line
-      }
-    }
-  }
-  /*
-    Call this when you successfully awaited the execution of n Insert operations
-  */
-  awaitedInserts (n) {
-    var ops = this.waiting.splice(this.waiting.length - n)
-    for (var oid = 0; oid < ops.length; oid++) {
-      var op = ops[oid]
-      for (var i = this.waiting.length - 1; i >= 0; i--) {
-        let w = this.waiting[i]
-        if (Y.utils.compareIds(op.left, w.id)) {
-          // include the effect of op in w
-          w.right = op.id
-          // exclude the effect of w in op
-          op.left = w.left
-        } else if (Y.utils.compareIds(op.right, w.id)) {
-          // similar..
-          w.left = op.id
-          op.right = w.right
-        }
-      }
-    }
-    this._tryCallEvents()
-  }
-  /*
-    Call this when you successfully awaited the execution of n Delete operations
-  */
-  awaitedDeletes (n, newLeft) {
-    var ops = this.waiting.splice(this.waiting.length - n)
-    for (var j in ops) {
-      var del = ops[j]
-      if (newLeft != null) {
-        for (var i in this.waiting) {
-          let w = this.waiting[i]
-          // We will just care about w.left
-          if (Y.utils.compareIds(del.target, w.left)) {
-            del.left = newLeft
-          }
-        }
-      }
-    }
-    this._tryCallEvents()
-  }
-  /* (private)
-    Try to execute the events for the waiting operations
-  */
-  _tryCallEvents () {
-    this.awaiting--
-    if (this.awaiting <= 0 && this.waiting.length > 0) {
-      var events = this.waiting
-      this.waiting = []
-      this.onevent(events)
-    }
-  }
-}
-Y.utils.EventHandler = EventHandler
-
-/*
-  A wrapper for the definition of a custom type.
-  Every custom type must have three properties:
-
-  * createType
-    - Defines the model of a newly created custom type and returns the type
-  * initType
-    - Given a model, creates a custom type
-  * class
-    - the constructor of the custom type (e.g. in order to inherit from a type)
-*/
-class CustomType { // eslint-disable-line
-  constructor (def) {
-    if (def.createType == null ||
-      def.initType == null ||
-      def.class == null
-    ) {
-      throw new Error('Custom type was not initialized correctly!')
-    }
-    this.createType = def.createType
-    this.initType = def.initType
-    this.class = def.class
-  }
-}
-Y.utils.CustomType = CustomType
-
-/*
-  Make a flat copy of an object
-  (just copy properties)
-*/
-function copyObject (o) {
-  var c = {}
-  for (var key in o) {
-    c[key] = o[key]
-  }
-  return c
-}
-Y.utils.copyObject = copyObject
-
-/*
-  Defines a smaller relation on Id's
-*/
-function smaller (a, b) {
-  return a[0] < b[0] || (a[0] === b[0] && a[1] < b[1])
-}
-Y.utils.smaller = smaller
-
-function compareIds (id1, id2) {
-  if (id1 == null || id2 == null) {
-    if (id1 == null && id2 == null) {
-      return true
-    }
-    return false
-  }
-  if (id1[0] === id2[0] && id1[1] === id2[1]) {
-    return true
-  } else {
-    return false
-  }
-}
-Y.utils.compareIds = compareIds
--- a/src/index.js
+++ b/src/index.js
@@ -0,0 +1,46 @@
+
+export {
+  Doc,
+  Transaction,
+  YArray as Array,
+  YMap as Map,
+  YText as Text,
+  YXmlText as XmlText,
+  YXmlHook as XmlHook,
+  YXmlElement as XmlElement,
+  YXmlFragment as XmlFragment,
+  YXmlEvent,
+  YMapEvent,
+  YArrayEvent,
+  YEvent,
+  AbstractItem,
+  AbstractStruct,
+  GC,
+  ItemBinary,
+  ItemDeleted,
+  ItemEmbed,
+  ItemFormat,
+  ItemJSON,
+  ItemString,
+  ItemType,
+  AbstractType,
+  RelativePosition,
+  createRelativePositionFromTypeIndex,
+  createRelativePositionFromJSON,
+  createAbsolutePositionFromRelativePosition,
+  compareRelativePositions,
+  writeRelativePosition,
+  readRelativePosition,
+  ID,
+  createID,
+  compareIDs,
+  getState,
+  Snapshot,
+  findRootTypeKey,
+  typeListToArraySnapshot,
+  typeMapGetSnapshot,
+  iterateDeletedStructs,
+  applyUpdate,
+  encodeStateAsUpdate,
+  encodeStateVector
+} from './internals.js'
--- a/src/internals.js
+++ b/src/internals.js
@@ -0,0 +1,34 @@
+export * from './utils/DeleteSet.js'
+export * from './utils/EventHandler.js'
+export * from './utils/ID.js'
+export * from './utils/isParentOf.js'
+export * from './utils/RelativePosition.js'
+export * from './utils/Snapshot.js'
+export * from './utils/StructStore.js'
+export * from './utils/Transaction.js'
+// export * from './utils/UndoManager.js'
+export * from './utils/Doc.js'
+export * from './utils/YEvent.js'
+
+export * from './types/AbstractType.js'
+export * from './types/YArray.js'
+export * from './types/YMap.js'
+export * from './types/YText.js'
+export * from './types/YXmlFragment.js'
+export * from './types/YXmlElement.js'
+export * from './types/YXmlEvent.js'
+export * from './types/YXmlHook.js'
+export * from './types/YXmlText.js'
+
+export * from './structs/AbstractStruct.js'
+export * from './structs/AbstractItem.js'
+export * from './structs/GC.js'
+export * from './structs/ItemBinary.js'
+export * from './structs/ItemDeleted.js'
+export * from './structs/ItemEmbed.js'
+export * from './structs/ItemFormat.js'
+export * from './structs/ItemJSON.js'
+export * from './structs/ItemString.js'
+export * from './structs/ItemType.js'
+
+export * from './utils/encoding.js'
--- a/src/structs/AbstractItem.js
+++ b/src/structs/AbstractItem.js
@@ -0,0 +1,642 @@
+
+import {
+  readID,
+  createID,
+  writeID,
+  GC,
+  nextID,
+  AbstractStructRef,
+  AbstractStruct,
+  replaceStruct,
+  addStruct,
+  addToDeleteSet,
+  ItemDeleted,
+  findRootTypeKey,
+  compareIDs,
+  getItem,
+  getItemType,
+  getItemCleanEnd,
+  getItemCleanStart,
+  YEvent, StructStore, ID, AbstractType, Transaction // eslint-disable-line
+} from '../internals.js'
+
+import * as error from 'lib0/error.js'
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+import * as maplib from 'lib0/map.js'
+import * as set from 'lib0/set.js'
+import * as binary from 'lib0/binary.js'
+
+/**
+ * @param {AbstractItem} left
+ * @param {AbstractItem} right
+ * @return {boolean} If true, right is removed from the linked list and should be discarded
+ */
+export const mergeItemWith = (left, right) => {
+  if (compareIDs(right.origin, left.lastId) && left.right === right && compareIDs(left.rightOrigin, right.rightOrigin)) {
+    left.right = right.right
+    if (left.right !== null) {
+      left.right.left = left
+    }
+    return true
+  }
+  return false
+}
+
+/**
+ * Split leftItem into two items
+ * @param {Transaction} transaction
+ * @param {AbstractItem} leftItem
+ * @param {number} diff
+ * @return {AbstractItem}
+ *
+ * @function
+ * @private
+ */
+export const splitItem = (transaction, leftItem, diff) => {
+  const id = leftItem.id
+  // create rightItem
+  const rightItem = leftItem.copy(
+    createID(id.client, id.clock + diff),
+    leftItem,
+    createID(id.client, id.clock + diff - 1),
+    leftItem.right,
+    leftItem.rightOrigin,
+    leftItem.parent,
+    leftItem.parentSub
+  )
+  if (leftItem.deleted) {
+    rightItem.deleted = true
+  }
+  // update left (do not set leftItem.rightOrigin as it will lead to problems when syncing)
+  leftItem.right = rightItem
+  // update right
+  if (rightItem.right !== null) {
+    rightItem.right.left = rightItem
+  }
+  // right is more specific.
+  transaction._mergeStructs.add(rightItem.id)
+  // update parent._map
+  if (rightItem.parentSub !== null && rightItem.right === null) {
+    rightItem.parent._map.set(rightItem.parentSub, rightItem)
+  }
+  return rightItem
+}
+
+/**
+ * Abstract class that represents any content.
+ */
+export class AbstractItem extends AbstractStruct {
+  /**
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   */
+  constructor (id, left, origin, right, rightOrigin, parent, parentSub) {
+    super(id)
+    /**
+     * The item that was originally to the left of this item.
+     * @type {ID | null}
+     * @readonly
+     */
+    this.origin = origin
+    /**
+     * The item that is currently to the left of this item.
+     * @type {AbstractItem | null}
+     */
+    this.left = left
+    /**
+     * The item that is currently to the right of this item.
+     * @type {AbstractItem | null}
+     */
+    this.right = right
+    /**
+     * The item that was originally to the right of this item.
+     * @readonly
+     * @type {ID | null}
+     */
+    this.rightOrigin = rightOrigin
+    /**
+     * The parent type.
+     * @type {AbstractType<any>}
+     * @readonly
+     */
+    this.parent = parent
+    /**
+     * If the parent refers to this item with some kind of key (e.g. YMap, the
+     * key is specified here. The key is then used to refer to the list in which
+     * to insert this item. If `parentSub = null` type._start is the list in
+     * which to insert to. Otherwise it is `parent._map`.
+     * @type {String | null}
+     * @readonly
+     */
+    this.parentSub = parentSub
+    /**
+     * Whether this item was deleted or not.
+     * @type {Boolean}
+     */
+    this.deleted = false
+    /**
+     * If this type's effect is reundone this type refers to the type that undid
+     * this operation.
+     * @type {AbstractItem | null}
+     */
+    this.redone = null
+  }
+
+  /**
+   * @param {Transaction} transaction
+   * @private
+   */
+  integrate (transaction) {
+    const store = transaction.doc.store
+    const id = this.id
+    const parent = this.parent
+    const parentSub = this.parentSub
+    const length = this.length
+    /**
+     * @type {AbstractItem|null}
+     */
+    let o
+    // set o to the first conflicting item
+    if (this.left !== null) {
+      o = this.left.right
+    } else if (parentSub !== null) {
+      o = parent._map.get(parentSub) || null
+      while (o !== null && o.left !== null) {
+        o = o.left
+      }
+    } else {
+      o = parent._start
+    }
+    // TODO: use something like DeleteSet here (a tree implementation would be best)
+    /**
+     * @type {Set<AbstractItem>}
+     */
+    const conflictingItems = new Set()
+    /**
+     * @type {Set<AbstractItem>}
+     */
+    const itemsBeforeOrigin = new Set()
+    // Let c in conflictingItems, b in itemsBeforeOrigin
+    // ***{origin}bbbb{this}{c,b}{c,b}{o}***
+    // Note that conflictingItems is a subset of itemsBeforeOrigin
+    while (o !== null && o !== this.right) {
+      itemsBeforeOrigin.add(o)
+      conflictingItems.add(o)
+      if (compareIDs(this.origin, o.origin)) {
+        // case 1
+        if (o.id.client < id.client) {
+          this.left = o
+          conflictingItems.clear()
+        }
+      } else if (o.origin !== null && itemsBeforeOrigin.has(getItem(store, o.origin))) {
+        // case 2
+        if (o.origin === null || !conflictingItems.has(getItem(store, o.origin))) {
+          this.left = o
+          conflictingItems.clear()
+        }
+      } else {
+        break
+      }
+      o = o.right
+    }
+    // reconnect left/right + update parent map/start if necessary
+    if (this.left !== null) {
+      const right = this.left.right
+      this.right = right
+      this.left.right = this
+    } else {
+      let r
+      if (parentSub !== null) {
+        r = parent._map.get(parentSub) || null
+        while (r !== null && r.left !== null) {
+          r = r.left
+        }
+      } else {
+        r = parent._start
+        parent._start = this
+      }
+      this.right = r
+    }
+    if (this.right !== null) {
+      this.right.left = this
+    } else if (parentSub !== null) {
+      // set as current parent value if right === null and this is parentSub
+      parent._map.set(parentSub, this)
+      if (this.left !== null) {
+        // this is the current attribute value of parent. delete right
+        this.left.delete(transaction)
+      }
+    }
+    // adjust length of parent
+    if (parentSub === null && this.countable && !this.deleted) {
+      parent._length += length
+    }
+    addStruct(store, this)
+    maplib.setIfUndefined(transaction.changed, parent, set.create).add(parentSub)
+    // @ts-ignore
+    if ((parent._item !== null && parent._item.deleted) || (this.right !== null && parentSub !== null)) {
+      // delete if parent is deleted or if this is not the current attribute value of parent
+      this.delete(transaction)
+    }
+  }
+
+  /**
+   * Returns the next non-deleted item
+   * @private
+   */
+  get next () {
+    let n = this.right
+    while (n !== null && n.deleted) {
+      n = n.right
+    }
+    return n
+  }
+
+  /**
+   * Returns the previous non-deleted item
+   * @private
+   */
+  get prev () {
+    let n = this.left
+    while (n !== null && n.deleted) {
+      n = n.left
+    }
+    return n
+  }
+
+  /**
+   * Creates an Item with the same effect as this Item (without position effect)
+   *
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   * @return {AbstractItem}
+   *
+   * @private
+   */
+  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
+    throw error.methodUnimplemented()
+  }
+
+  /**
+   * Redoes the effect of this operation.
+   *
+   * @param {Transaction} transaction The Yjs instance.
+   * @param {Set<AbstractItem>} redoitems
+   *
+   * @private
+   */
+  redo (transaction, redoitems) {
+    if (this.redone !== null) {
+      return this.redone
+    }
+    /**
+     * @type {any}
+     */
+    let parent = this.parent
+    if (parent === null) {
+      return
+    }
+    let left, right
+    if (this.parentSub === null) {
+      // Is an array item. Insert at the old position
+      left = this.left
+      right = this
+    } else {
+      // Is a map item. Insert as current value
+      left = parent.type._map.get(this.parentSub)
+      right = null
+    }
+    // make sure that parent is redone
+    if (parent._deleted === true && parent.redone === null) {
+      // try to undo parent if it will be undone anyway
+      if (!redoitems.has(parent) || !parent.redo(transaction, redoitems)) {
+        return false
+      }
+    }
+    if (parent.redone !== null) {
+      while (parent.redone !== null) {
+        parent = parent.redone
+      }
+      // find next cloned_redo items
+      while (left !== null) {
+        if (left.redone !== null && left.redone.parent === parent) {
+          left = left.redone
+          break
+        }
+        left = left.left
+      }
+      while (right !== null) {
+        if (right.redone !== null && right.redone.parent === parent) {
+          right = right.redone
+        }
+        right = right.right
+      }
+    }
+    this.redone = this.copy(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, this.parentSub)
+    this.redone.integrate(transaction)
+    return true
+  }
+
+  /**
+   * Computes the last content address of this Item.
+   */
+  get lastId () {
+    return createID(this.id.client, this.id.clock + this.length - 1)
+  }
+
+  /**
+   * Computes the length of this Item.
+   */
+  get length () {
+    return 1
+  }
+
+  /**
+   * Should return false if this Item is some kind of meta information
+   * (e.g. format information).
+   *
+   * * Whether this Item should be addressable via `yarray.get(i)`
+   * * Whether this Item should be counted when computing yarray.length
+   */
+  get countable () {
+    return true
+  }
+
+  /**
+   * Do not call directly. Always split via StructStore!
+   *
+   * Splits this Item so that another Item can be inserted in-between.
+   * This must be overwritten if _length > 1
+   * Returns right part after split
+   *
+   * (see {@link ItemJSON}/{@link ItemString} for implementation)
+   *
+   * Does not integrate the struct, nor store it in struct store.
+   *
+   * This method should only be cally by StructStore.
+   *
+   * @param {Transaction} transaction
+   * @param {number} diff
+   * @return {AbstractItem}
+   *
+   * @private
+   */
+  splitAt (transaction, diff) {
+    throw error.methodUnimplemented()
+  }
+
+  /**
+   * Mark this Item as deleted.
+   *
+   * @param {Transaction} transaction
+   */
+  delete (transaction) {
+    if (!this.deleted) {
+      const parent = this.parent
+      // adjust the length of parent
+      if (this.countable && this.parentSub === null) {
+        parent._length -= this.length
+      }
+      this.deleted = true
+      addToDeleteSet(transaction.deleteSet, this.id, this.length)
+      maplib.setIfUndefined(transaction.changed, parent, set.create).add(this.parentSub)
+    }
+  }
+
+  /**
+   * @param {StructStore} store
+   *
+   * @private
+   */
+  gcChildren (store) { }
+
+  /**
+   * @param {StructStore} store
+   * @param {boolean} parentGCd
+   *
+   * @private
+   */
+  gc (store, parentGCd) {
+    if (!this.deleted) {
+      throw error.unexpectedCase()
+    }
+    let r
+    if (parentGCd) {
+      r = new GC(this.id, this.length)
+    } else {
+      r = new ItemDeleted(this.id, this.left, this.origin, this.right, this.rightOrigin, this.parent, this.parentSub, this.length)
+      if (r.right !== null) {
+        r.right.left = r
+      } else if (r.parentSub !== null) {
+        r.parent._map.set(r.parentSub, r)
+      }
+      if (r.left !== null) {
+        r.left.right = r
+      } else if (r.parentSub === null) {
+        r.parent._start = r
+      }
+    }
+    replaceStruct(store, this, r)
+  }
+
+  /**
+   * @return {Array<any>}
+   */
+  getContent () {
+    throw error.methodUnimplemented()
+  }
+
+  /**
+   * Transform the properties of this type to binary and write it to an
+   * BinaryEncoder.
+   *
+   * This is called when this Item is sent to a remote peer.
+   *
+   * @param {encoding.Encoder} encoder The encoder to write data to.
+   * @param {number} offset
+   * @param {number} encodingRef
+   *
+   * @private
+   */
+  write (encoder, offset, encodingRef) {
+    const origin = offset > 0 ? createID(this.id.client, this.id.clock + offset - 1) : this.origin
+    const rightOrigin = this.rightOrigin
+    const parentSub = this.parentSub
+    const info = (encodingRef & binary.BITS5) |
+      (origin === null ? 0 : binary.BIT8) | // origin is defined
+      (rightOrigin === null ? 0 : binary.BIT7) | // right origin is defined
+      (parentSub === null ? 0 : binary.BIT6) // parentSub is non-null
+    encoding.writeUint8(encoder, info)
+    if (origin !== null) {
+      writeID(encoder, origin)
+    }
+    if (rightOrigin !== null) {
+      writeID(encoder, rightOrigin)
+    }
+    if (origin === null && rightOrigin === null) {
+      const parent = this.parent
+      if (parent._item === null) {
+        // parent type on y._map
+        // find the correct key
+        // @ts-ignore we know that y exists
+        const ykey = findRootTypeKey(parent)
+        encoding.writeVarUint(encoder, 1) // write parentYKey
+        encoding.writeVarString(encoder, ykey)
+      } else {
+        encoding.writeVarUint(encoder, 0) // write parent id
+        // @ts-ignore _item is defined because parent is integrated
+        writeID(encoder, parent._item.id)
+      }
+      if (parentSub !== null) {
+        encoding.writeVarString(encoder, parentSub)
+      }
+    }
+  }
+}
+
+/**
+ * @private
+ */
+export class AbstractItemRef extends AbstractStructRef {
+  /**
+   * @param {decoding.Decoder} decoder
+   * @param {ID} id
+   * @param {number} info
+   */
+  constructor (decoder, id, info) {
+    super(id)
+    /**
+     * The item that was originally to the left of this item.
+     * @type {ID | null}
+     */
+    this.left = (info & binary.BIT8) === binary.BIT8 ? readID(decoder) : null
+    /**
+     * The item that was originally to the right of this item.
+     * @type {ID | null}
+     */
+    this.right = (info & binary.BIT7) === binary.BIT7 ? readID(decoder) : null
+    const canCopyParentInfo = (info & (binary.BIT7 | binary.BIT8)) === 0
+    const hasParentYKey = canCopyParentInfo ? decoding.readVarUint(decoder) === 1 : false
+    /**
+     * If parent = null and neither left nor right are defined, then we know that `parent` is child of `y`
+     * and we read the next string as parentYKey.
+     * It indicates how we store/retrieve parent from `y.share`
+     * @type {string|null}
+     */
+    this.parentYKey = canCopyParentInfo && hasParentYKey ? decoding.readVarString(decoder) : null
+    /**
+     * The parent type.
+     * @type {ID | null}
+     */
+    this.parent = canCopyParentInfo && !hasParentYKey ? readID(decoder) : null
+    /**
+     * If the parent refers to this item with some kind of key (e.g. YMap, the
+     * key is specified here. The key is then used to refer to the list in which
+     * to insert this item. If `parentSub = null` type._start is the list in
+     * which to insert to. Otherwise it is `parent._map`.
+     * @type {String | null}
+     */
+    this.parentSub = canCopyParentInfo && (info & binary.BIT6) === binary.BIT6 ? decoding.readVarString(decoder) : null
+    const missing = this._missing
+    if (this.left !== null) {
+      missing.push(this.left)
+    }
+    if (this.right !== null) {
+      missing.push(this.right)
+    }
+    if (this.parent !== null) {
+      missing.push(this.parent)
+    }
+  }
+}
+
+/**
+ * @param {AbstractItemRef} item
+ * @param {number} offset
+ *
+ * @function
+ * @private
+ */
+export const changeItemRefOffset = (item, offset) => {
+  item.id = createID(item.id.client, item.id.clock + offset)
+  item.left = createID(item.id.client, item.id.clock - 1)
+}
+
+export class ItemParams {
+  /**
+   * @param {AbstractItem?} left
+   * @param {AbstractItem?} right
+   * @param {AbstractType<YEvent>?} parent
+   * @param {string|null} parentSub
+   */
+  constructor (left, right, parent, parentSub) {
+    this.left = left
+    this.right = right
+    this.parent = parent
+    this.parentSub = parentSub
+  }
+}
+
+/**
+ * Outsourcing some of the logic of computing the item params from a received struct.
+ * If parent === null, it is expected to gc the read struct. Otherwise apply it.
+ *
+ * @param {Transaction} transaction
+ * @param {StructStore} store
+ * @param {ID|null} leftid
+ * @param {ID|null} rightid
+ * @param {ID|null} parentid
+ * @param {string|null} parentSub
+ * @param {string|null} parentYKey
+ * @return {ItemParams}
+ *
+ * @private
+ * @function
+ */
+export const computeItemParams = (transaction, store, leftid, rightid, parentid, parentSub, parentYKey) => {
+  const left = leftid === null ? null : getItemCleanEnd(transaction, store, leftid)
+  const right = rightid === null ? null : getItemCleanStart(transaction, store, rightid)
+  let parent = null
+  if (parentid !== null) {
+    const parentItem = getItemType(store, parentid)
+    switch (parentItem.constructor) {
+      case ItemDeleted:
+      case GC:
+        break
+      default:
+        // Edge case: toStruct is called with an offset > 0. In this case left is defined.
+        // Depending in which order structs arrive, left may be GC'd and the parent not
+        // deleted. This is why we check if left is GC'd. Strictly we probably don't have
+        // to check if right is GC'd, but we will in case we run into future issues
+        if (!parentItem.deleted && (left === null || left.constructor !== GC) && (right === null || right.constructor !== GC)) {
+          parent = parentItem.type
+        }
+    }
+  } else if (parentYKey !== null) {
+    parent = transaction.doc.get(parentYKey)
+  } else if (left !== null) {
+    if (left.constructor !== GC) {
+      parent = left.parent
+      parentSub = left.parentSub
+    }
+  } else if (right !== null) {
+    if (right.constructor !== GC) {
+      parent = right.parent
+      parentSub = right.parentSub
+    }
+  } else {
+    throw error.unexpectedCase()
+  }
+  return new ItemParams(left, right, parent, parentSub)
+}
--- a/src/structs/AbstractStruct.js
+++ b/src/structs/AbstractStruct.js
@@ -0,0 +1,98 @@
+
+import {
+  StructStore, ID, Transaction // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js' // eslint-disable-line
+import * as error from 'lib0/error.js'
+
+/**
+ * @private
+ */
+export class AbstractStruct {
+  /**
+   * @param {ID} id
+   */
+  constructor (id) {
+    /**
+     * The uniqe identifier of this struct.
+     * @type {ID}
+     * @readonly
+     */
+    this.id = id
+    this.deleted = false
+  }
+  /**
+   * Merge this struct with the item to the right.
+   * This method is already assuming that `this.id.clock + this.length === this.id.clock`.
+   * Also this method does *not* remove right from StructStore!
+   * @param {AbstractStruct} right
+   * @return {boolean} wether this merged with right
+   */
+  mergeWith (right) {
+    return false
+  }
+  /**
+   * @type {number}
+   */
+  get length () {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @param {encoding.Encoder} encoder The encoder to write data to.
+   * @param {number} offset
+   * @param {number} encodingRef
+   * @private
+   */
+  write (encoder, offset, encodingRef) {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @param {Transaction} transaction
+   */
+  integrate (transaction) {
+    throw error.methodUnimplemented()
+  }
+}
+
+/**
+ * @private
+ */
+export class AbstractStructRef {
+  /**
+   * @param {ID} id
+   */
+  constructor (id) {
+    /**
+     * @type {Array<ID>}
+     */
+    this._missing = []
+    /**
+     * The uniqe identifier of this type.
+     * @type {ID}
+     */
+    this.id = id
+  }
+  /**
+   * @param {Transaction} transaction
+   * @return {Array<ID|null>}
+   */
+  getMissing (transaction) {
+    return this._missing
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {StructStore} store
+   * @param {number} offset
+   * @return {AbstractStruct}
+   */
+  toStruct (transaction, store, offset) {
+    throw error.methodUnimplemented()
+  }
+  /**
+   * @type {number}
+   */
+  get length () {
+    return 1
+  }
+}
--- a/src/structs/GC.js
+++ b/src/structs/GC.js
@@ -0,0 +1,105 @@
+
+import {
+  AbstractStructRef,
+  AbstractStruct,
+  createID,
+  addStruct,
+  StructStore, Transaction, ID // eslint-disable-line
+} from '../internals.js'
+
+import * as decoding from 'lib0/decoding.js'
+import * as encoding from 'lib0/encoding.js'
+
+export const structGCRefNumber = 0
+
+/**
+ * @private
+ */
+export class GC extends AbstractStruct {
+  /**
+   * @param {ID} id
+   * @param {number} length
+   */
+  constructor (id, length) {
+    super(id)
+    /**
+     * @type {number}
+     */
+    this._len = length
+    this.deleted = true
+  }
+
+  get length () {
+    return this._len
+  }
+
+  delete () {}
+
+  /**
+   * @param {AbstractStruct} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    this._len += right.length
+    return true
+  }
+
+  /**
+   * @param {Transaction} transaction
+   */
+  integrate (transaction) {
+    addStruct(transaction.doc.store, this)
+  }
+
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    encoding.writeUint8(encoder, structGCRefNumber)
+    encoding.writeVarUint(encoder, this._len - offset)
+  }
+}
+
+/**
+ * @private
+ */
+export class GCRef extends AbstractStructRef {
+  /**
+   * @param {decoding.Decoder} decoder
+   * @param {ID} id
+   * @param {number} info
+   */
+  constructor (decoder, id, info) {
+    super(id)
+    /**
+     * @type {number}
+     */
+    this._len = decoding.readVarUint(decoder)
+  }
+  get length () {
+    return this._len
+  }
+  missing () {
+    return [
+      createID(this.id.client, this.id.clock - 1)
+    ]
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {StructStore} store
+   * @param {number} offset
+   * @return {GC}
+   */
+  toStruct (transaction, store, offset) {
+    if (offset > 0) {
+      // @ts-ignore
+      this.id = createID(this.id.client, this.id.clock + offset)
+      this._len = this._len - offset
+    }
+    return new GC(
+      this.id,
+      this._len
+    )
+  }
+}
--- a/src/structs/ItemBinary.js
+++ b/src/structs/ItemBinary.js
@@ -0,0 +1,99 @@
+
+import {
+  AbstractItem,
+  AbstractItemRef,
+  computeItemParams,
+  GC,
+  StructStore, Transaction, AbstractType, ID // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+import * as buffer from 'lib0/buffer.js'
+
+/**
+ * @private
+ */
+export const structBinaryRefNumber = 1
+
+/**
+ * @private
+ */
+export class ItemBinary extends AbstractItem {
+  /**
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   * @param {Uint8Array} content
+   */
+  constructor (id, left, origin, right, rightOrigin, parent, parentSub, content) {
+    super(id, left, origin, right, rightOrigin, parent, parentSub)
+    this.content = content
+  }
+  getContent () {
+    return [this.content]
+  }
+  /**
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   */
+  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
+    return new ItemBinary(id, left, origin, right, rightOrigin, parent, parentSub, this.content)
+  }
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    super.write(encoder, offset, structBinaryRefNumber)
+    encoding.writeVarUint8Array(encoder, this.content)
+  }
+}
+
+/**
+ * @private
+ */
+export class ItemBinaryRef extends AbstractItemRef {
+  /**
+   * @param {decoding.Decoder} decoder
+   * @param {ID} id
+   * @param {number} info
+   */
+  constructor (decoder, id, info) {
+    super(decoder, id, info)
+    /**
+     * @type {Uint8Array}
+     */
+    this.content = buffer.copyUint8Array(decoding.readVarUint8Array(decoder))
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {StructStore} store
+   * @param {number} offset
+   * @return {ItemBinary|GC}
+   */
+  toStruct (transaction, store, offset) {
+    const { left, right, parent, parentSub } = computeItemParams(transaction, store, this.left, this.right, this.parent, this.parentSub, this.parentYKey)
+    return parent === null
+      ? new GC(this.id, this.length)
+      : new ItemBinary(
+        this.id,
+        left,
+        this.left,
+        right,
+        this.right,
+        parent,
+        parentSub,
+        this.content
+      )
+  }
+}
--- a/src/structs/ItemDeleted.js
+++ b/src/structs/ItemDeleted.js
@@ -0,0 +1,155 @@
+
+import {
+  AbstractItem,
+  AbstractItemRef,
+  computeItemParams,
+  changeItemRefOffset,
+  GC,
+  splitItem,
+  addToDeleteSet,
+  mergeItemWith,
+  StructStore, Transaction, ID, AbstractType // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+
+/**
+ * @private
+ */
+export const structDeletedRefNumber = 2
+
+/**
+ * @private
+ */
+export class ItemDeleted extends AbstractItem {
+  /**
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   * @param {number} length
+   */
+  constructor (id, left, origin, right, rightOrigin, parent, parentSub, length) {
+    super(id, left, origin, right, rightOrigin, parent, parentSub)
+    this._len = length
+    this.deleted = true
+  }
+  get length () {
+    return this._len
+  }
+  /**
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   */
+  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
+    return new ItemDeleted(id, left, origin, right, rightOrigin, parent, parentSub, this.length)
+  }
+  /**
+   * @param {Transaction} transaction
+   */
+  integrate (transaction) {
+    super.integrate(transaction)
+    addToDeleteSet(transaction.deleteSet, this.id, this.length)
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {number} diff
+   */
+  splitAt (transaction, diff) {
+    /**
+     * @type {ItemDeleted}
+     */
+    // @ts-ignore
+    const right = splitItem(transaction, this, diff)
+    right._len -= diff
+    this._len = diff
+    return right
+  }
+  /**
+   * @param {ItemDeleted} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    if (mergeItemWith(this, right)) {
+      this._len += right._len
+      return true
+    }
+    return false
+  }
+
+  /**
+   * @param {StructStore} store
+   * @param {boolean} parentGCd
+   *
+   * @private
+   */
+  gc (store, parentGCd) {
+    if (parentGCd) {
+      super.gc(store, parentGCd)
+    }
+  }
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    super.write(encoder, offset, structDeletedRefNumber)
+    encoding.writeVarUint(encoder, this.length - offset)
+  }
+}
+
+/**
+ * @private
+ */
+export class ItemDeletedRef extends AbstractItemRef {
+  /**
+   * @param {decoding.Decoder} decoder
+   * @param {ID} id
+   * @param {number} info
+   */
+  constructor (decoder, id, info) {
+    super(decoder, id, info)
+    /**
+     * @type {number}
+     */
+    this.len = decoding.readVarUint(decoder)
+  }
+  get length () {
+    return this.len
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {StructStore} store
+   * @param {number} offset
+   * @return {ItemDeleted|GC}
+   */
+  toStruct (transaction, store, offset) {
+    if (offset > 0) {
+      changeItemRefOffset(this, offset)
+      this.len = this.len - offset
+    }
+
+    const { left, right, parent, parentSub } = computeItemParams(transaction, store, this.left, this.right, this.parent, this.parentSub, this.parentYKey)
+    return parent === null
+      ? new GC(this.id, this.length)
+      : new ItemDeleted(
+        this.id,
+        left,
+        this.left,
+        right,
+        this.right,
+        parent,
+        parentSub,
+        this.len
+      )
+  }
+}
--- a/src/structs/ItemEmbed.js
+++ b/src/structs/ItemEmbed.js
@@ -0,0 +1,95 @@
+
+import {
+  AbstractItem,
+  AbstractItemRef,
+  computeItemParams,
+  GC,
+  Transaction, StructStore, ID, AbstractType // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+
+/**
+ * @private
+ */
+export const structEmbedRefNumber = 3
+
+/**
+ * @private
+ */
+export class ItemEmbed extends AbstractItem {
+  /**
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   * @param {Object} embed
+   */
+  constructor (id, left, origin, right, rightOrigin, parent, parentSub, embed) {
+    super(id, left, origin, right, rightOrigin, parent, parentSub)
+    this.embed = embed
+  }
+  /**
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   */
+  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
+    return new ItemEmbed(id, left, origin, right, rightOrigin, parent, parentSub, this.embed)
+  }
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    super.write(encoder, offset, structEmbedRefNumber)
+    encoding.writeVarString(encoder, JSON.stringify(this.embed))
+  }
+}
+
+/**
+ * @private
+ */
+export class ItemEmbedRef extends AbstractItemRef {
+  /**
+   * @param {decoding.Decoder} decoder
+   * @param {ID} id
+   * @param {number} info
+   */
+  constructor (decoder, id, info) {
+    super(decoder, id, info)
+    /**
+     * @type {Object}
+     */
+    this.embed = JSON.parse(decoding.readVarString(decoder))
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {StructStore} store
+   * @param {number} offset
+   * @return {ItemEmbed|GC}
+   */
+  toStruct (transaction, store, offset) {
+    const { left, right, parent, parentSub } = computeItemParams(transaction, store, this.left, this.right, this.parent, this.parentSub, this.parentYKey)
+    return parent === null
+      ? new GC(this.id, this.length)
+      : new ItemEmbed(
+        this.id,
+        left,
+        this.left,
+        right,
+        this.right,
+        parent,
+        parentSub,
+        this.embed
+      )
+  }
+}
--- a/src/structs/ItemFormat.js
+++ b/src/structs/ItemFormat.js
@@ -0,0 +1,103 @@
+
+import {
+  AbstractItem,
+  AbstractItemRef,
+  computeItemParams,
+  GC,
+  Transaction, StructStore, ID, AbstractType // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+
+/**
+ * @private
+ */
+export const structFormatRefNumber = 4
+
+/**
+ * @private
+ */
+export class ItemFormat extends AbstractItem {
+  /**
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   * @param {string} key
+   * @param {any} value
+   */
+  constructor (id, left, origin, right, rightOrigin, parent, parentSub, key, value) {
+    super(id, left, origin, right, rightOrigin, parent, parentSub)
+    this.key = key
+    this.value = value
+  }
+  /**
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   */
+  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
+    return new ItemFormat(id, left, origin, right, rightOrigin, parent, parentSub, this.key, this.value)
+  }
+  get countable () {
+    return false
+  }
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    super.write(encoder, offset, structFormatRefNumber)
+    encoding.writeVarString(encoder, this.key)
+    encoding.writeVarString(encoder, JSON.stringify(this.value))
+  }
+}
+
+/**
+ * @private
+ */
+export class ItemFormatRef extends AbstractItemRef {
+  /**
+   * @param {decoding.Decoder} decoder
+   * @param {ID} id
+   * @param {number} info
+   */
+  constructor (decoder, id, info) {
+    super(decoder, id, info)
+    /**
+     * @type {string}
+     */
+    this.key = decoding.readVarString(decoder)
+    this.value = JSON.parse(decoding.readVarString(decoder))
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {StructStore} store
+   * @param {number} offset
+   * @return {ItemFormat|GC}
+   */
+  toStruct (transaction, store, offset) {
+    const { left, right, parent, parentSub } = computeItemParams(transaction, store, this.left, this.right, this.parent, this.parentSub, this.parentYKey)
+    return parent === null
+      ? new GC(this.id, this.length)
+      : new ItemFormat(
+        this.id,
+        left,
+        this.left,
+        right,
+        this.right,
+        parent,
+        parentSub,
+        this.key,
+        this.value
+      )
+  }
+}
--- a/src/structs/ItemJSON.js
+++ b/src/structs/ItemJSON.js
@@ -0,0 +1,153 @@
+
+import {
+  AbstractItem,
+  AbstractItemRef,
+  computeItemParams,
+  splitItem,
+  changeItemRefOffset,
+  GC,
+  mergeItemWith,
+  Transaction, StructStore, ID, AbstractType // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+
+/**
+ * @private
+ */
+export const structJSONRefNumber = 5
+
+/**
+ * @private
+ */
+export class ItemJSON extends AbstractItem {
+  /**
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   * @param {Array<any>} content
+   */
+  constructor (id, left, origin, right, rightOrigin, parent, parentSub, content) {
+    super(id, left, origin, right, rightOrigin, parent, parentSub)
+    /**
+     * @type {Array<any>}
+     */
+    this.content = content
+  }
+  /**
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   */
+  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
+    return new ItemJSON(id, left, origin, right, rightOrigin, parent, parentSub, this.content)
+  }
+  get length () {
+    return this.content.length
+  }
+  getContent () {
+    return this.content
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {number} diff
+   */
+  splitAt (transaction, diff) {
+    /**
+     * @type {ItemJSON}
+     */
+    // @ts-ignore
+    const right = splitItem(transaction, this, diff)
+    right.content = this.content.splice(diff)
+    return right
+  }
+  /**
+   * @param {ItemJSON} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    if (mergeItemWith(this, right)) {
+      this.content = this.content.concat(right.content)
+      return true
+    }
+    return false
+  }
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    super.write(encoder, offset, structJSONRefNumber)
+    const len = this.content.length
+    encoding.writeVarUint(encoder, len - offset)
+    for (let i = offset; i < len; i++) {
+      const c = this.content[i]
+      encoding.writeVarString(encoder, c === undefined ? 'undefined' : JSON.stringify(c))
+    }
+  }
+}
+
+/**
+ * @private
+ */
+export class ItemJSONRef extends AbstractItemRef {
+  /**
+   * @param {decoding.Decoder} decoder
+   * @param {ID} id
+   * @param {number} info
+   */
+  constructor (decoder, id, info) {
+    super(decoder, id, info)
+    const len = decoding.readVarUint(decoder)
+    const cs = []
+    for (let i = 0; i < len; i++) {
+      const c = decoding.readVarString(decoder)
+      if (c === 'undefined') {
+        cs.push(undefined)
+      } else {
+        cs.push(JSON.parse(c))
+      }
+    }
+    /**
+     * @type {Array<any>}
+     */
+    this.content = cs
+  }
+  get length () {
+    return this.content.length
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {StructStore} store
+   * @param {number} offset
+   * @return {ItemJSON|GC}
+   */
+  toStruct (transaction, store, offset) {
+    if (offset > 0) {
+      changeItemRefOffset(this, offset)
+      this.content = this.content.slice(offset)
+    }
+    const { left, right, parent, parentSub } = computeItemParams(transaction, store, this.left, this.right, this.parent, this.parentSub, this.parentYKey)
+    return parent === null
+      ? new GC(this.id, this.length)
+      : new ItemJSON(
+        this.id,
+        left,
+        this.left,
+        right,
+        this.right,
+        parent,
+        parentSub,
+        this.content
+      )
+  }
+}
--- a/src/structs/ItemString.js
+++ b/src/structs/ItemString.js
@@ -0,0 +1,138 @@
+
+import {
+  AbstractItem,
+  AbstractItemRef,
+  computeItemParams,
+  splitItem,
+  changeItemRefOffset,
+  GC,
+  mergeItemWith,
+  Transaction, StructStore, ID, AbstractType // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+
+export const structStringRefNumber = 6
+
+/**
+ * @private
+ */
+export class ItemString extends AbstractItem {
+  /**
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   * @param {string} string
+   */
+  constructor (id, left, origin, right, rightOrigin, parent, parentSub, string) {
+    super(id, left, origin, right, rightOrigin, parent, parentSub)
+    /**
+     * @type {string}
+     */
+    this.string = string
+  }
+  /**
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   */
+  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
+    return new ItemString(id, left, origin, right, rightOrigin, parent, parentSub, this.string)
+  }
+  getContent () {
+    return this.string.split('')
+  }
+  get length () {
+    return this.string.length
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {number} diff
+   * @return {ItemString}
+   */
+  splitAt (transaction, diff) {
+    /**
+     * @type {ItemString}
+     */
+    // @ts-ignore
+    const right = splitItem(transaction, this, diff)
+    right.string = this.string.slice(diff)
+    this.string = this.string.slice(0, diff)
+    return right
+  }
+  /**
+   * @param {ItemString} right
+   * @return {boolean}
+   */
+  mergeWith (right) {
+    if (mergeItemWith(this, right)) {
+      this.string += right.string
+      return true
+    }
+    return false
+  }
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    super.write(encoder, offset, structStringRefNumber)
+    encoding.writeVarString(encoder, offset === 0 ? this.string : this.string.slice(offset))
+  }
+}
+
+/**
+ * @private
+ */
+export class ItemStringRef extends AbstractItemRef {
+  /**
+   * @param {decoding.Decoder} decoder
+   * @param {ID} id
+   * @param {number} info
+   */
+  constructor (decoder, id, info) {
+    super(decoder, id, info)
+    /**
+     * @type {string}
+     */
+    this.string = decoding.readVarString(decoder)
+  }
+  get length () {
+    return this.string.length
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {StructStore} store
+   * @param {number} offset
+   * @return {ItemString|GC}
+   */
+  toStruct (transaction, store, offset) {
+    if (offset > 0) {
+      changeItemRefOffset(this, offset)
+      this.string = this.string.slice(offset)
+    }
+
+    const { left, right, parent, parentSub } = computeItemParams(transaction, store, this.left, this.right, this.parent, this.parentSub, this.parentYKey)
+    return parent === null
+      ? new GC(this.id, this.length)
+      : new ItemString(
+        this.id,
+        left,
+        this.left,
+        right,
+        this.right,
+        parent,
+        parentSub,
+        this.string
+      )
+  }
+}
--- a/src/structs/ItemType.js
+++ b/src/structs/ItemType.js
@@ -0,0 +1,199 @@
+
+import {
+  AbstractItem,
+  AbstractItemRef,
+  computeItemParams,
+  readYArray,
+  readYMap,
+  readYText,
+  readYXmlElement,
+  readYXmlFragment,
+  readYXmlHook,
+  readYXmlText,
+  StructStore, GC, Transaction, ID, AbstractType // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js' // eslint-disable-line
+import * as decoding from 'lib0/decoding.js'
+
+/**
+ * @private
+ */
+export const structTypeRefNumber = 7
+
+/**
+ * @type {Array<function(decoding.Decoder):AbstractType<any>>}
+ * @private
+ */
+export const typeRefs = [
+  readYArray,
+  readYMap,
+  readYText,
+  readYXmlElement,
+  readYXmlFragment,
+  readYXmlHook,
+  readYXmlText
+]
+
+export const YArrayRefID = 0
+export const YMapRefID = 1
+export const YTextRefID = 2
+export const YXmlElementRefID = 3
+export const YXmlFragmentRefID = 4
+export const YXmlHookRefID = 5
+export const YXmlTextRefID = 6
+
+/**
+ * @private
+ */
+export class ItemType extends AbstractItem {
+  /**
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   * @param {AbstractType<any>} type
+   */
+  constructor (id, left, origin, right, rightOrigin, parent, parentSub, type) {
+    super(id, left, origin, right, rightOrigin, parent, parentSub)
+    this.type = type
+  }
+
+  getContent () {
+    return [this.type]
+  }
+  /**
+   * @param {ID} id
+   * @param {AbstractItem | null} left
+   * @param {ID | null} origin
+   * @param {AbstractItem | null} right
+   * @param {ID | null} rightOrigin
+   * @param {AbstractType<any>} parent
+   * @param {string | null} parentSub
+   * @return {ItemType}
+   */
+  copy (id, left, origin, right, rightOrigin, parent, parentSub) {
+    return new ItemType(id, left, origin, right, rightOrigin, parent, parentSub, this.type._copy())
+  }
+  /**
+   * @param {Transaction} transaction
+   */
+  integrate (transaction) {
+    super.integrate(transaction)
+    this.type._integrate(transaction.doc, this)
+  }
+  /**
+   * @param {encoding.Encoder} encoder
+   * @param {number} offset
+   */
+  write (encoder, offset) {
+    super.write(encoder, offset, structTypeRefNumber)
+    this.type._write(encoder)
+  }
+  /**
+   * Mark this Item as deleted.
+   *
+   * @param {Transaction} transaction The Yjs instance
+   * @private
+   */
+  delete (transaction) {
+    if (!this.deleted) {
+      super.delete(transaction)
+      let item = this.type._start
+      while (item !== null) {
+        if (!item.deleted) {
+          item.delete(transaction)
+        } else {
+          // Whis will be gc'd later and we want to merge it if possible
+          // We try to merge all deleted items after each transaction,
+          // but we have no knowledge about that this needs to be merged
+          // since it is not in transaction.ds. Hence we add it to transaction._mergeStructs
+          transaction._mergeStructs.add(item.id)
+        }
+        item = item.right
+      }
+      this.type._map.forEach(item => {
+        if (!item.deleted) {
+          item.delete(transaction)
+        } else {
+          // same as above
+          transaction._mergeStructs.add(item.id)
+        }
+      })
+      transaction.changed.delete(this.type)
+      transaction.changedParentTypes.delete(this.type)
+    }
+  }
+
+  /**
+   * @param {StructStore} store
+   */
+  gcChildren (store) {
+    let item = this.type._start
+    while (item !== null) {
+      item.gc(store, true)
+      item = item.right
+    }
+    this.type._start = null
+    this.type._map.forEach(item => {
+      while (item !== null) {
+        item.gc(store, true)
+        // @ts-ignore
+        item = item.left
+      }
+    })
+    this._map = new Map()
+  }
+
+  /**
+   * @param {StructStore} store
+   * @param {boolean} parentGCd
+   */
+  gc (store, parentGCd) {
+    this.gcChildren(store)
+    super.gc(store, parentGCd)
+  }
+}
+
+/**
+ * @private
+ */
+export class ItemTypeRef extends AbstractItemRef {
+  /**
+   * @param {decoding.Decoder} decoder
+   * @param {ID} id
+   * @param {number} info
+   */
+  constructor (decoder, id, info) {
+    super(decoder, id, info)
+    const typeRef = decoding.readVarUint(decoder)
+    /**
+     * @type {AbstractType<any>}
+     */
+    this.type = typeRefs[typeRef](decoder)
+  }
+  /**
+   * @param {Transaction} transaction
+   * @param {StructStore} store
+   * @param {number} offset
+   * @return {ItemType|GC}
+   */
+  toStruct (transaction, store, offset) {
+    const { left, right, parent, parentSub } = computeItemParams(transaction, store, this.left, this.right, this.parent, this.parentSub, this.parentYKey)
+    return parent === null
+      ? new GC(this.id, this.length)
+      : new ItemType(
+        this.id,
+        left,
+        this.left,
+        right,
+        this.right,
+        parent,
+        parentSub,
+        this.type
+      )
+  }
+}
--- a/src/types/AbstractType.js
+++ b/src/types/AbstractType.js
@@ -0,0 +1,601 @@
+
+import {
+  removeEventHandlerListener,
+  callEventHandlerListeners,
+  addEventHandlerListener,
+  createEventHandler,
+  ItemType,
+  nextID,
+  isVisible,
+  ItemJSON,
+  ItemBinary,
+  createID,
+  getItemCleanStart,
+  Doc, Snapshot, Transaction, EventHandler, YEvent, AbstractItem, // eslint-disable-line
+} from '../internals.js'
+
+import * as map from 'lib0/map.js'
+import * as iterator from 'lib0/iterator.js'
+import * as error from 'lib0/error.js'
+import * as encoding from 'lib0/encoding.js' // eslint-disable-line
+
+/**
+ * Call event listeners with an event. This will also add an event to all
+ * parents (for `.observeDeep` handlers).
+ * @private
+ *
+ * @template EventType
+ * @param {AbstractType<EventType>} type
+ * @param {Transaction} transaction
+ * @param {EventType} event
+ */
+export const callTypeObservers = (type, transaction, event) => {
+  callEventHandlerListeners(type._eH, event, transaction)
+  const changedParentTypes = transaction.changedParentTypes
+  while (true) {
+    // @ts-ignore
+    map.setIfUndefined(changedParentTypes, type, () => []).push(event)
+    if (type._item === null) {
+      break
+    }
+    type = type._item.parent
+  }
+}
+
+/**
+ * @template EventType
+ * Abstract Yjs Type class
+ */
+export class AbstractType {
+  constructor () {
+    /**
+     * @type {ItemType|null}
+     */
+    this._item = null
+    /**
+     * @private
+     * @type {Map<string,AbstractItem>}
+     */
+    this._map = new Map()
+    /**
+     * @private
+     * @type {AbstractItem|null}
+     */
+    this._start = null
+    /**
+     * @private
+     * @type {Doc|null}
+     */
+    this.doc = null
+    this._length = 0
+    /**
+     * Event handlers
+     * @type {EventHandler<EventType,Transaction>}
+     */
+    this._eH = createEventHandler()
+    /**
+     * Deep event handlers
+     * @type {EventHandler<Array<YEvent>,Transaction>}
+     */
+    this._dEH = createEventHandler()
+  }
+
+  /**
+   * Integrate this type into the Yjs instance.
+   *
+   * * Save this struct in the os
+   * * This type is sent to other client
+   * * Observer functions are fired
+   *
+   * @param {Doc} y The Yjs instance
+   * @param {ItemType|null} item
+   * @private
+   */
+  _integrate (y, item) {
+    this.doc = y
+    this._item = item
+  }
+
+  /**
+   * @return {AbstractType<EventType>}
+   * @private
+   */
+  _copy () {
+    throw error.methodUnimplemented()
+  }
+
+  /**
+   * @param {encoding.Encoder} encoder
+   * @private
+   */
+  _write (encoder) { }
+
+  /**
+   * The first non-deleted item
+   */
+  get _first () {
+    let n = this._start
+    while (n !== null && n.deleted) {
+      n = n.right
+    }
+    return n
+  }
+
+  /**
+   * Creates YEvent and calls all type observers.
+   * Must be implemented by each type.
+   *
+   * @param {Transaction} transaction
+   * @param {Set<null|string>} parentSubs Keys changed on this type. `null` if list was modified.
+   *
+   * @private
+   */
+  _callObserver (transaction, parentSubs) { /* skip if no type is specified */ }
+
+  /**
+   * Observe all events that are created on this type.
+   *
+   * @param {function(EventType, Transaction):void} f Observer function
+   */
+  observe (f) {
+    addEventHandlerListener(this._eH, f)
+  }
+
+  /**
+   * Observe all events that are created by this type and its children.
+   *
+   * @param {function(Array<YEvent>,Transaction):void} f Observer function
+   */
+  observeDeep (f) {
+    addEventHandlerListener(this._dEH, f)
+  }
+
+  /**
+   * Unregister an observer function.
+   *
+   * @param {function(EventType,Transaction):void} f Observer function
+   */
+  unobserve (f) {
+    removeEventHandlerListener(this._eH, f)
+  }
+
+  /**
+   * Unregister an observer function.
+   *
+   * @param {function(Array<YEvent>,Transaction):void} f Observer function
+   */
+  unobserveDeep (f) {
+    removeEventHandlerListener(this._dEH, f)
+  }
+
+  /**
+   * @abstract
+   * @return {Object | Array | number | string}
+   */
+  toJSON () {}
+}
+
+/**
+ * @param {AbstractType<any>} type
+ * @return {Array<any>}
+ *
+ * @private
+ * @function
+ */
+export const typeListToArray = type => {
+  const cs = []
+  let n = type._start
+  while (n !== null) {
+    if (n.countable && !n.deleted) {
+      const c = n.getContent()
+      for (let i = 0; i < c.length; i++) {
+        cs.push(c[i])
+      }
+    }
+    n = n.right
+  }
+  return cs
+}
+
+/**
+ * @param {AbstractType<any>} type
+ * @param {Snapshot} snapshot
+ * @return {Array<any>}
+ *
+ * @private
+ * @function
+ */
+export const typeListToArraySnapshot = (type, snapshot) => {
+  const cs = []
+  let n = type._start
+  while (n !== null) {
+    if (n.countable && isVisible(n, snapshot)) {
+      const c = n.getContent()
+      for (let i = 0; i < c.length; i++) {
+        cs.push(c[i])
+      }
+    }
+    n = n.right
+  }
+  return cs
+}
+
+/**
+ * Executes a provided function on once on overy element of this YArray.
+ *
+ * @param {AbstractType<any>} type
+ * @param {function(any,number,any):void} f A function to execute on every element of this YArray.
+ *
+ * @private
+ * @function
+ */
+export const typeListForEach = (type, f) => {
+  let index = 0
+  let n = type._start
+  while (n !== null) {
+    if (n.countable && !n.deleted) {
+      const c = n.getContent()
+      for (let i = 0; i < c.length; i++) {
+        f(c[i], index++, type)
+      }
+    }
+    n = n.right
+  }
+}
+
+/**
+ * @template C,R
+ * @param {AbstractType<any>} type
+ * @param {function(C,number,AbstractType<any>):R} f
+ * @return {Array<R>}
+ *
+ * @private
+ * @function
+ */
+export const typeListMap = (type, f) => {
+  /**
+   * @type {Array<any>}
+   */
+  const result = []
+  typeListForEach(type, (c, i) => {
+    result.push(f(c, i, type))
+  })
+  return result
+}
+
+/**
+ * @param {AbstractType<any>} type
+ * @return {IterableIterator<any>}
+ *
+ * @private
+ * @function
+ */
+export const typeListCreateIterator = type => {
+  let n = type._start
+  /**
+   * @type {Array<any>|null}
+   */
+  let currentContent = null
+  let currentContentIndex = 0
+  return {
+    [Symbol.iterator] () {
+      return this
+    },
+    next: () => {
+      // find some content
+      if (currentContent === null) {
+        while (n !== null && n.deleted) {
+          n = n.right
+        }
+      }
+      // check if we reached the end, no need to check currentContent, because it does not exist
+      if (n === null) {
+        return {
+          done: true,
+          value: undefined
+        }
+      }
+      // currentContent could exist from the last iteration
+      if (currentContent === null) {
+        // we found n, so we can set currentContent
+        currentContent = n.getContent()
+        currentContentIndex = 0
+        n = n.right // we used the content of n, now iterate to next
+      }
+      const value = currentContent[currentContentIndex++]
+      // check if we need to empty currentContent
+      if (currentContent.length <= currentContentIndex) {
+        currentContent = null
+      }
+      return {
+        done: false,
+        value
+      }
+    }
+  }
+}
+
+/**
+ * Executes a provided function on once on overy element of this YArray.
+ * Operates on a snapshotted state of the document.
+ *
+ * @param {AbstractType<any>} type
+ * @param {function(any,number,AbstractType<any>):void} f A function to execute on every element of this YArray.
+ * @param {Snapshot} snapshot
+ *
+ * @private
+ * @function
+ */
+export const typeListForEachSnapshot = (type, f, snapshot) => {
+  let index = 0
+  let n = type._start
+  while (n !== null) {
+    if (n.countable && isVisible(n, snapshot)) {
+      const c = n.getContent()
+      for (let i = 0; i < c.length; i++) {
+        f(c[i], index++, type)
+      }
+    }
+    n = n.right
+  }
+}
+
+/**
+ * @param {AbstractType<any>} type
+ * @param {number} index
+ * @return {any}
+ *
+ * @private
+ * @function
+ */
+export const typeListGet = (type, index) => {
+  for (let n = type._start; n !== null; n = n.right) {
+    if (!n.deleted && n.countable) {
+      if (index < n.length) {
+        return n.getContent()[index]
+      }
+      index -= n.length
+    }
+  }
+}
+
+/**
+ * @param {Transaction} transaction
+ * @param {AbstractType<any>} parent
+ * @param {AbstractItem?} referenceItem
+ * @param {Array<Object<string,any>|Array<any>|boolean|number|string|Uint8Array>} content
+ *
+ * @private
+ * @function
+ */
+export const typeListInsertGenericsAfter = (transaction, parent, referenceItem, content) => {
+  let left = referenceItem
+  const right = referenceItem === null ? parent._start : referenceItem.right
+  /**
+   * @type {Array<Object|Array|number>}
+   */
+  let jsonContent = []
+  const packJsonContent = () => {
+    if (jsonContent.length > 0) {
+      left = new ItemJSON(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, null, jsonContent)
+      left.integrate(transaction)
+      jsonContent = []
+    }
+  }
+  content.forEach(c => {
+    switch (c.constructor) {
+      case Number:
+      case Object:
+      case Boolean:
+      case Array:
+      case String:
+        jsonContent.push(c)
+        break
+      default:
+        packJsonContent()
+        switch (c.constructor) {
+          case Uint8Array:
+          case ArrayBuffer:
+            left = new ItemBinary(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, null, new Uint8Array(/** @type {Uint8Array} */ (c)))
+            left.integrate(transaction)
+            break
+          default:
+            if (c instanceof AbstractType) {
+              left = new ItemType(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, null, c)
+              left.integrate(transaction)
+            } else {
+              throw new Error('Unexpected content type in insert operation')
+            }
+        }
+    }
+  })
+  packJsonContent()
+}
+
+/**
+ * @param {Transaction} transaction
+ * @param {AbstractType<any>} parent
+ * @param {number} index
+ * @param {Array<Object<string,any>|Array<any>|number|string|Uint8Array>} content
+ *
+ * @private
+ * @function
+ */
+export const typeListInsertGenerics = (transaction, parent, index, content) => {
+  if (index === 0) {
+    return typeListInsertGenericsAfter(transaction, parent, null, content)
+  }
+  let n = parent._start
+  for (; n !== null; n = n.right) {
+    if (!n.deleted && n.countable) {
+      if (index <= n.length) {
+        if (index < n.length) {
+          // insert in-between
+          getItemCleanStart(transaction, transaction.doc.store, createID(n.id.client, n.id.clock + index))
+        }
+        break
+      }
+      index -= n.length
+    }
+  }
+  return typeListInsertGenericsAfter(transaction, parent, n, content)
+}
+
+/**
+ * @param {Transaction} transaction
+ * @param {AbstractType<any>} parent
+ * @param {number} index
+ * @param {number} length
+ *
+ * @private
+ * @function
+ */
+export const typeListDelete = (transaction, parent, index, length) => {
+  if (length === 0) { return }
+  let n = parent._start
+  // compute the first item to be deleted
+  for (; n !== null && index > 0; n = n.right) {
+    if (!n.deleted && n.countable) {
+      if (index < n.length) {
+        getItemCleanStart(transaction, transaction.doc.store, createID(n.id.client, n.id.clock + index))
+      }
+      index -= n.length
+    }
+  }
+  // delete all items until done
+  while (length > 0 && n !== null) {
+    if (!n.deleted) {
+      if (length < n.length) {
+        getItemCleanStart(transaction, transaction.doc.store, createID(n.id.client, n.id.clock + length))
+      }
+      n.delete(transaction)
+      length -= n.length
+    }
+    n = n.right
+  }
+  if (length > 0) {
+    throw error.create('array length exceeded')
+  }
+}
+
+/**
+ * @param {Transaction} transaction
+ * @param {AbstractType<any>} parent
+ * @param {string} key
+ *
+ * @private
+ * @function
+ */
+export const typeMapDelete = (transaction, parent, key) => {
+  const c = parent._map.get(key)
+  if (c !== undefined) {
+    c.delete(transaction)
+  }
+}
+
+/**
+ * @param {Transaction} transaction
+ * @param {AbstractType<any>} parent
+ * @param {string} key
+ * @param {Object|number|Array<any>|string|Uint8Array|AbstractType<any>} value
+ *
+ * @private
+ * @function
+ */
+export const typeMapSet = (transaction, parent, key, value) => {
+  const left = parent._map.get(key) || null
+  if (value == null) {
+    new ItemJSON(nextID(transaction), left, left === null ? null : left.lastId, null, null, parent, key, [value]).integrate(transaction)
+    return
+  }
+  switch (value.constructor) {
+    case Number:
+    case Object:
+    case Boolean:
+    case Array:
+    case String:
+      new ItemJSON(nextID(transaction), left, left === null ? null : left.lastId, null, null, parent, key, [value]).integrate(transaction)
+      break
+    case Uint8Array:
+      new ItemBinary(nextID(transaction), left, left === null ? null : left.lastId, null, null, parent, key, value).integrate(transaction)
+      break
+    default:
+      if (value instanceof AbstractType) {
+        new ItemType(nextID(transaction), left, left === null ? null : left.lastId, null, null, parent, key, value).integrate(transaction)
+      } else {
+        throw new Error('Unexpected content type')
+      }
+  }
+}
+
+/**
+ * @param {AbstractType<any>} parent
+ * @param {string} key
+ * @return {Object<string,any>|number|Array<any>|string|Uint8Array|AbstractType<any>|undefined}
+ *
+ * @private
+ * @function
+ */
+export const typeMapGet = (parent, key) => {
+  const val = parent._map.get(key)
+  return val !== undefined && !val.deleted ? val.getContent()[0] : undefined
+}
+
+/**
+ * @param {AbstractType<any>} parent
+ * @return {Object<string,Object<string,any>|number|Array<any>|string|Uint8Array|AbstractType<any>|undefined>}
+ *
+ * @private
+ * @function
+ */
+export const typeMapGetAll = (parent) => {
+  /**
+   * @type {Object<string,any>}
+   */
+  let res = {}
+  for (const [key, value] of parent._map) {
+    if (!value.deleted) {
+      res[key] = value.getContent()[value.length - 1]
+    }
+  }
+  return res
+}
+
+/**
+ * @param {AbstractType<any>} parent
+ * @param {string} key
+ * @return {boolean}
+ *
+ * @private
+ * @function
+ */
+export const typeMapHas = (parent, key) => {
+  const val = parent._map.get(key)
+  return val !== undefined && !val.deleted
+}
+
+/**
+ * @param {AbstractType<any>} parent
+ * @param {string} key
+ * @param {Snapshot} snapshot
+ * @return {Object<string,any>|number|Array<any>|string|Uint8Array|AbstractType<any>|undefined}
+ *
+ * @private
+ * @function
+ */
+export const typeMapGetSnapshot = (parent, key, snapshot) => {
+  let v = parent._map.get(key) || null
+  while (v !== null && (!snapshot.sm.has(v.id.client) || v.id.clock >= (snapshot.sm.get(v.id.client) || 0))) {
+    v = v.left
+  }
+  return v !== null && isVisible(v, snapshot) ? v.getContent()[v.length - 1] : undefined
+}
+
+/**
+ * @param {Map<string,AbstractItem>} map
+ * @return {IterableIterator<Array<any>>}
+ *
+ * @private
+ * @function
+ */
+export const createMapIterator = map => iterator.iteratorFilter(map.entries(), /** @param {any} entry */ entry => !entry[1].deleted)
--- a/src/types/YArray.js
+++ b/src/types/YArray.js
@@ -0,0 +1,213 @@
+/**
+ * @module YArray
+ */
+
+import {
+  YEvent,
+  AbstractType,
+  typeListGet,
+  typeListToArray,
+  typeListForEach,
+  typeListCreateIterator,
+  typeListInsertGenerics,
+  typeListDelete,
+  typeListMap,
+  YArrayRefID,
+  callTypeObservers,
+  transact,
+  Doc, Transaction, ItemType, // eslint-disable-line
+} from '../internals.js'
+
+import * as decoding from 'lib0/decoding.js' // eslint-disable-line
+import * as encoding from 'lib0/encoding.js'
+
+/**
+ * Event that describes the changes on a YArray
+ * @template T
+ */
+export class YArrayEvent extends YEvent {
+  /**
+   * @param {YArray<T>} yarray The changed type
+   * @param {Transaction} transaction The transaction object
+   */
+  constructor (yarray, transaction) {
+    super(yarray, transaction)
+    this._transaction = transaction
+  }
+}
+
+/**
+ * A shared Array implementation.
+ * @template T
+ * @extends AbstractType<YArrayEvent<T>>
+ * @implements {IterableIterator<T>}
+ */
+export class YArray extends AbstractType {
+  constructor () {
+    super()
+    /**
+     * @type {Array<any>?}
+     * @private
+     */
+    this._prelimContent = []
+  }
+  /**
+   * Integrate this type into the Yjs instance.
+   *
+   * * Save this struct in the os
+   * * This type is sent to other client
+   * * Observer functions are fired
+   *
+   * @param {Doc} y The Yjs instance
+   * @param {ItemType} item
+   *
+   * @private
+   */
+  _integrate (y, item) {
+    super._integrate(y, item)
+    // @ts-ignore
+    this.insert(0, this._prelimContent)
+    this._prelimContent = null
+  }
+  get length () {
+    return this._prelimContent === null ? this._length : this._prelimContent.length
+  }
+  /**
+   * Creates YArrayEvent and calls observers.
+   *
+   * @param {Transaction} transaction
+   * @param {Set<null|string>} parentSubs Keys changed on this type. `null` if list was modified.
+   *
+   * @private
+   */
+  _callObserver (transaction, parentSubs) {
+    callTypeObservers(this, transaction, new YArrayEvent(this, transaction))
+  }
+
+  /**
+   * Inserts new content at an index.
+   *
+   * Important: This function expects an array of content. Not just a content
+   * object. The reason for this "weirdness" is that inserting several elements
+   * is very efficient when it is done as a single operation.
+   *
+   * @example
+   *  // Insert character 'a' at position 0
+   *  yarray.insert(0, ['a'])
+   *  // Insert numbers 1, 2 at position 1
+   *  yarray.insert(1, [1, 2])
+   *
+   * @param {number} index The index to insert content at.
+   * @param {Array<T>} content The array of content
+   */
+  insert (index, content) {
+    if (this.doc !== null) {
+      transact(this.doc, transaction => {
+        typeListInsertGenerics(transaction, this, index, content)
+      })
+    } else {
+      // @ts-ignore _prelimContent is defined because this is not yet integrated
+      this._prelimContent.splice(index, 0, ...content)
+    }
+  }
+
+  /**
+   * Appends content to this YArray.
+   *
+   * @param {Array<T>} content Array of content to append.
+   */
+  push (content) {
+    this.insert(this.length, content)
+  }
+
+  /**
+   * Deletes elements starting from an index.
+   *
+   * @param {number} index Index at which to start deleting elements
+   * @param {number} length The number of elements to remove. Defaults to 1.
+   */
+  delete (index, length = 1) {
+    if (this.doc !== null) {
+      transact(this.doc, transaction => {
+        typeListDelete(transaction, this, index, length)
+      })
+    } else {
+      // @ts-ignore _prelimContent is defined because this is not yet integrated
+      this._prelimContent.splice(index, length)
+    }
+  }
+
+  /**
+   * Returns the i-th element from a YArray.
+   *
+   * @param {number} index The index of the element to return from the YArray
+   * @return {T}
+   */
+  get (index) {
+    return typeListGet(this, index)
+  }
+
+  /**
+   * Transforms this YArray to a JavaScript Array.
+   *
+   * @return {Array<T>}
+   */
+  toArray () {
+    return typeListToArray(this)
+  }
+
+  /**
+   * Transforms this Shared Type to a JSON object.
+   *
+   * @return {Array<any>}
+   */
+  toJSON () {
+    return this.map(c => c instanceof AbstractType ? c.toJSON() : c)
+  }
+
+  /**
+   * Returns an Array with the result of calling a provided function on every
+   * element of this YArray.
+   *
+   * @template T,M
+   * @param {function(T,number,YArray<T>):M} f Function that produces an element of the new Array
+   * @return {Array<M>} A new array with each element being the result of the
+   *                 callback function
+   */
+  map (f) {
+    // @ts-ignore
+    return typeListMap(this, f)
+  }
+
+  /**
+   * Executes a provided function on once on overy element of this YArray.
+   *
+   * @param {function(T,number,YArray<T>):void} f A function to execute on every element of this YArray.
+   */
+  forEach (f) {
+    typeListForEach(this, f)
+  }
+
+  /**
+   * @return {IterableIterator<T>}
+   */
+  [Symbol.iterator] () {
+    return typeListCreateIterator(this)
+  }
+
+  /**
+   * @param {encoding.Encoder} encoder
+   * @private
+   */
+  _write (encoder) {
+    encoding.writeVarUint(encoder, YArrayRefID)
+  }
+}
+
+/**
+ * @param {decoding.Decoder} decoder
+ *
+ * @private
+ * @function
+ */
+export const readYArray = decoder => new YArray()
--- a/src/types/YMap.js
+++ b/src/types/YMap.js
@@ -0,0 +1,212 @@
+
+/**
+ * @module YMap
+ */
+
+import {
+  YEvent,
+  AbstractType,
+  typeMapDelete,
+  typeMapSet,
+  typeMapGet,
+  typeMapHas,
+  createMapIterator,
+  YMapRefID,
+  callTypeObservers,
+  transact,
+  Doc, Transaction, ItemType, // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js' // eslint-disable-line
+import * as iterator from 'lib0/iterator.js'
+
+/**
+ * @template T
+ * Event that describes the changes on a YMap.
+ */
+export class YMapEvent extends YEvent {
+  /**
+   * @param {YMap<T>} ymap The YArray that changed.
+   * @param {Transaction} transaction
+   * @param {Set<any>} subs The keys that changed.
+   */
+  constructor (ymap, transaction, subs) {
+    super(ymap, transaction)
+    this.keysChanged = subs
+  }
+}
+
+/**
+ * @template T number|string|Object|Array|Uint8Array
+ * A shared Map implementation.
+ *
+ * @extends AbstractType<YMapEvent<T>>
+ * @implements {IterableIterator}
+ */
+export class YMap extends AbstractType {
+  constructor () {
+    super()
+    /**
+     * @type {Map<string,any>?}
+     * @private
+     */
+    this._prelimContent = new Map()
+  }
+  /**
+   * Integrate this type into the Yjs instance.
+   *
+   * * Save this struct in the os
+   * * This type is sent to other client
+   * * Observer functions are fired
+   *
+   * @param {Doc} y The Yjs instance
+   * @param {ItemType} item
+   *
+   * @private
+   */
+  _integrate (y, item) {
+    super._integrate(y, item)
+    // @ts-ignore
+    for (let [key, value] of this._prelimContent) {
+      this.set(key, value)
+    }
+    this._prelimContent = null
+  }
+  /**
+   * Creates YMapEvent and calls observers.
+   *
+   * @param {Transaction} transaction
+   * @param {Set<null|string>} parentSubs Keys changed on this type. `null` if list was modified.
+   *
+   * @private
+   */
+  _callObserver (transaction, parentSubs) {
+    callTypeObservers(this, transaction, new YMapEvent(this, transaction, parentSubs))
+  }
+
+  /**
+   * Transforms this Shared Type to a JSON object.
+   *
+   * @return {Object<string,T>}
+   */
+  toJSON () {
+    /**
+     * @type {Object<string,T>}
+     */
+    const map = {}
+    for (let [key, item] of this._map) {
+      if (!item.deleted) {
+        const v = item.getContent()[0]
+        map[key] = v instanceof AbstractType ? v.toJSON() : v
+      }
+    }
+    return map
+  }
+
+  /**
+   * Returns the keys for each element in the YMap Type.
+   *
+   * @return {Iterator<string>}
+   */
+  keys () {
+    return iterator.iteratorMap(createMapIterator(this._map), /** @param {any} v */ v => v[0])
+  }
+
+  /**
+   * Returns the keys for each element in the YMap Type.
+   *
+   * @return {Iterator<string>}
+   */
+  values () {
+    return iterator.iteratorMap(createMapIterator(this._map), /** @param {any} v */ v => v[1].getContent()[v[1].length - 1])
+  }
+
+  /**
+   * Returns an Iterator of [key, value] pairs
+   *
+   * @return {IterableIterator<any>}
+   */
+  entries () {
+    return iterator.iteratorMap(createMapIterator(this._map), /** @param {any} v */ v => [v[0], v[1].getContent()[v[1].length - 1]])
+  }
+
+  /**
+   * @return {IterableIterator<T>}
+   */
+  [Symbol.iterator] () {
+    return this.entries()
+  }
+
+  /**
+   * Remove a specified element from this YMap.
+   *
+   * @param {string} key The key of the element to remove.
+   */
+  delete (key) {
+    if (this.doc !== null) {
+      transact(this.doc, transaction => {
+        typeMapDelete(transaction, this, key)
+      })
+    } else {
+      // @ts-ignore
+      this._prelimContent.delete(key)
+    }
+  }
+
+  /**
+   * Adds or updates an element with a specified key and value.
+   *
+   * @param {string} key The key of the element to add to this YMap
+   * @param {T} value The value of the element to add
+   */
+  set (key, value) {
+    if (this.doc !== null) {
+      transact(this.doc, transaction => {
+        typeMapSet(transaction, this, key, value)
+      })
+    } else {
+      // @ts-ignore
+      this._prelimContent.set(key, value)
+    }
+    return value
+  }
+
+  /**
+   * Returns a specified element from this YMap.
+   *
+   * @param {string} key
+   * @return {T|undefined}
+   */
+  get (key) {
+    // @ts-ignore
+    return typeMapGet(this, key)
+  }
+
+  /**
+   * Returns a boolean indicating whether the specified key exists or not.
+   *
+   * @param {string} key The key to test.
+   * @return {boolean}
+   */
+  has (key) {
+    return typeMapHas(this, key)
+  }
+
+  /**
+   * @param {encoding.Encoder} encoder
+   *
+   * @private
+   */
+  _write (encoder) {
+    encoding.writeVarUint(encoder, YMapRefID)
+  }
+}
+
+/**
+ * @param {decoding.Decoder} decoder
+ *
+ * @private
+ * @function
+ */
+export const readYMap = decoder => new YMap()
--- a/src/types/YText.js
+++ b/src/types/YText.js
@@ -0,0 +1,917 @@
+
+/**
+ * @module YText
+ */
+
+import {
+  YEvent,
+  ItemEmbed,
+  ItemString,
+  ItemFormat,
+  AbstractType,
+  nextID,
+  createID,
+  getItemCleanStart,
+  isVisible,
+  YTextRefID,
+  callTypeObservers,
+  transact,
+  Doc, ItemType, AbstractItem, Snapshot, StructStore, Transaction // eslint-disable-line
+} from '../internals.js'
+
+import * as decoding from 'lib0/decoding.js' // eslint-disable-line
+import * as encoding from 'lib0/encoding.js'
+
+export class ItemListPosition {
+  /**
+   * @param {AbstractItem|null} left
+   * @param {AbstractItem|null} right
+   */
+  constructor (left, right) {
+    this.left = left
+    this.right = right
+  }
+}
+
+export class ItemTextListPosition extends ItemListPosition {
+  /**
+   * @param {AbstractItem|null} left
+   * @param {AbstractItem|null} right
+   * @param {Map<string,any>} currentAttributes
+   */
+  constructor (left, right, currentAttributes) {
+    super(left, right)
+    this.currentAttributes = currentAttributes
+  }
+}
+
+export class ItemInsertionResult extends ItemListPosition {
+  /**
+   * @param {AbstractItem|null} left
+   * @param {AbstractItem|null} right
+   * @param {Map<string,any>} negatedAttributes
+   */
+  constructor (left, right, negatedAttributes) {
+    super(left, right)
+    this.negatedAttributes = negatedAttributes
+  }
+}
+
+/**
+ * @param {Transaction} transaction
+ * @param {StructStore} store
+ * @param {Map<string,any>} currentAttributes
+ * @param {AbstractItem|null} left
+ * @param {AbstractItem|null} right
+ * @param {number} count
+ * @return {ItemTextListPosition}
+ *
+ * @private
+ * @function
+ */
+const findNextPosition = (transaction, store, currentAttributes, left, right, count) => {
+  while (right !== null && count > 0) {
+    switch (right.constructor) {
+      case ItemEmbed:
+      case ItemString:
+        if (!right.deleted) {
+          if (count < right.length) {
+            // split right
+            getItemCleanStart(transaction, store, createID(right.id.client, right.id.clock + count))
+          }
+          count -= right.length
+        }
+        break
+      case ItemFormat:
+        if (!right.deleted) {
+          // @ts-ignore right is ItemFormat
+          updateCurrentAttributes(currentAttributes, right)
+        }
+        break
+    }
+    left = right
+    right = right.right
+  }
+  return new ItemTextListPosition(left, right, currentAttributes)
+}
+
+/**
+ * @param {Transaction} transaction
+ * @param {StructStore} store
+ * @param {AbstractType<any>} parent
+ * @param {number} index
+ * @return {ItemTextListPosition}
+ *
+ * @private
+ * @function
+ */
+const findPosition = (transaction, store, parent, index) => {
+  let currentAttributes = new Map()
+  let left = null
+  let right = parent._start
+  return findNextPosition(transaction, store, currentAttributes, left, right, index)
+}
+
+/**
+ * Negate applied formats
+ *
+ * @param {Transaction} transaction
+ * @param {AbstractType<any>} parent
+ * @param {AbstractItem|null} left
+ * @param {AbstractItem|null} right
+ * @param {Map<string,any>} negatedAttributes
+ * @return {ItemListPosition}
+ *
+ * @private
+ * @function
+ */
+const insertNegatedAttributes = (transaction, parent, left, right, negatedAttributes) => {
+  // check if we really need to remove attributes
+  while (
+    right !== null && (
+      right.deleted === true || (
+        right.constructor === ItemFormat &&
+        // @ts-ignore right is ItemFormat
+        (negatedAttributes.get(right.key) === right.value)
+      )
+    )
+  ) {
+    if (!right.deleted) {
+      // @ts-ignore right is ItemFormat
+      negatedAttributes.delete(right.key)
+    }
+    left = right
+    right = right.right
+  }
+  for (let [key, val] of negatedAttributes) {
+    left = new ItemFormat(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, null, key, val)
+    left.integrate(transaction)
+  }
+  return { left, right }
+}
+
+/**
+ * @param {Map<string,any>} currentAttributes
+ * @param {ItemFormat} item
+ *
+ * @private
+ * @function
+ */
+const updateCurrentAttributes = (currentAttributes, item) => {
+  const value = item.value
+  const key = item.key
+  if (value === null) {
+    currentAttributes.delete(key)
+  } else {
+    currentAttributes.set(key, value)
+  }
+}
+
+/**
+ * @param {AbstractItem|null} left
+ * @param {AbstractItem|null} right
+ * @param {Map<string,any>} currentAttributes
+ * @param {Object<string,any>} attributes
+ * @return {ItemListPosition}
+ *
+ * @private
+ * @function
+ */
+const minimizeAttributeChanges = (left, right, currentAttributes, attributes) => {
+  // go right while attributes[right.key] === right.value (or right is deleted)
+  while (true) {
+    if (right === null) {
+      break
+    } else if (right.deleted) {
+      // continue
+    // @ts-ignore right is ItemFormat
+    } else if (right.constructor === ItemFormat && (attributes[right.key] || null) === right.value) {
+      // found a format, update currentAttributes and continue
+      // @ts-ignore right is ItemFormat
+      updateCurrentAttributes(currentAttributes, right)
+    } else {
+      break
+    }
+    left = right
+    right = right.right
+  }
+  return new ItemListPosition(left, right)
+}
+
+/**
+ * @param {Transaction} transaction
+ * @param {AbstractType<any>} parent
+ * @param {AbstractItem|null} left
+ * @param {AbstractItem|null} right
+ * @param {Map<string,any>} currentAttributes
+ * @param {Object<string,any>} attributes
+ * @return {ItemInsertionResult}
+ *
+ * @private
+ * @function
+ **/
+const insertAttributes = (transaction, parent, left, right, currentAttributes, attributes) => {
+  const negatedAttributes = new Map()
+  // insert format-start items
+  for (let key in attributes) {
+    const val = attributes[key]
+    const currentVal = currentAttributes.get(key) || null
+    if (currentVal !== val) {
+      // save negated attribute (set null if currentVal undefined)
+      negatedAttributes.set(key, currentVal)
+      left = new ItemFormat(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, null, key, val)
+      left.integrate(transaction)
+    }
+  }
+  return new ItemInsertionResult(left, right, negatedAttributes)
+}
+
+/**
+ * @param {Transaction} transaction
+ * @param {AbstractType<any>} parent
+ * @param {AbstractItem|null} left
+ * @param {AbstractItem|null} right
+ * @param {Map<string,any>} currentAttributes
+ * @param {string} text
+ * @param {Object<string,any>} attributes
+ * @return {ItemListPosition}
+ *
+ * @private
+ * @function
+ **/
+const insertText = (transaction, parent, left, right, currentAttributes, text, attributes) => {
+  for (let [key] of currentAttributes) {
+    if (attributes[key] === undefined) {
+      attributes[key] = null
+    }
+  }
+  const minPos = minimizeAttributeChanges(left, right, currentAttributes, attributes)
+  const insertPos = insertAttributes(transaction, parent, minPos.left, minPos.right, currentAttributes, attributes)
+  left = insertPos.left
+  right = insertPos.right
+  // insert content
+  if (text.constructor === String) {
+    left = new ItemString(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, null, text)
+  } else {
+    left = new ItemEmbed(nextID(transaction), left, left === null ? null : left.lastId, right, right === null ? null : right.id, parent, null, text)
+  }
+  left.integrate(transaction)
+  return insertNegatedAttributes(transaction, parent, left, insertPos.right, insertPos.negatedAttributes)
+}
+
+/**
+ * @param {Transaction} transaction
+ * @param {AbstractType<any>} parent
+ * @param {AbstractItem|null} left
+ * @param {AbstractItem|null} right
+ * @param {Map<string,any>} currentAttributes
+ * @param {number} length
+ * @param {Object<string,any>} attributes
+ * @return {ItemListPosition}
+ *
+ * @private
+ * @function
+ */
+const formatText = (transaction, parent, left, right, currentAttributes, length, attributes) => {
+  const minPos = minimizeAttributeChanges(left, right, currentAttributes, attributes)
+  const insertPos = insertAttributes(transaction, parent, minPos.left, minPos.right, currentAttributes, attributes)
+  const negatedAttributes = insertPos.negatedAttributes
+  left = insertPos.left
+  right = insertPos.right
+  // iterate until first non-format or null is found
+  // delete all formats with attributes[format.key] != null
+  while (length > 0 && right !== null) {
+    if (right.deleted === false) {
+      switch (right.constructor) {
+        case ItemFormat:
+          // @ts-ignore right is ItemFormat
+          const attr = attributes[right.key]
+          if (attr !== undefined) {
+            // @ts-ignore right is ItemFormat
+            if (attr === right.value) {
+              // @ts-ignore right is ItemFormat
+              negatedAttributes.delete(right.key)
+            } else {
+              // @ts-ignore right is ItemFormat
+              negatedAttributes.set(right.key, right.value)
+            }
+            right.delete(transaction)
+          }
+          // @ts-ignore right is ItemFormat
+          updateCurrentAttributes(currentAttributes, right)
+          break
+        case ItemEmbed:
+        case ItemString:
+          if (length < right.length) {
+            getItemCleanStart(transaction, transaction.doc.store, createID(right.id.client, right.id.clock + length))
+          }
+          length -= right.length
+          break
+      }
+    }
+    left = right
+    right = right.right
+  }
+  return insertNegatedAttributes(transaction, parent, left, right, negatedAttributes)
+}
+
+/**
+ * @param {Transaction} transaction
+ * @param {AbstractItem|null} left
+ * @param {AbstractItem|null} right
+ * @param {Map<string,any>} currentAttributes
+ * @param {number} length
+ * @return {ItemListPosition}
+ *
+ * @private
+ * @function
+ */
+const deleteText = (transaction, left, right, currentAttributes, length) => {
+  while (length > 0 && right !== null) {
+    if (right.deleted === false) {
+      switch (right.constructor) {
+        case ItemFormat:
+          // @ts-ignore right is ItemFormat
+          updateCurrentAttributes(currentAttributes, right)
+          break
+        case ItemEmbed:
+        case ItemString:
+          if (length < right.length) {
+            getItemCleanStart(transaction, transaction.doc.store, createID(right.id.client, right.id.clock + length))
+          }
+          length -= right.length
+          right.delete(transaction)
+          break
+      }
+    }
+    left = right
+    right = right.right
+  }
+  return { left, right }
+}
+
+/**
+ * The Quill Delta format represents changes on a text document with
+ * formatting information. For mor information visit {@link https://quilljs.com/docs/delta/|Quill Delta}
+ *
+ * @example
+ *   {
+ *     ops: [
+ *       { insert: 'Gandalf', attributes: { bold: true } },
+ *       { insert: ' the ' },
+ *       { insert: 'Grey', attributes: { color: '#cccccc' } }
+ *     ]
+ *   }
+ *
+ */
+
+/**
+  * Attributes that can be assigned to a selection of text.
+  *
+  * @example
+  *   {
+  *     bold: true,
+  *     font-size: '40px'
+  *   }
+  *
+  * @typedef {Object} TextAttributes
+  */
+
+/**
+ * @typedef {Object} DeltaItem
+ * @property {number|undefined} DeltaItem.delete
+ * @property {number|undefined} DeltaItem.retain
+ * @property {string|undefined} DeltaItem.string
+ * @property {Object<string,any>} DeltaItem.attributes
+ */
+
+/**
+ * Event that describes the changes on a YText type.
+ */
+export class YTextEvent extends YEvent {
+  /**
+   * @param {YText} ytext
+   * @param {Transaction} transaction
+   */
+  constructor (ytext, transaction) {
+    super(ytext, transaction)
+    /**
+     * @private
+     * @type {Array<DeltaItem>|null}
+     */
+    this._delta = null
+  }
+  /**
+   * Compute the changes in the delta format.
+   * A {@link https://quilljs.com/docs/delta/|Quill Delta}) that represents the changes on the document.
+   *
+   * @type {Array<DeltaItem>}
+   *
+   * @public
+   */
+  get delta () {
+    if (this._delta === null) {
+      const y = this.target.doc
+      // @ts-ignore
+      transact(y, transaction => {
+        /**
+         * @type {Array<DeltaItem>}
+         */
+        const delta = []
+        const currentAttributes = new Map() // saves all current attributes for insert
+        const oldAttributes = new Map()
+        let item = this.target._start
+        /**
+         * @type {string?}
+         */
+        let action = null
+        /**
+         * @type {Object<string,any>}
+         */
+        let attributes = {} // counts added or removed new attributes for retain
+        let insert = ''
+        let retain = 0
+        let deleteLen = 0
+        this._delta = delta
+        const addOp = () => {
+          if (action !== null) {
+            /**
+             * @type {any}
+             */
+            let op
+            switch (action) {
+              case 'delete':
+                op = { delete: deleteLen }
+                deleteLen = 0
+                break
+              case 'insert':
+                op = { insert }
+                if (currentAttributes.size > 0) {
+                  op.attributes = {}
+                  for (let [key, value] of currentAttributes) {
+                    if (value !== null) {
+                      op.attributes[key] = value
+                    }
+                  }
+                }
+                insert = ''
+                break
+              case 'retain':
+                op = { retain }
+                if (Object.keys(attributes).length > 0) {
+                  op.attributes = {}
+                  for (let key in attributes) {
+                    op.attributes[key] = attributes[key]
+                  }
+                }
+                retain = 0
+                break
+            }
+            delta.push(op)
+            action = null
+          }
+        }
+        while (item !== null) {
+          switch (item.constructor) {
+            case ItemEmbed:
+              if (this.adds(item)) {
+                if (!this.deletes(item)) {
+                  addOp()
+                  action = 'insert'
+                  // @ts-ignore item is ItemFormat
+                  insert = item.embed
+                  addOp()
+                }
+              } else if (this.deletes(item)) {
+                if (action !== 'delete') {
+                  addOp()
+                  action = 'delete'
+                }
+                deleteLen += 1
+              } else if (!item.deleted) {
+                if (action !== 'retain') {
+                  addOp()
+                  action = 'retain'
+                }
+                retain += 1
+              }
+              break
+            case ItemString:
+              if (this.adds(item)) {
+                if (!this.deletes(item)) {
+                  if (action !== 'insert') {
+                    addOp()
+                    action = 'insert'
+                  }
+                  // @ts-ignore
+                  insert += item.string
+                }
+              } else if (this.deletes(item)) {
+                if (action !== 'delete') {
+                  addOp()
+                  action = 'delete'
+                }
+                deleteLen += item.length
+              } else if (!item.deleted) {
+                if (action !== 'retain') {
+                  addOp()
+                  action = 'retain'
+                }
+                retain += item.length
+              }
+              break
+            case ItemFormat:
+              if (this.adds(item)) {
+                if (!this.deletes(item)) {
+                  // @ts-ignore item is ItemFormat
+                  const curVal = currentAttributes.get(item.key) || null
+                  // @ts-ignore item is ItemFormat
+                  if (curVal !== item.value) {
+                    if (action === 'retain') {
+                      addOp()
+                    }
+                    // @ts-ignore item is ItemFormat
+                    if (item.value === (oldAttributes.get(item.key) || null)) {
+                      // @ts-ignore item is ItemFormat
+                      delete attributes[item.key]
+                    } else {
+                      // @ts-ignore item is ItemFormat
+                      attributes[item.key] = item.value
+                    }
+                  } else {
+                    item.delete(transaction)
+                  }
+                }
+              } else if (this.deletes(item)) {
+                // @ts-ignore item is ItemFormat
+                oldAttributes.set(item.key, item.value)
+                // @ts-ignore item is ItemFormat
+                const curVal = currentAttributes.get(item.key) || null
+                // @ts-ignore item is ItemFormat
+                if (curVal !== item.value) {
+                  if (action === 'retain') {
+                    addOp()
+                  }
+                  // @ts-ignore item is ItemFormat
+                  attributes[item.key] = curVal
+                }
+              } else if (!item.deleted) {
+                // @ts-ignore item is ItemFormat
+                oldAttributes.set(item.key, item.value)
+                // @ts-ignore item is ItemFormat
+                const attr = attributes[item.key]
+                if (attr !== undefined) {
+                  // @ts-ignore item is ItemFormat
+                  if (attr !== item.value) {
+                    if (action === 'retain') {
+                      addOp()
+                    }
+                    // @ts-ignore item is ItemFormat
+                    if (item.value === null) {
+                      // @ts-ignore item is ItemFormat
+                      attributes[item.key] = item.value
+                    } else {
+                      // @ts-ignore item is ItemFormat
+                      delete attributes[item.key]
+                    }
+                  } else {
+                    item.delete(transaction)
+                  }
+                }
+              }
+              if (!item.deleted) {
+                if (action === 'insert') {
+                  addOp()
+                }
+                // @ts-ignore item is ItemFormat
+                updateCurrentAttributes(currentAttributes, item)
+              }
+              break
+          }
+          item = item.right
+        }
+        addOp()
+        while (this._delta.length > 0) {
+          let lastOp = this._delta[this._delta.length - 1]
+          if (lastOp.retain !== undefined && lastOp.attributes === undefined) {
+            // retain delta's if they don't assign attributes
+            this._delta.pop()
+          } else {
+            break
+          }
+        }
+      })
+    }
+    // @ts-ignore _delta is defined above
+    return this._delta
+  }
+}
+
+/**
+ * Type that represents text with formatting information.
+ *
+ * This type replaces y-richtext as this implementation is able to handle
+ * block formats (format information on a paragraph), embeds (complex elements
+ * like pictures and videos), and text formats (**bold**, *italic*).
+ *
+ * @extends AbstractType<YTextEvent>
+ */
+export class YText extends AbstractType {
+  /**
+   * @param {String} [string] The initial value of the YText.
+   */
+  constructor (string) {
+    super()
+    /**
+     * Array of pending operations on this type
+     * @type {Array<function():void>?}
+     * @private
+     */
+    this._pending = string !== undefined ? [() => this.insert(0, string)] : []
+  }
+
+  get length () {
+    return this._length
+  }
+
+  /**
+   * @param {Doc} y
+   * @param {ItemType} item
+   *
+   * @private
+   */
+  _integrate (y, item) {
+    super._integrate(y, item)
+    try {
+      // @ts-ignore this._prelimContent is still defined
+      this._pending.forEach(f => f())
+    } catch (e) {
+      console.error(e)
+    }
+    this._pending = null
+  }
+
+  /**
+   * Creates YTextEvent and calls observers.
+   *
+   * @param {Transaction} transaction
+   * @param {Set<null|string>} parentSubs Keys changed on this type. `null` if list was modified.
+   *
+   * @private
+   */
+  _callObserver (transaction, parentSubs) {
+    callTypeObservers(this, transaction, new YTextEvent(this, transaction))
+  }
+
+  /**
+   * Returns the unformatted string representation of this YText type.
+   *
+   * @public
+   */
+  toString () {
+    let str = ''
+    /**
+     * @type {AbstractItem|null}
+     */
+    let n = this._start
+    while (n !== null) {
+      if (!n.deleted && n.countable && n.constructor === ItemString) {
+        // @ts-ignore
+        str += n.string
+      }
+      n = n.right
+    }
+    return str
+  }
+
+  /**
+   * Apply a {@link Delta} on this shared YText type.
+   *
+   * @param {any} delta The changes to apply on this element.
+   *
+   * @public
+   */
+  applyDelta (delta) {
+    if (this.doc !== null) {
+      transact(this.doc, transaction => {
+        /**
+         * @type {ItemListPosition}
+         */
+        let pos = new ItemListPosition(null, this._start)
+        const currentAttributes = new Map()
+        for (let i = 0; i < delta.length; i++) {
+          const op = delta[i]
+          if (op.insert !== undefined) {
+            pos = insertText(transaction, this, pos.left, pos.right, currentAttributes, op.insert, op.attributes || {})
+          } else if (op.retain !== undefined) {
+            pos = formatText(transaction, this, pos.left, pos.right, currentAttributes, op.retain, op.attributes || {})
+          } else if (op.delete !== undefined) {
+            pos = deleteText(transaction, pos.left, pos.right, currentAttributes, op.delete)
+          }
+        }
+      })
+    } else {
+      // @ts-ignore
+      this._pending.push(() => this.applyDelta(delta))
+    }
+  }
+
+  /**
+   * Returns the Delta representation of this YText type.
+   *
+   * @param {Snapshot} [snapshot]
+   * @param {Snapshot} [prevSnapshot]
+   * @return {any} The Delta representation of this type.
+   *
+   * @public
+   */
+  toDelta (snapshot, prevSnapshot) {
+    /**
+     * @type{Array<any>}
+     */
+    const ops = []
+    const currentAttributes = new Map()
+    let str = ''
+    /**
+     * @type {AbstractItem|null}
+     */
+    // @ts-ignore
+    let n = this._start
+    function packStr () {
+      if (str.length > 0) {
+        // pack str with attributes to ops
+        /**
+         * @type {Object<string,any>}
+         */
+        const attributes = {}
+        let addAttributes = false
+        for (let [key, value] of currentAttributes) {
+          addAttributes = true
+          attributes[key] = value
+        }
+        /**
+         * @type {Object<string,any>}
+         */
+        const op = { insert: str }
+        if (addAttributes) {
+          op.attributes = attributes
+        }
+        ops.push(op)
+        str = ''
+      }
+    }
+    while (n !== null) {
+      if (isVisible(n, snapshot) || (prevSnapshot !== undefined && isVisible(n, prevSnapshot))) {
+        switch (n.constructor) {
+          case ItemString:
+            const cur = currentAttributes.get('ychange')
+            if (snapshot !== undefined && !isVisible(n, snapshot)) {
+              if (cur === undefined || cur.user !== n.id.client || cur.state !== 'removed') {
+                packStr()
+                currentAttributes.set('ychange', { user: n.id.client, state: 'removed' })
+              }
+            } else if (prevSnapshot !== undefined && !isVisible(n, prevSnapshot)) {
+              if (cur === undefined || cur.user !== n.id.client || cur.state !== 'added') {
+                packStr()
+                currentAttributes.set('ychange', { user: n.id.client, state: 'added' })
+              }
+            } else if (cur !== undefined) {
+              packStr()
+              currentAttributes.delete('ychange')
+            }
+            // @ts-ignore
+            str += n.string
+            break
+          case ItemFormat:
+            packStr()
+            // @ts-ignore
+            updateCurrentAttributes(currentAttributes, n)
+            break
+        }
+      }
+      n = n.right
+    }
+    packStr()
+    return ops
+  }
+
+  /**
+   * Insert text at a given index.
+   *
+   * @param {number} index The index at which to start inserting.
+   * @param {String} text The text to insert at the specified position.
+   * @param {TextAttributes} attributes Optionally define some formatting
+   *                                    information to apply on the inserted
+   *                                    Text.
+   * @public
+   */
+  insert (index, text, attributes = {}) {
+    if (text.length <= 0) {
+      return
+    }
+    const y = this.doc
+    if (y !== null) {
+      transact(y, transaction => {
+        const { left, right, currentAttributes } = findPosition(transaction, y.store, this, index)
+        insertText(transaction, this, left, right, currentAttributes, text, attributes)
+      })
+    } else {
+      // @ts-ignore
+      this._pending.push(() => this.insert(index, text, attributes))
+    }
+  }
+
+  /**
+   * Inserts an embed at a index.
+   *
+   * @param {number} index The index to insert the embed at.
+   * @param {Object} embed The Object that represents the embed.
+   * @param {TextAttributes} attributes Attribute information to apply on the
+   *                                    embed
+   *
+   * @public
+   */
+  insertEmbed (index, embed, attributes = {}) {
+    if (embed.constructor !== Object) {
+      throw new Error('Embed must be an Object')
+    }
+    const y = this.doc
+    if (y !== null) {
+      transact(y, transaction => {
+        const { left, right, currentAttributes } = findPosition(transaction, y.store, this, index)
+        insertText(transaction, this, left, right, currentAttributes, embed, attributes)
+      })
+    } else {
+      // @ts-ignore
+      this._pending.push(() => this.insertEmbed(index, embed, attributes))
+    }
+  }
+
+  /**
+   * Deletes text starting from an index.
+   *
+   * @param {number} index Index at which to start deleting.
+   * @param {number} length The number of characters to remove. Defaults to 1.
+   *
+   * @public
+   */
+  delete (index, length) {
+    if (length === 0) {
+      return
+    }
+    const y = this.doc
+    if (y !== null) {
+      transact(y, transaction => {
+        const { left, right, currentAttributes } = findPosition(transaction, y.store, this, index)
+        deleteText(transaction, left, right, currentAttributes, length)
+      })
+    } else {
+      // @ts-ignore
+      this._pending.push(() => this.delete(index, length))
+    }
+  }
+
+  /**
+   * Assigns properties to a range of text.
+   *
+   * @param {number} index The position where to start formatting.
+   * @param {number} length The amount of characters to assign properties to.
+   * @param {TextAttributes} attributes Attribute information to apply on the
+   *                                    text.
+   *
+   * @public
+   */
+  format (index, length, attributes) {
+    const y = this.doc
+    if (y !== null) {
+      transact(y, transaction => {
+        let { left, right, currentAttributes } = findPosition(transaction, y.store, this, index)
+        if (right === null) {
+          return
+        }
+        formatText(transaction, this, left, right, currentAttributes, length, attributes)
+      })
+    } else {
+      // @ts-ignore
+      this._pending.push(() => this.format(index, length, attributes))
+    }
+  }
+
+  /**
+   * @param {encoding.Encoder} encoder
+   *
+   * @private
+   */
+  _write (encoder) {
+    encoding.writeVarUint(encoder, YTextRefID)
+  }
+}
+
+/**
+ * @param {decoding.Decoder} decoder
+ * @return {YText}
+ *
+ * @private
+ * @function
+ */
+export const readYText = decoder => new YText()
--- a/src/types/YXmlElement.js
+++ b/src/types/YXmlElement.js
@@ -0,0 +1,210 @@
+
+import {
+  YXmlFragment,
+  transact,
+  typeMapDelete,
+  typeMapSet,
+  typeMapGet,
+  typeMapGetAll,
+  typeListForEach,
+  YXmlElementRefID,
+  Snapshot, Doc, ItemType // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+
+/**
+ * An YXmlElement imitates the behavior of a
+ * {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}.
+ *
+ * * An YXmlElement has attributes (key value pairs)
+ * * An YXmlElement has childElements that must inherit from YXmlElement
+ */
+export class YXmlElement extends YXmlFragment {
+  constructor (nodeName = 'UNDEFINED') {
+    super()
+    this.nodeName = nodeName.toUpperCase()
+    /**
+     * @type {Map<string, any>|null}
+     * @private
+     */
+    this._prelimAttrs = new Map()
+  }
+
+  /**
+   * Integrate this type into the Yjs instance.
+   *
+   * * Save this struct in the os
+   * * This type is sent to other client
+   * * Observer functions are fired
+   *
+   * @param {Doc} y The Yjs instance
+   * @param {ItemType} item
+   * @private
+   */
+  _integrate (y, item) {
+    super._integrate(y, item)
+    // @ts-ignore
+    this.insert(0, this._prelimContent)
+    this._prelimContent = null
+    // @ts-ignore
+    this._prelimAttrs.forEach((value, key) => {
+      this.setAttribute(key, value)
+    })
+    this._prelimContent = null
+  }
+
+  /**
+   * Creates an Item with the same effect as this Item (without position effect)
+   *
+   * @return {YXmlElement}
+   * @private
+   */
+  _copy () {
+    return new YXmlElement(this.nodeName)
+  }
+
+  /**
+   * Returns the XML serialization of this YXmlElement.
+   * The attributes are ordered by attribute-name, so you can easily use this
+   * method to compare YXmlElements
+   *
+   * @return {string} The string representation of this type.
+   *
+   * @public
+   */
+  toString () {
+    const attrs = this.getAttributes()
+    const stringBuilder = []
+    const keys = []
+    for (let key in attrs) {
+      keys.push(key)
+    }
+    keys.sort()
+    const keysLen = keys.length
+    for (let i = 0; i < keysLen; i++) {
+      const key = keys[i]
+      stringBuilder.push(key + '="' + attrs[key] + '"')
+    }
+    const nodeName = this.nodeName.toLocaleLowerCase()
+    const attrsString = stringBuilder.length > 0 ? ' ' + stringBuilder.join(' ') : ''
+    return `<${nodeName}${attrsString}>${super.toString()}</${nodeName}>`
+  }
+
+  /**
+   * Removes an attribute from this YXmlElement.
+   *
+   * @param {String} attributeName The attribute name that is to be removed.
+   *
+   * @public
+   */
+  removeAttribute (attributeName) {
+    if (this.doc !== null) {
+      transact(this.doc, transaction => {
+        typeMapDelete(transaction, this, attributeName)
+      })
+    } else {
+      // @ts-ignore
+      this._prelimAttrs.delete(attributeName)
+    }
+  }
+
+  /**
+   * Sets or updates an attribute.
+   *
+   * @param {String} attributeName The attribute name that is to be set.
+   * @param {String} attributeValue The attribute value that is to be set.
+   *
+   * @public
+   */
+  setAttribute (attributeName, attributeValue) {
+    if (this.doc !== null) {
+      transact(this.doc, transaction => {
+        typeMapSet(transaction, this, attributeName, attributeValue)
+      })
+    } else {
+      // @ts-ignore
+      this._prelimAttrs.set(attributeName, attributeValue)
+    }
+  }
+
+  /**
+   * Returns an attribute value that belongs to the attribute name.
+   *
+   * @param {String} attributeName The attribute name that identifies the
+   *                               queried value.
+   * @return {String} The queried attribute value.
+   *
+   * @public
+   */
+  getAttribute (attributeName) {
+    // @ts-ignore
+    return typeMapGet(this, attributeName)
+  }
+
+  /**
+   * Returns all attribute name/value pairs in a JSON Object.
+   *
+   * @param {Snapshot} [snapshot]
+   * @return {Object} A JSON Object that describes the attributes.
+   *
+   * @public
+   */
+  getAttributes (snapshot) {
+    return typeMapGetAll(this)
+  }
+
+  /**
+   * Creates a Dom Element that mirrors this YXmlElement.
+   *
+   * @param {Document} [_document=document] The document object (you must define
+   *                                        this when calling this method in
+   *                                        nodejs)
+   * @param {Object<string, any>} [hooks={}] Optional property to customize how hooks
+   *                                             are presented in the DOM
+   * @param {any} [binding] You should not set this property. This is
+   *                               used if DomBinding wants to create a
+   *                               association to the created DOM type.
+   * @return {Node} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}
+   *
+   * @public
+   */
+  toDOM (_document = document, hooks = {}, binding) {
+    const dom = _document.createElement(this.nodeName)
+    let attrs = this.getAttributes()
+    for (let key in attrs) {
+      dom.setAttribute(key, attrs[key])
+    }
+    typeListForEach(this, yxml => {
+      dom.appendChild(yxml.toDOM(_document, hooks, binding))
+    })
+    if (binding !== undefined) {
+      binding._createAssociation(dom, this)
+    }
+    return dom
+  }
+
+  /**
+   * Transform the properties of this type to binary and write it to an
+   * BinaryEncoder.
+   *
+   * This is called when this Item is sent to a remote peer.
+   *
+   * @private
+   * @param {encoding.Encoder} encoder The encoder to write data to.
+   */
+  _write (encoder) {
+    encoding.writeVarUint(encoder, YXmlElementRefID)
+    encoding.writeVarString(encoder, this.nodeName)
+  }
+}
+
+/**
+ * @param {decoding.Decoder} decoder
+ * @return {YXmlElement}
+ *
+ * @private
+ * @function
+ */
+export const readYXmlElement = decoder => new YXmlElement(decoding.readVarString(decoder))
--- a/src/types/YXmlEvent.js
+++ b/src/types/YXmlEvent.js
@@ -0,0 +1,39 @@
+
+import {
+  YEvent,
+  YXmlElement, YXmlFragment, Transaction // eslint-disable-line
+} from '../internals.js'
+
+/**
+ * An Event that describes changes on a YXml Element or Yxml Fragment
+ */
+export class YXmlEvent extends YEvent {
+  /**
+   * @param {YXmlElement|YXmlFragment} target The target on which the event is created.
+   * @param {Set<string|null>} subs The set of changed attributes. `null` is included if the
+   *                   child list changed.
+   * @param {Transaction} transaction The transaction instance with wich the
+   *                                  change was created.
+   */
+  constructor (target, subs, transaction) {
+    super(target, transaction)
+    /**
+     * Whether the children changed.
+     * @type {Boolean}
+     * @private
+     */
+    this.childListChanged = false
+    /**
+     * Set of all changed attributes.
+     * @type {Set<string|null>}
+     */
+    this.attributesChanged = new Set()
+    subs.forEach((sub) => {
+      if (sub === null) {
+        this.childListChanged = true
+      } else {
+        this.attributesChanged.add(sub)
+      }
+    })
+  }
+}
--- a/src/types/YXmlFragment.js
+++ b/src/types/YXmlFragment.js
@@ -0,0 +1,313 @@
+/**
+ * @module YXml
+ */
+
+import {
+  YXmlEvent,
+  YXmlElement,
+  AbstractType,
+  typeListMap,
+  typeListForEach,
+  typeListInsertGenerics,
+  typeListDelete,
+  typeListToArray,
+  YXmlFragmentRefID,
+  callTypeObservers,
+  transact,
+  Transaction, ItemType, YXmlText, YXmlHook, Snapshot // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js' // eslint-disable-line
+
+/**
+ * Define the elements to which a set of CSS queries apply.
+ * {@link https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Selectors|CSS_Selectors}
+ *
+ * @example
+ *   query = '.classSelector'
+ *   query = 'nodeSelector'
+ *   query = '#idSelector'
+ *
+ * @typedef {string} CSS_Selector
+ */
+
+/**
+ * Dom filter function.
+ *
+ * @callback domFilter
+ * @param {string} nodeName The nodeName of the element
+ * @param {Map} attributes The map of attributes.
+ * @return {boolean} Whether to include the Dom node in the YXmlElement.
+ */
+
+/**
+ * Represents a subset of the nodes of a YXmlElement / YXmlFragment and a
+ * position within them.
+ *
+ * Can be created with {@link YXmlFragment#createTreeWalker}
+ *
+ * @public
+ * @implements {IterableIterator}
+ */
+export class YXmlTreeWalker {
+  /**
+   * @param {YXmlFragment | YXmlElement} root
+   * @param {function(AbstractType<any>):boolean} [f]
+   */
+  constructor (root, f = () => true) {
+    this._filter = f
+    this._root = root
+    /**
+     * @type {ItemType | null}
+     */
+    // @ts-ignore
+    this._currentNode = root._start
+    this._firstCall = true
+  }
+
+  [Symbol.iterator] () {
+    return this
+  }
+  /**
+   * Get the next node.
+   *
+   * @return {IteratorResult<YXmlElement|YXmlText|YXmlHook>} The next node.
+   *
+   * @public
+   */
+  next () {
+    let n = this._currentNode
+    if (n !== null && (!this._firstCall || n.deleted || !this._filter(n.type))) { // if first call, we check if we can use the first item
+      do {
+        if (!n.deleted && (n.type.constructor === YXmlElement || n.type.constructor === YXmlFragment) && n.type._start !== null) {
+          // walk down in the tree
+          // @ts-ignore
+          n = n.type._start
+        } else {
+          // walk right or up in the tree
+          while (n !== null) {
+            if (n.right !== null) {
+              // @ts-ignore
+              n = n.right
+              break
+            } else if (n.parent === this._root) {
+              n = null
+            } else {
+              n = n.parent._item
+            }
+          }
+        }
+      } while (n !== null && (n.deleted || !this._filter(n.type)))
+    }
+    this._firstCall = false
+    this._currentNode = n
+    if (n === null) {
+      // @ts-ignore return undefined if done=true (the expected result)
+      return { value: undefined, done: true }
+    }
+    // @ts-ignore
+    return { value: n.type, done: false }
+  }
+}
+
+/**
+ * Represents a list of {@link YXmlElement}.and {@link YXmlText} types.
+ * A YxmlFragment is similar to a {@link YXmlElement}, but it does not have a
+ * nodeName and it does not have attributes. Though it can be bound to a DOM
+ * element - in this case the attributes and the nodeName are not shared.
+ *
+ * @public
+ * @extends AbstractType<YXmlEvent>
+ */
+export class YXmlFragment extends AbstractType {
+  constructor () {
+    super()
+    /**
+     * @type {Array<any>|null}
+     * @private
+     */
+    this._prelimContent = []
+  }
+  /**
+   * Create a subtree of childNodes.
+   *
+   * @example
+   * const walker = elem.createTreeWalker(dom => dom.nodeName === 'div')
+   * for (let node in walker) {
+   *   // `node` is a div node
+   *   nop(node)
+   * }
+   *
+   * @param {function(AbstractType<any>):boolean} filter Function that is called on each child element and
+   *                          returns a Boolean indicating whether the child
+   *                          is to be included in the subtree.
+   * @return {YXmlTreeWalker} A subtree and a position within it.
+   *
+   * @public
+   */
+  createTreeWalker (filter) {
+    return new YXmlTreeWalker(this, filter)
+  }
+
+  /**
+   * Returns the first YXmlElement that matches the query.
+   * Similar to DOM's {@link querySelector}.
+   *
+   * Query support:
+   *   - tagname
+   * TODO:
+   *   - id
+   *   - attribute
+   *
+   * @param {CSS_Selector} query The query on the children.
+   * @return {YXmlElement|YXmlText|YXmlHook|null} The first element that matches the query or null.
+   *
+   * @public
+   */
+  querySelector (query) {
+    query = query.toUpperCase()
+    // @ts-ignore
+    const iterator = new YXmlTreeWalker(this, element => element.nodeName === query)
+    const next = iterator.next()
+    if (next.done) {
+      return null
+    } else {
+      return next.value
+    }
+  }
+
+  /**
+   * Returns all YXmlElements that match the query.
+   * Similar to Dom's {@link querySelectorAll}.
+   *
+   * @todo Does not yet support all queries. Currently only query by tagName.
+   *
+   * @param {CSS_Selector} query The query on the children
+   * @return {Array<YXmlElement|YXmlText|YXmlHook|null>} The elements that match this query.
+   *
+   * @public
+   */
+  querySelectorAll (query) {
+    query = query.toUpperCase()
+    // @ts-ignore
+    return Array.from(new YXmlTreeWalker(this, element => element.nodeName === query))
+  }
+
+  /**
+   * Creates YXmlEvent and calls observers.
+   * @private
+   *
+   * @param {Transaction} transaction
+   * @param {Set<null|string>} parentSubs Keys changed on this type. `null` if list was modified.
+   */
+  _callObserver (transaction, parentSubs) {
+    callTypeObservers(this, transaction, new YXmlEvent(this, parentSubs, transaction))
+  }
+
+  /**
+   * Get the string representation of all the children of this YXmlFragment.
+   *
+   * @return {string} The string representation of all children.
+   */
+  toString () {
+    return typeListMap(this, xml => xml.toString()).join('')
+  }
+
+  toJSON () {
+    return this.toString()
+  }
+
+  /**
+   * Creates a Dom Element that mirrors this YXmlElement.
+   *
+   * @param {Document} [_document=document] The document object (you must define
+   *                                        this when calling this method in
+   *                                        nodejs)
+   * @param {Object<string, any>} [hooks={}] Optional property to customize how hooks
+   *                                             are presented in the DOM
+   * @param {any} [binding] You should not set this property. This is
+   *                               used if DomBinding wants to create a
+   *                               association to the created DOM type.
+   * @return {Node} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}
+   *
+   * @public
+   */
+  toDOM (_document = document, hooks = {}, binding) {
+    const fragment = _document.createDocumentFragment()
+    if (binding !== undefined) {
+      binding._createAssociation(fragment, this)
+    }
+    typeListForEach(this, xmlType => {
+      fragment.insertBefore(xmlType.toDOM(_document, hooks, binding), null)
+    })
+    return fragment
+  }
+
+  /**
+   * Inserts new content at an index.
+   *
+   * @example
+   *  // Insert character 'a' at position 0
+   *  xml.insert(0, [new Y.XmlText('text')])
+   *
+   * @param {number} index The index to insert content at
+   * @param {Array<YXmlElement|YXmlText>} content The array of content
+   */
+  insert (index, content) {
+    if (this.doc !== null) {
+      transact(this.doc, transaction => {
+        typeListInsertGenerics(transaction, this, index, content)
+      })
+    } else {
+      // @ts-ignore _prelimContent is defined because this is not yet integrated
+      this._prelimContent.splice(index, 0, ...content)
+    }
+  }
+
+  /**
+   * Deletes elements starting from an index.
+   *
+   * @param {number} index Index at which to start deleting elements
+   * @param {number} [length=1] The number of elements to remove. Defaults to 1.
+   */
+  delete (index, length = 1) {
+    if (this.doc !== null) {
+      transact(this.doc, transaction => {
+        typeListDelete(transaction, this, index, length)
+      })
+    } else {
+      // @ts-ignore _prelimContent is defined because this is not yet integrated
+      this._prelimContent.splice(index, length)
+    }
+  }
+  /**
+   * Transforms this YArray to a JavaScript Array.
+   *
+   * @return {Array<YXmlElement|YXmlText|YXmlHook>}
+   */
+  toArray () {
+    return typeListToArray(this)
+  }
+  /**
+   * Transform the properties of this type to binary and write it to an
+   * BinaryEncoder.
+   *
+   * This is called when this Item is sent to a remote peer.
+   *
+   * @private
+   * @param {encoding.Encoder} encoder The encoder to write data to.
+   */
+  _write (encoder) {
+    encoding.writeVarUint(encoder, YXmlFragmentRefID)
+  }
+}
+
+/**
+ * @param {decoding.Decoder} decoder
+ * @return {YXmlFragment}
+ *
+ * @private
+ * @function
+ */
+export const readYXmlFragment = decoder => new YXmlFragment()
--- a/src/types/YXmlHook.js
+++ b/src/types/YXmlHook.js
@@ -0,0 +1,90 @@
+
+import {
+  YMap,
+  YXmlHookRefID
+} from '../internals.js'
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+
+/**
+ * You can manage binding to a custom type with YXmlHook.
+ *
+ * @extends {YMap<any>}
+ */
+export class YXmlHook extends YMap {
+  /**
+   * @param {string} hookName nodeName of the Dom Node.
+   */
+  constructor (hookName) {
+    super()
+    /**
+     * @type {string}
+     */
+    this.hookName = hookName
+  }
+
+  /**
+   * Creates an Item with the same effect as this Item (without position effect)
+   *
+   * @private
+   */
+  _copy () {
+    return new YXmlHook(this.hookName)
+  }
+
+  /**
+   * Creates a Dom Element that mirrors this YXmlElement.
+   *
+   * @param {Document} [_document=document] The document object (you must define
+   *                                        this when calling this method in
+   *                                        nodejs)
+   * @param {Object.<string, any>} [hooks] Optional property to customize how hooks
+   *                                             are presented in the DOM
+   * @param {any} [binding] You should not set this property. This is
+   *                               used if DomBinding wants to create a
+   *                               association to the created DOM type
+   * @return {Element} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}
+   *
+   * @public
+   */
+  toDOM (_document = document, hooks = {}, binding) {
+    const hook = hooks[this.hookName]
+    let dom
+    if (hook !== undefined) {
+      dom = hook.createDom(this)
+    } else {
+      dom = document.createElement(this.hookName)
+    }
+    dom.setAttribute('data-yjs-hook', this.hookName)
+    if (binding !== undefined) {
+      binding._createAssociation(dom, this)
+    }
+    return dom
+  }
+
+  /**
+   * Transform the properties of this type to binary and write it to an
+   * BinaryEncoder.
+   *
+   * This is called when this Item is sent to a remote peer.
+   *
+   * @param {encoding.Encoder} encoder The encoder to write data to.
+   *
+   * @private
+   */
+  _write (encoder) {
+    super._write(encoder)
+    encoding.writeVarUint(encoder, YXmlHookRefID)
+    encoding.writeVarString(encoder, this.hookName)
+  }
+}
+
+/**
+ * @param {decoding.Decoder} decoder
+ * @return {YXmlHook}
+ *
+ * @private
+ * @function
+ */
+export const readYXmlHook = decoder =>
+  new YXmlHook(decoding.readVarString(decoder))
--- a/src/types/YXmlText.js
+++ b/src/types/YXmlText.js
@@ -0,0 +1,90 @@
+
+import { YText, YXmlTextRefID } from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js' // eslint-disable-line
+
+/**
+ * Represents text in a Dom Element. In the future this type will also handle
+ * simple formatting information like bold and italic.
+ */
+export class YXmlText extends YText {
+  /**
+   * Creates a Dom Element that mirrors this YXmlText.
+   *
+   * @param {Document} [_document=document] The document object (you must define
+   *                                        this when calling this method in
+   *                                        nodejs)
+   * @param {Object<string, any>} [hooks] Optional property to customize how hooks
+   *                                             are presented in the DOM
+   * @param {any} [binding] You should not set this property. This is
+   *                               used if DomBinding wants to create a
+   *                               association to the created DOM type.
+   * @return {Text} The {@link https://developer.mozilla.org/en-US/docs/Web/API/Element|Dom Element}
+   *
+   * @public
+   */
+  toDOM (_document = document, hooks, binding) {
+    const dom = _document.createTextNode(this.toString())
+    if (binding !== undefined) {
+      binding._createAssociation(dom, this)
+    }
+    return dom
+  }
+
+  toString () {
+    // @ts-ignore
+    return this.toDelta().map(delta => {
+      const nestedNodes = []
+      for (let nodeName in delta.attributes) {
+        const attrs = []
+        for (let key in delta.attributes[nodeName]) {
+          attrs.push({ key, value: delta.attributes[nodeName][key] })
+        }
+        // sort attributes to get a unique order
+        attrs.sort((a, b) => a.key < b.key ? -1 : 1)
+        nestedNodes.push({ nodeName, attrs })
+      }
+      // sort node order to get a unique order
+      nestedNodes.sort((a, b) => a.nodeName < b.nodeName ? -1 : 1)
+      // now convert to dom string
+      let str = ''
+      for (let i = 0; i < nestedNodes.length; i++) {
+        const node = nestedNodes[i]
+        str += `<${node.nodeName}`
+        for (let j = 0; j < node.attrs.length; j++) {
+          const attr = node.attrs[i]
+          str += ` ${attr.key}="${attr.value}"`
+        }
+        str += '>'
+      }
+      str += delta.insert
+      for (let i = nestedNodes.length - 1; i >= 0; i--) {
+        str += `</${nestedNodes[i].nodeName}>`
+      }
+      return str
+    }).join('')
+  }
+
+  toJSON () {
+    return this.toString()
+  }
+
+  /**
+   * @param {encoding.Encoder} encoder
+   *
+   * @private
+   */
+  _write (encoder) {
+    encoding.writeVarUint(encoder, YXmlTextRefID)
+  }
+}
+
+/**
+ * @param {decoding.Decoder} decoder
+ * @return {YXmlText}
+ *
+ * @private
+ * @function
+ */
+export const readYXmlText = decoder => new YXmlText()
--- a/src/utils/DeleteSet.js
+++ b/src/utils/DeleteSet.js
@@ -0,0 +1,271 @@
+
+import {
+  findIndexSS,
+  createID,
+  getState,
+  AbstractStruct, AbstractItem, StructStore, Transaction, ID // eslint-disable-line
+} from '../internals.js'
+
+import * as math from 'lib0/math.js'
+import * as map from 'lib0/map.js'
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+
+class DeleteItem {
+  /**
+   * @param {number} clock
+   * @param {number} len
+   */
+  constructor (clock, len) {
+    /**
+     * @type {number}
+     */
+    this.clock = clock
+    /**
+     * @type {number}
+     */
+    this.len = len
+  }
+}
+
+/**
+ * We no longer maintain a DeleteStore. DeleteSet is a temporary object that is created when needed.
+ * - When created in a transaction, it must only be accessed after sorting, and merging
+ *   - This DeleteSet is send to other clients
+ * - We do not create a DeleteSet when we send a sync message. The DeleteSet message is created directly from StructStore
+ * - We read a DeleteSet as part of a sync/update message. In this case the DeleteSet is already sorted and merged.
+ */
+export class DeleteSet {
+  constructor () {
+    /**
+     * @type {Map<number,Array<DeleteItem>>}
+     * @private
+     */
+    this.clients = new Map()
+  }
+}
+
+/**
+ * Iterate over all structs that were deleted.
+ *
+ * This function expects that the deletes structs are not merged. Hence, you can
+ * probably only use it in type observes and `afterTransaction` events. But not
+ * in `afterTransactionCleanup`.
+ *
+ * @param {DeleteSet} ds
+ * @param {StructStore} store
+ * @param {function(AbstractStruct):void} f
+ *
+ * @function
+ */
+export const iterateDeletedStructs = (ds, store, f) =>
+  ds.clients.forEach((deletes, clientid) => {
+    const structs = /** @type {Array<AbstractStruct>} */ (store.clients.get(clientid))
+    for (let i = 0; i < deletes.length; i++) {
+      const del = deletes[i]
+      let index = findIndexSS(structs, del.clock)
+      let struct
+      do {
+        struct = structs[index++]
+        f(struct)
+      } while (index < structs.length && structs[index].id.clock < del.clock + del.len)
+    }
+  })
+
+/**
+ * @param {Array<DeleteItem>} dis
+ * @param {number} clock
+ * @return {number|null}
+ *
+ * @private
+ * @function
+ */
+export const findIndexDS = (dis, clock) => {
+  let left = 0
+  let right = dis.length - 1
+  while (left <= right) {
+    const midindex = math.floor((left + right) / 2)
+    const mid = dis[midindex]
+    const midclock = mid.clock
+    if (midclock <= clock) {
+      if (clock < midclock + mid.len) {
+        return midindex
+      }
+      left = midindex + 1
+    } else {
+      right = midindex - 1
+    }
+  }
+  return null
+}
+
+/**
+ * @param {DeleteSet} ds
+ * @param {ID} id
+ * @return {boolean}
+ *
+ * @private
+ * @function
+ */
+export const isDeleted = (ds, id) => {
+  const dis = ds.clients.get(id.client)
+  return dis !== undefined && findIndexDS(dis, id.clock) !== null
+}
+
+/**
+ * @param {DeleteSet} ds
+ *
+ * @private
+ * @function
+ */
+export const sortAndMergeDeleteSet = ds => {
+  ds.clients.forEach(dels => {
+    dels.sort((a, b) => a.clock - b.clock)
+    // merge items without filtering or splicing the array
+    // i is the current pointer
+    // j refers to the current insert position for the pointed item
+    // try to merge dels[i] into dels[j-1] or set dels[j]=dels[i]
+    let i, j
+    for (i = 1, j = 1; i < dels.length; i++) {
+      const left = dels[j - 1]
+      const right = dels[i]
+      if (left.clock + left.len === right.clock) {
+        left.len += right.len
+      } else {
+        if (j < i) {
+          dels[j] = right
+        }
+        j++
+      }
+    }
+    dels.length = j
+  })
+}
+
+/**
+ * @param {DeleteSet} ds
+ * @param {ID} id
+ * @param {number} length
+ *
+ * @private
+ * @function
+ */
+export const addToDeleteSet = (ds, id, length) => {
+  map.setIfUndefined(ds.clients, id.client, () => []).push(new DeleteItem(id.clock, length))
+}
+
+/**
+ * @param {StructStore} ss
+ * @return {DeleteSet} Merged and sorted DeleteSet
+ *
+ * @private
+ * @function
+ */
+export const createDeleteSetFromStructStore = ss => {
+  const ds = new DeleteSet()
+  ss.clients.forEach((structs, client) => {
+    /**
+     * @type {Array<DeleteItem>}
+     */
+    const dsitems = []
+    for (let i = 0; i < structs.length; i++) {
+      const struct = structs[i]
+      if (struct.deleted) {
+        const clock = struct.id.clock
+        let len = struct.length
+        if (i + 1 < structs.length) {
+          for (let next = structs[i + 1]; i + 1 < structs.length && next.id.clock === clock + len && next.deleted; next = structs[++i + 1]) {
+            len += next.length
+          }
+        }
+        dsitems.push(new DeleteItem(clock, len))
+      }
+    }
+    if (dsitems.length > 0) {
+      ds.clients.set(client, dsitems)
+    }
+  })
+  return ds
+}
+
+/**
+ * @param {encoding.Encoder} encoder
+ * @param {DeleteSet} ds
+ *
+ * @private
+ * @function
+ */
+export const writeDeleteSet = (encoder, ds) => {
+  encoding.writeVarUint(encoder, ds.clients.size)
+  ds.clients.forEach((dsitems, client) => {
+    encoding.writeVarUint(encoder, client)
+    const len = dsitems.length
+    encoding.writeVarUint(encoder, len)
+    for (let i = 0; i < len; i++) {
+      const item = dsitems[i]
+      encoding.writeVarUint(encoder, item.clock)
+      encoding.writeVarUint(encoder, item.len)
+    }
+  })
+}
+
+/**
+ * @param {decoding.Decoder} decoder
+ * @param {Transaction} transaction
+ * @param {StructStore} store
+ *
+ * @private
+ * @function
+ */
+export const readDeleteSet = (decoder, transaction, store) => {
+  const unappliedDS = new DeleteSet()
+  const numClients = decoding.readVarUint(decoder)
+  for (let i = 0; i < numClients; i++) {
+    const client = decoding.readVarUint(decoder)
+    const numberOfDeletes = decoding.readVarUint(decoder)
+    const structs = store.clients.get(client) || []
+    const state = getState(store, client)
+    for (let i = 0; i < numberOfDeletes; i++) {
+      const clock = decoding.readVarUint(decoder)
+      const len = decoding.readVarUint(decoder)
+      if (clock < state) {
+        if (state < clock + len) {
+          addToDeleteSet(unappliedDS, createID(client, state), clock + len - state)
+        }
+        let index = findIndexSS(structs, clock)
+        /**
+         * We can ignore the case of GC and Delete structs, because we are going to skip them
+         * @type {AbstractItem}
+         */
+        // @ts-ignore
+        let struct = structs[index]
+        // split the first item if necessary
+        if (!struct.deleted && struct.id.clock < clock) {
+          structs.splice(index + 1, 0, struct.splitAt(transaction, clock - struct.id.clock))
+          index++ // increase we now want to use the next struct
+        }
+        while (index < structs.length) {
+          // @ts-ignore
+          struct = structs[index++]
+          if (struct.id.clock < clock + len) {
+            if (!struct.deleted) {
+              if (clock + len < struct.id.clock + struct.length) {
+                structs.splice(index, 0, struct.splitAt(transaction, clock + len - struct.id.clock))
+              }
+              struct.delete(transaction)
+            }
+          } else {
+            break
+          }
+        }
+      } else {
+        addToDeleteSet(unappliedDS, createID(client, clock), len)
+      }
+    }
+  }
+  if (unappliedDS.clients.size > 0) {
+    const unappliedDSEncoder = encoding.createEncoder()
+    writeDeleteSet(unappliedDSEncoder, unappliedDS)
+    store.pendingDeleteReaders.push(decoding.createDecoder(encoding.toUint8Array(unappliedDSEncoder)))
+  }
+}
--- a/src/utils/Doc.js
+++ b/src/utils/Doc.js
@@ -0,0 +1,183 @@
+/**
+ * @module Y
+ */
+
+import {
+  StructStore,
+  AbstractType,
+  YArray,
+  YText,
+  YMap,
+  YXmlFragment,
+  transact,
+  AbstractItem, Transaction, YEvent // eslint-disable-line
+} from '../internals.js'
+
+import { Observable } from 'lib0/observable.js'
+import * as random from 'lib0/random.js'
+import * as map from 'lib0/map.js'
+
+/**
+ * A Yjs instance handles the state of shared data.
+ * @extends Observable<string>
+ */
+export class Doc extends Observable {
+  /**
+   * @param {Object|undefined} conf configuration
+   */
+  constructor (conf = {}) {
+    super()
+    this.clientID = random.uint32()
+    /**
+     * @type {Map<string, AbstractType<YEvent>>}
+     */
+    this.share = new Map()
+    this.store = new StructStore()
+    /**
+     * @type {Transaction | null}
+     * @private
+     */
+    this._transaction = null
+    /**
+     * @type {Array<Transaction>}
+     * @private
+     */
+    this._transactionCleanups = []
+  }
+  /**
+   * Changes that happen inside of a transaction are bundled. This means that
+   * the observer fires _after_ the transaction is finished and that all changes
+   * that happened inside of the transaction are sent as one message to the
+   * other peers.
+   *
+   * @param {function(Transaction):void} f The function that should be executed as a transaction
+   * @param {any} [origin] Origin of who started the transaction. Will be stored on transaction.origin
+   *
+   * @public
+   */
+  transact (f, origin = null) {
+    transact(this, f, origin)
+  }
+  /**
+   * Define a shared data type.
+   *
+   * Multiple calls of `y.get(name, TypeConstructor)` yield the same result
+   * and do not overwrite each other. I.e.
+   * `y.define(name, Y.Array) === y.define(name, Y.Array)`
+   *
+   * After this method is called, the type is also available on `y.share.get(name)`.
+   *
+   * *Best Practices:*
+   * Define all types right after the Yjs instance is created and store them in a separate object.
+   * Also use the typed methods `getText(name)`, `getArray(name)`, ..
+   *
+   * @example
+   *   const y = new Y(..)
+   *   const appState = {
+   *     document: y.getText('document')
+   *     comments: y.getArray('comments')
+   *   }
+   *
+   * @param {string} name
+   * @param {Function} TypeConstructor The constructor of the type definition. E.g. Y.Text, Y.Array, Y.Map, ...
+   * @return {AbstractType<any>} The created type. Constructed with TypeConstructor
+   *
+   * @public
+   */
+  get (name, TypeConstructor = AbstractType) {
+    const type = map.setIfUndefined(this.share, name, () => {
+      // @ts-ignore
+      const t = new TypeConstructor()
+      t._integrate(this, null)
+      return t
+    })
+    const Constr = type.constructor
+    if (TypeConstructor !== AbstractType && Constr !== TypeConstructor) {
+      if (Constr === AbstractType) {
+        // @ts-ignore
+        const t = new TypeConstructor()
+        t._map = type._map
+        type._map.forEach(/** @param {AbstractItem?} n */ n => {
+          for (; n !== null; n = n.left) {
+            n.parent = t
+          }
+        })
+        t._start = type._start
+        for (let n = t._start; n !== null; n = n.right) {
+          n.parent = t
+        }
+        t._length = type._length
+        this.share.set(name, t)
+        t._integrate(this, null)
+        return t
+      } else {
+        throw new Error(`Type with the name ${name} has already been defined with a different constructor`)
+      }
+    }
+    return type
+  }
+  /**
+   * @template T
+   * @param {string} name
+   * @return {YArray<T>}
+   *
+   * @public
+   */
+  getArray (name) {
+    // @ts-ignore
+    return this.get(name, YArray)
+  }
+  /**
+   * @param {string} name
+   * @return {YText}
+   *
+   * @public
+   */
+  getText (name) {
+    // @ts-ignore
+    return this.get(name, YText)
+  }
+  /**
+   * @param {string} name
+   * @return {YMap<any>}
+   *
+   * @public
+   */
+  getMap (name) {
+    // @ts-ignore
+    return this.get(name, YMap)
+  }
+  /**
+   * @param {string} name
+   * @return {YXmlFragment}
+   *
+   * @public
+   */
+  getXmlFragment (name) {
+    // @ts-ignore
+    return this.get(name, YXmlFragment)
+  }
+  /**
+   * Emit `destroy` event and unregister all event handlers.
+   *
+   * @protected
+   */
+  destroy () {
+    this.emit('destroyed', [true])
+    super.destroy()
+  }
+  /**
+   * @param {string} eventName
+   * @param {function} f
+   */
+  on (eventName, f) {
+    super.on(eventName, f)
+  }
+  /**
+   * @param {string} eventName
+   * @param {function} f
+   */
+  off (eventName, f) {
+    super.off(eventName, f)
+  }
+}
--- a/src/utils/EventHandler.js
+++ b/src/utils/EventHandler.js
@@ -0,0 +1,82 @@
+import * as f from 'lib0/function.js'
+
+/**
+ * General event handler implementation.
+ *
+ * @template ARG0, ARG1
+ *
+ * @private
+ */
+export class EventHandler {
+  constructor () {
+    /**
+     * @type {Array<function(ARG0, ARG1):void>}
+     */
+    this.l = []
+  }
+}
+
+/**
+ * @template ARG0,ARG1
+ * @returns {EventHandler<ARG0,ARG1>}
+ *
+ * @private
+ * @function
+ */
+export const createEventHandler = () => new EventHandler()
+
+/**
+ * Adds an event listener that is called when
+ * {@link EventHandler#callEventListeners} is called.
+ *
+ * @template ARG0,ARG1
+ * @param {EventHandler<ARG0,ARG1>} eventHandler
+ * @param {function(ARG0,ARG1):void} f The event handler.
+ *
+ * @private
+ * @function
+ */
+export const addEventHandlerListener = (eventHandler, f) =>
+  eventHandler.l.push(f)
+
+/**
+ * Removes an event listener.
+ *
+ * @template ARG0,ARG1
+ * @param {EventHandler<ARG0,ARG1>} eventHandler
+ * @param {function(ARG0,ARG1):void} f The event handler that was added with
+ *                     {@link EventHandler#addEventListener}
+ *
+ * @private
+ * @function
+ */
+export const removeEventHandlerListener = (eventHandler, f) => {
+  eventHandler.l = eventHandler.l.filter(g => f !== g)
+}
+
+/**
+ * Removes all event listeners.
+ * @template ARG0,ARG1
+ * @param {EventHandler<ARG0,ARG1>} eventHandler
+ *
+ * @private
+ * @function
+ */
+export const removeAllEventHandlerListeners = eventHandler => {
+  eventHandler.l.length = 0
+}
+
+/**
+ * Call all event listeners that were added via
+ * {@link EventHandler#addEventListener}.
+ *
+ * @template ARG0,ARG1
+ * @param {EventHandler<ARG0,ARG1>} eventHandler
+ * @param {ARG0} arg0
+ * @param {ARG1} arg1
+ *
+ * @private
+ * @function
+ */
+export const callEventHandlerListeners = (eventHandler, arg0, arg1) =>
+  f.callAll(eventHandler.l, [arg0, arg1])
--- a/src/utils/ID.js
+++ b/src/utils/ID.js
@@ -0,0 +1,90 @@
+
+import { AbstractType } from '../internals' // eslint-disable-line
+
+import * as decoding from 'lib0/decoding.js'
+import * as encoding from 'lib0/encoding.js'
+import * as error from 'lib0/error.js'
+
+export class ID {
+  /**
+   * @param {number} client client id
+   * @param {number} clock unique per client id, continuous number
+   */
+  constructor (client, clock) {
+    /**
+     * Client id
+     * @type {number}
+     */
+    this.client = client
+    /**
+     * unique per client id, continuous number
+     * @type {number}
+     */
+    this.clock = clock
+  }
+}
+
+/**
+ * @param {ID | null} a
+ * @param {ID | null} b
+ * @return {boolean}
+ *
+ * @function
+ */
+export const compareIDs = (a, b) => a === b || (a !== null && b !== null && a.client === b.client && a.clock === b.clock)
+
+/**
+ * @param {number} client
+ * @param {number} clock
+ *
+ * @private
+ * @function
+ */
+export const createID = (client, clock) => new ID(client, clock)
+
+/**
+ * @param {encoding.Encoder} encoder
+ * @param {ID} id
+ *
+ * @private
+ * @function
+ */
+export const writeID = (encoder, id) => {
+  encoding.writeVarUint(encoder, id.client)
+  encoding.writeVarUint(encoder, id.clock)
+}
+
+/**
+ * Read ID.
+ * * If first varUint read is 0xFFFFFF a RootID is returned.
+ * * Otherwise an ID is returned
+ *
+ * @param {decoding.Decoder} decoder
+ * @return {ID}
+ *
+ * @private
+ * @function
+ */
+export const readID = decoder =>
+  createID(decoding.readVarUint(decoder), decoding.readVarUint(decoder))
+
+/**
+ * The top types are mapped from y.share.get(keyname) => type.
+ * `type` does not store any information about the `keyname`.
+ * This function finds the correct `keyname` for `type` and throws otherwise.
+ *
+ * @param {AbstractType<any>} type
+ * @return {string}
+ *
+ * @private
+ * @function
+ */
+export const findRootTypeKey = type => {
+  // @ts-ignore _y must be defined, otherwise unexpected case
+  for (let [key, value] of type.doc.share) {
+    if (value === type) {
+      return key
+    }
+  }
+  throw error.unexpectedCase()
+}
--- a/src/utils/RelativePosition.js
+++ b/src/utils/RelativePosition.js
@@ -0,0 +1,273 @@
+
+import {
+  getItem,
+  getItemType,
+  createID,
+  writeID,
+  readID,
+  compareIDs,
+  getState,
+  findRootTypeKey,
+  AbstractItem,
+  ItemType,
+  ID, StructStore, Doc, AbstractType // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+import * as error from 'lib0/error.js'
+
+/**
+ * A relative position is based on the Yjs model and is not affected by document changes.
+ * E.g. If you place a relative position before a certain character, it will always point to this character.
+ * If you place a relative position at the end of a type, it will always point to the end of the type.
+ *
+ * A numeric position is often unsuited for user selections, because it does not change when content is inserted
+ * before or after.
+ *
+ * ```Insert(0, 'x')('a|bc') = 'xa|bc'``` Where | is the relative position.
+ *
+ * One of the properties must be defined.
+ *
+ * @example
+ *   // Current cursor position is at position 10
+ *   const relativePosition = createRelativePositionFromIndex(yText, 10)
+ *   // modify yText
+ *   yText.insert(0, 'abc')
+ *   yText.delete(3, 10)
+ *   // Compute the cursor position
+ *   const absolutePosition = createAbsolutePositionFromRelativePosition(y, relativePosition)
+ *   absolutePosition.type === yText // => true
+ *   console.log('cursor location is ' + absolutePosition.index) // => cursor location is 3
+ *
+ */
+export class RelativePosition {
+  /**
+   * @param {ID|null} type
+   * @param {string|null} tname
+   * @param {ID|null} item
+   */
+  constructor (type, tname, item) {
+    /**
+     * @type {ID|null}
+     */
+    this.type = type
+    /**
+     * @type {string|null}
+     */
+    this.tname = tname
+    /**
+     * @type {ID | null}
+     */
+    this.item = item
+  }
+}
+
+/**
+ * @param {Object} json
+ * @return {RelativePosition}
+ *
+ * @function
+ */
+export const createRelativePositionFromJSON = json => new RelativePosition(json.type == null ? null : createID(json.type.client, json.type.clock), json.tname || null, json.item == null ? null : createID(json.item.client, json.item.clock))
+
+export class AbsolutePosition {
+  /**
+   * @param {AbstractType<any>} type
+   * @param {number} index
+   */
+  constructor (type, index) {
+    /**
+     * @type {AbstractType<any>}
+     */
+    this.type = type
+    /**
+     * @type {number}
+     */
+    this.index = index
+  }
+}
+
+/**
+ * @param {AbstractType<any>} type
+ * @param {number} index
+ *
+ * @function
+ */
+export const createAbsolutePosition = (type, index) => new AbsolutePosition(type, index)
+
+/**
+ * @param {AbstractType<any>} type
+ * @param {ID|null} item
+ *
+ * @function
+ */
+export const createRelativePosition = (type, item) => {
+  let typeid = null
+  let tname = null
+  if (type._item === null) {
+    tname = findRootTypeKey(type)
+  } else {
+    typeid = type._item.id
+  }
+  return new RelativePosition(typeid, tname, item)
+}
+
+/**
+ * Create a relativePosition based on a absolute position.
+ *
+ * @param {AbstractType<any>} type The base type (e.g. YText or YArray).
+ * @param {number} index The absolute position.
+ * @return {RelativePosition}
+ *
+ * @function
+ */
+export const createRelativePositionFromTypeIndex = (type, index) => {
+  let t = type._start
+  while (t !== null) {
+    if (!t.deleted && t.countable) {
+      if (t.length > index) {
+        // case 1: found position somewhere in the linked list
+        return createRelativePosition(type, createID(t.id.client, t.id.clock + index))
+      }
+      index -= t.length
+    }
+    t = t.right
+  }
+  return createRelativePosition(type, null)
+}
+
+/**
+ * @param {encoding.Encoder} encoder
+ * @param {RelativePosition} rpos
+ *
+ * @function
+ */
+export const writeRelativePosition = (encoder, rpos) => {
+  const { type, tname, item } = rpos
+  if (item !== null) {
+    encoding.writeVarUint(encoder, 0)
+    writeID(encoder, item)
+  } else if (tname !== null) {
+    // case 2: found position at the end of the list and type is stored in y.share
+    encoding.writeUint8(encoder, 1)
+    encoding.writeVarString(encoder, tname)
+  } else if (type !== null) {
+    // case 3: found position at the end of the list and type is attached to an item
+    encoding.writeUint8(encoder, 2)
+    writeID(encoder, type)
+  } else {
+    throw error.unexpectedCase()
+  }
+  return encoder
+}
+
+/**
+ * @param {RelativePosition} rpos
+ * @return {Uint8Array}
+ */
+export const encodeRelativePosition = rpos => {
+  const encoder = encoding.createEncoder()
+  writeRelativePosition(encoder, rpos)
+  return encoding.toUint8Array(encoder)
+}
+
+/**
+ * @param {decoding.Decoder} decoder
+ * @return {RelativePosition|null}
+ *
+ * @function
+ */
+export const readRelativePosition = decoder => {
+  let type = null
+  let tname = null
+  let itemID = null
+  switch (decoding.readVarUint(decoder)) {
+    case 0:
+      // case 1: found position somewhere in the linked list
+      itemID = readID(decoder)
+      break
+    case 1:
+      // case 2: found position at the end of the list and type is stored in y.share
+      tname = decoding.readVarString(decoder)
+      break
+    case 2: {
+      // case 3: found position at the end of the list and type is attached to an item
+      type = readID(decoder)
+    }
+  }
+  return new RelativePosition(type, tname, itemID)
+}
+
+/**
+ * @param {Uint8Array} uint8Array
+ * @return {RelativePosition|null}
+ */
+export const decodeRelativePosition = uint8Array => readRelativePosition(decoding.createDecoder(uint8Array))
+
+/**
+ * @param {RelativePosition} rpos
+ * @param {Doc} doc
+ * @return {AbsolutePosition|null}
+ *
+ * @function
+ */
+export const createAbsolutePositionFromRelativePosition = (rpos, doc) => {
+  const store = doc.store
+  const rightID = rpos.item
+  const typeID = rpos.type
+  const tname = rpos.tname
+  let type = null
+  let index = 0
+  if (rightID !== null) {
+    if (getState(store, rightID.client) <= rightID.clock) {
+      return null
+    }
+    const right = getItem(store, rightID)
+    if (!(right instanceof AbstractItem)) {
+      return null
+    }
+    index = right.deleted || !right.countable ? 0 : rightID.clock - right.id.clock
+    let n = right.left
+    while (n !== null) {
+      if (!n.deleted && n.countable) {
+        index += n.length
+      }
+      n = n.left
+    }
+    type = right.parent
+  } else {
+    if (tname !== null) {
+      type = doc.get(tname)
+    } else if (typeID !== null) {
+      if (getState(store, typeID.client) <= typeID.clock) {
+        // type does not exist yet
+        return null
+      }
+      const struct = getItemType(store, typeID)
+      if (struct instanceof ItemType) {
+        type = struct.type
+      } else {
+        // struct is garbage collected
+        return null
+      }
+    } else {
+      throw error.unexpectedCase()
+    }
+    index = type._length
+  }
+  if (type._item !== null && type._item.deleted) {
+    return null
+  }
+  return createAbsolutePosition(type, index)
+}
+
+/**
+ * @param {RelativePosition|null} a
+ * @param {RelativePosition|null} b
+ *
+ * @function
+ */
+export const compareRelativePositions = (a, b) => a === b || (
+  a !== null && b !== null && a.tname === b.tname && compareIDs(a.item, b.item) && compareIDs(a.type, b.type)
+)
--- a/src/utils/Snapshot.js
+++ b/src/utils/Snapshot.js
@@ -0,0 +1,42 @@
+
+import {
+  isDeleted,
+  DeleteSet, AbstractItem // eslint-disable-line
+} from '../internals.js'
+
+export class Snapshot {
+  /**
+   * @param {DeleteSet} ds
+   * @param {Map<number,number>} sm state map
+   */
+  constructor (ds, sm) {
+    /**
+     * @type {DeleteSet}
+     * @private
+     */
+    this.ds = ds
+    /**
+     * State Map
+     * @type {Map<number,number>}
+     * @private
+     */
+    this.sm = sm
+  }
+}
+
+/**
+ * @param {DeleteSet} ds
+ * @param {Map<number,number>} sm
+ */
+export const createSnapshot = (ds, sm) => new Snapshot(ds, sm)
+
+/**
+ * @param {AbstractItem} item
+ * @param {Snapshot|undefined} snapshot
+ *
+ * @protected
+ * @function
+ */
+export const isVisible = (item, snapshot) => snapshot === undefined ? !item.deleted : (
+  snapshot.sm.has(item.id.client) && (snapshot.sm.get(item.id.client) || 0) > item.id.clock && !isDeleted(snapshot.ds, item.id)
+)
--- a/src/utils/StructStore.js
+++ b/src/utils/StructStore.js
@@ -0,0 +1,263 @@
+
+import {
+  GC,
+  Transaction, AbstractStructRef, ID, ItemType, AbstractItem, AbstractStruct // eslint-disable-line
+} from '../internals.js'
+
+import * as math from 'lib0/math.js'
+import * as error from 'lib0/error.js'
+import * as decoding from 'lib0/decoding.js' // eslint-disable-line
+
+export class StructStore {
+  constructor () {
+    /**
+     * @type {Map<number,Array<AbstractStruct>>}
+     * @private
+     */
+    this.clients = new Map()
+    /**
+     * Store incompleted struct reads here
+     * `i` denotes to the next read operation
+     * We could shift the array of refs instead, but shift is incredible
+     * slow in Chrome for arrays with more than 100k elements
+     * @see tryResumePendingStructRefs
+     * @type {Map<number,{i:number,refs:Array<AbstractStructRef>}>}
+     * @private
+     */
+    this.pendingClientsStructRefs = new Map()
+    /**
+     * Stack of pending structs waiting for struct dependencies
+     * Maximum length of stack is structReaders.size
+     * @type {Array<AbstractStructRef>}
+     * @private
+     */
+    this.pendingStack = []
+    /**
+     * @type {Array<decoding.Decoder>}
+     * @private
+     */
+    this.pendingDeleteReaders = []
+  }
+}
+
+/**
+ * Return the states as a Map<client,clock>.
+ * Note that clock refers to the next expected clock id.
+ *
+ * @param {StructStore} store
+ * @return {Map<number,number>}
+ *
+ * @public
+ * @function
+ */
+export const getStateVector = store => {
+  const sm = new Map()
+  store.clients.forEach((structs, client) => {
+    const struct = structs[structs.length - 1]
+    sm.set(client, struct.id.clock + struct.length)
+  })
+  return sm
+}
+
+/**
+ * @param {StructStore} store
+ * @param {number} client
+ * @return {number}
+ *
+ * @public
+ * @function
+ */
+export const getState = (store, client) => {
+  const structs = store.clients.get(client)
+  if (structs === undefined) {
+    return 0
+  }
+  const lastStruct = structs[structs.length - 1]
+  return lastStruct.id.clock + lastStruct.length
+}
+
+/**
+ * @param {StructStore} store
+ *
+ * @private
+ * @function
+ */
+export const integretyCheck = store => {
+  store.clients.forEach(structs => {
+    for (let i = 1; i < structs.length; i++) {
+      const l = structs[i - 1]
+      const r = structs[i]
+      if (l.id.clock + l.length !== r.id.clock) {
+        throw new Error('StructStore failed integrety check')
+      }
+    }
+  })
+}
+
+/**
+ * @param {StructStore} store
+ * @param {AbstractStruct} struct
+ *
+ * @private
+ * @function
+ */
+export const addStruct = (store, struct) => {
+  let structs = store.clients.get(struct.id.client)
+  if (structs === undefined) {
+    structs = []
+    store.clients.set(struct.id.client, structs)
+  } else {
+    const lastStruct = structs[structs.length - 1]
+    if (lastStruct.id.clock + lastStruct.length !== struct.id.clock) {
+      throw error.unexpectedCase()
+    }
+  }
+  structs.push(struct)
+}
+
+/**
+ * Perform a binary search on a sorted array
+ * @param {Array<any>} structs
+ * @param {number} clock
+ * @return {number}
+ *
+ * @private
+ * @function
+ */
+export const findIndexSS = (structs, clock) => {
+  let left = 0
+  let right = structs.length - 1
+  while (left <= right) {
+    const midindex = math.floor((left + right) / 2)
+    const mid = structs[midindex]
+    const midclock = mid.id.clock
+    if (midclock <= clock) {
+      if (clock < midclock + mid.length) {
+        return midindex
+      }
+      left = midindex + 1
+    } else {
+      right = midindex - 1
+    }
+  }
+  // Always check state before looking for a struct in StructStore
+  // Therefore the case of not finding a struct is unexpected
+  throw error.unexpectedCase()
+}
+
+/**
+ * Expects that id is actually in store. This function throws or is an infinite loop otherwise.
+ *
+ * @param {StructStore} store
+ * @param {ID} id
+ * @return {AbstractStruct}
+ *
+ * @private
+ * @function
+ */
+export const find = (store, id) => {
+  /**
+   * @type {Array<AbstractStruct>}
+   */
+  // @ts-ignore
+  const structs = store.clients.get(id.client)
+  return structs[findIndexSS(structs, id.clock)]
+}
+
+/**
+ * Expects that id is actually in store. This function throws or is an infinite loop otherwise.
+ *
+ * @param {StructStore} store
+ * @param {ID} id
+ * @return {AbstractItem}
+ *
+ * @private
+ * @function
+ */
+// @ts-ignore
+export const getItem = (store, id) => find(store, id)
+
+/**
+ * Expects that id is actually in store. This function throws or is an infinite loop otherwise.
+ *
+ * @param {StructStore} store
+ * @param {ID} id
+ * @return {ItemType}
+ *
+ * @private
+ * @function
+ */
+// @ts-ignore
+export const getItemType = (store, id) => find(store, id)
+
+/**
+ * Expects that id is actually in store. This function throws or is an infinite loop otherwise.
+ *
+ * @param {Transaction} transaction
+ * @param {StructStore} store
+ * @param {ID} id
+ * @return {AbstractItem}
+ *
+ * @private
+ * @function
+ */
+export const getItemCleanStart = (transaction, store, id) => {
+  /**
+   * @type {Array<AbstractItem>}
+   */
+  // @ts-ignore
+  const structs = store.clients.get(id.client)
+  const index = findIndexSS(structs, id.clock)
+  /**
+   * @type {AbstractItem}
+   */
+  let struct = structs[index]
+  if (struct.id.clock < id.clock && struct.constructor !== GC) {
+    struct = struct.splitAt(transaction, id.clock - struct.id.clock)
+    structs.splice(index + 1, 0, struct)
+  }
+  return struct
+}
+
+/**
+ * Expects that id is actually in store. This function throws or is an infinite loop otherwise.
+ *
+ * @param {Transaction} transaction
+ * @param {StructStore} store
+ * @param {ID} id
+ * @return {AbstractItem}
+ *
+ * @private
+ * @function
+ */
+export const getItemCleanEnd = (transaction, store, id) => {
+  /**
+   * @type {Array<AbstractItem>}
+   */
+  // @ts-ignore
+  const structs = store.clients.get(id.client)
+  const index = findIndexSS(structs, id.clock)
+  const struct = structs[index]
+  if (id.clock !== struct.id.clock + struct.length - 1 && struct.constructor !== GC) {
+    structs.splice(index + 1, 0, struct.splitAt(transaction, id.clock - struct.id.clock + 1))
+  }
+  return struct
+}
+
+/**
+ * Replace `item` with `newitem` in store
+ * @param {StructStore} store
+ * @param {AbstractStruct} struct
+ * @param {AbstractStruct} newStruct
+ *
+ * @private
+ * @function
+ */
+export const replaceStruct = (store, struct, newStruct) => {
+  /**
+   * @type {Array<AbstractStruct>}
+   */
+  // @ts-ignore
+  const structs = store.clients.get(struct.id.client)
+  structs[findIndexSS(structs, struct.id.clock)] = newStruct
+}
--- a/src/utils/Transaction.js
+++ b/src/utils/Transaction.js
@@ -0,0 +1,283 @@
+
+import {
+  getState,
+  createID,
+  writeStructsFromTransaction,
+  writeDeleteSet,
+  DeleteSet,
+  sortAndMergeDeleteSet,
+  getStateVector,
+  findIndexSS,
+  callEventHandlerListeners,
+  AbstractItem,
+  ID, AbstractType, AbstractStruct, YEvent, Doc // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as map from 'lib0/map.js'
+import * as math from 'lib0/math.js'
+
+/**
+ * A transaction is created for every change on the Yjs model. It is possible
+ * to bundle changes on the Yjs model in a single transaction to
+ * minimize the number on messages sent and the number of observer calls.
+ * If possible the user of this library should bundle as many changes as
+ * possible. Here is an example to illustrate the advantages of bundling:
+ *
+ * @example
+ * const map = y.define('map', YMap)
+ * // Log content when change is triggered
+ * map.observe(() => {
+ *   console.log('change triggered')
+ * })
+ * // Each change on the map type triggers a log message:
+ * map.set('a', 0) // => "change triggered"
+ * map.set('b', 0) // => "change triggered"
+ * // When put in a transaction, it will trigger the log after the transaction:
+ * y.transact(() => {
+ *   map.set('a', 1)
+ *   map.set('b', 1)
+ * }) // => "change triggered"
+ *
+ * @public
+ */
+export class Transaction {
+  /**
+   * @param {Doc} doc
+   * @param {any} origin
+   */
+  constructor (doc, origin) {
+    /**
+     * The Yjs instance.
+     * @type {Doc}
+     */
+    this.doc = doc
+    /**
+     * Describes the set of deleted items by ids
+     * @type {DeleteSet}
+     */
+    this.deleteSet = new DeleteSet()
+    /**
+     * Holds the state before the transaction started.
+     * @type {Map<Number,Number>}
+     */
+    this.beforeState = getStateVector(doc.store)
+    /**
+     * Holds the state after the transaction.
+     * @type {Map<Number,Number>}
+     */
+    this.afterState = new Map()
+    /**
+     * All types that were directly modified (property added or child
+     * inserted/deleted). New types are not included in this Set.
+     * Maps from type to parentSubs (`item._parentSub = null` for YArray)
+     * @type {Map<AbstractType<YEvent>,Set<String|null>>}
+     */
+    this.changed = new Map()
+    /**
+     * Stores the events for the types that observe also child elements.
+     * It is mainly used by `observeDeep`.
+     * @type {Map<AbstractType<YEvent>,Array<YEvent>>}
+     */
+    this.changedParentTypes = new Map()
+    /**
+     * @type {Set<ID>}
+     * @private
+     */
+    this._mergeStructs = new Set()
+    /**
+     * @type {any}
+     */
+    this.origin = origin
+  }
+}
+
+/**
+ * @param {Transaction} transaction
+ */
+export const computeUpdateMessageFromTransaction = transaction => {
+  if (transaction.deleteSet.clients.size === 0 && !map.any(transaction.afterState, (clock, client) => transaction.beforeState.get(client) !== clock)) {
+    return null
+  }
+  const encoder = encoding.createEncoder()
+  sortAndMergeDeleteSet(transaction.deleteSet)
+  writeStructsFromTransaction(encoder, transaction)
+  writeDeleteSet(encoder, transaction.deleteSet)
+  return encoder
+}
+
+/**
+ * @param {Transaction} transaction
+ *
+ * @private
+ * @function
+ */
+export const nextID = transaction => {
+  const y = transaction.doc
+  return createID(y.clientID, getState(y.store, y.clientID))
+}
+
+/**
+ * Implements the functionality of `y.transact(()=>{..})`
+ *
+ * @param {Doc} doc
+ * @param {function(Transaction):void} f
+ * @param {any} [origin]
+ *
+ * @private
+ * @function
+ */
+export const transact = (doc, f, origin = null) => {
+  const transactionCleanups = doc._transactionCleanups
+  let initialCall = false
+  if (doc._transaction === null) {
+    initialCall = true
+    doc._transaction = new Transaction(doc, origin)
+    transactionCleanups.push(doc._transaction)
+    doc.emit('beforeTransaction', [doc._transaction, doc])
+  }
+  try {
+    f(doc._transaction)
+  } finally {
+    if (initialCall && transactionCleanups[0] === doc._transaction) {
+      // The first transaction ended, now process observer calls.
+      // Observer call may create new transactions for which we need to call the observers and do cleanup.
+      // We don't want to nest these calls, so we execute these calls one after another
+      for (let i = 0; i < transactionCleanups.length; i++) {
+        const transaction = transactionCleanups[i]
+        const store = transaction.doc.store
+        const ds = transaction.deleteSet
+        sortAndMergeDeleteSet(ds)
+        transaction.afterState = getStateVector(transaction.doc.store)
+        doc._transaction = null
+        doc.emit('beforeObserverCalls', [transaction, doc])
+        // emit change events on changed types
+        transaction.changed.forEach((subs, itemtype) => {
+          itemtype._callObserver(transaction, subs)
+        })
+        transaction.changedParentTypes.forEach((events, type) => {
+          events = events
+            .filter(event =>
+              event.target._item === null || !event.target._item.deleted
+            )
+          events
+            .forEach(event => {
+              event.currentTarget = type
+            })
+          // we don't need to check for events.length
+          // because we know it has at least one element
+          callEventHandlerListeners(type._dEH, events, transaction)
+        })
+        doc.emit('afterTransaction', [transaction, doc])
+        /**
+         * @param {Array<AbstractStruct>} structs
+         * @param {number} pos
+         */
+        const tryToMergeWithLeft = (structs, pos) => {
+          const left = structs[pos - 1]
+          const right = structs[pos]
+          if (left.deleted === right.deleted && left.constructor === right.constructor) {
+            if (left.mergeWith(right)) {
+              structs.splice(pos, 1)
+              if (right instanceof AbstractItem && right.parentSub !== null && right.parent._map.get(right.parentSub) === right) {
+                // @ts-ignore we already did a constructor check above
+                right.parent._map.set(right.parentSub, left)
+              }
+            }
+          }
+        }
+        // replace deleted items with ItemDeleted / GC
+        for (const [client, deleteItems] of ds.clients) {
+          /**
+           * @type {Array<AbstractStruct>}
+           */
+          // @ts-ignore
+          const structs = store.clients.get(client)
+          for (let di = deleteItems.length - 1; di >= 0; di--) {
+            const deleteItem = deleteItems[di]
+            const endDeleteItemClock = deleteItem.clock + deleteItem.len
+            for (
+              let si = findIndexSS(structs, deleteItem.clock), struct = structs[si];
+              si < structs.length && struct.id.clock < endDeleteItemClock;
+              struct = structs[++si]
+            ) {
+              const struct = structs[si]
+              if (deleteItem.clock + deleteItem.len <= struct.id.clock) {
+                break
+              }
+              if (struct.deleted && struct instanceof AbstractItem) {
+                struct.gc(store, false)
+              }
+            }
+          }
+        }
+        // try to merge deleted / gc'd items
+        // merge from right to left for better efficiecy and so we don't miss any merge targets
+        for (const [client, deleteItems] of ds.clients) {
+          /**
+           * @type {Array<AbstractStruct>}
+           */
+          // @ts-ignore
+          const structs = store.clients.get(client)
+          for (let di = deleteItems.length - 1; di >= 0; di--) {
+            const deleteItem = deleteItems[di]
+            // start with merging the item next to the last deleted item
+            const mostRightIndexToCheck = math.min(structs.length - 1, 1 + findIndexSS(structs, deleteItem.clock + deleteItem.len - 1))
+            for (
+              let si = mostRightIndexToCheck, struct = structs[si];
+              si > 0 && struct.id.clock >= deleteItem.clock;
+              struct = structs[--si]
+            ) {
+              tryToMergeWithLeft(structs, si)
+            }
+          }
+        }
+
+        // on all affected store.clients props, try to merge
+        for (const [client, clock] of transaction.afterState) {
+          const beforeClock = transaction.beforeState.get(client) || 0
+          if (beforeClock !== clock) {
+            /**
+             * @type {Array<AbstractStruct>}
+             */
+            // @ts-ignore
+            const structs = store.clients.get(client)
+            // we iterate from right to left so we can safely remove entries
+            const firstChangePos = math.max(findIndexSS(structs, beforeClock), 1)
+            for (let i = structs.length - 1; i >= firstChangePos; i--) {
+              tryToMergeWithLeft(structs, i)
+            }
+          }
+        }
+        // try to merge mergeStructs
+        // @todo: it makes more sense to transform mergeStructs to a DS, sort it, and merge from right to left
+        //        but at the moment DS does not handle duplicates
+        for (const mid of transaction._mergeStructs) {
+          const client = mid.client
+          const clock = mid.clock
+          /**
+           * @type {Array<AbstractStruct>}
+           */
+          // @ts-ignore
+          const structs = store.clients.get(client)
+          const replacedStructPos = findIndexSS(structs, clock)
+          if (replacedStructPos + 1 < structs.length) {
+            tryToMergeWithLeft(structs, replacedStructPos + 1)
+          }
+          if (replacedStructPos > 0) {
+            tryToMergeWithLeft(structs, replacedStructPos)
+          }
+        }
+        // @todo Merge all the transactions into one and provide send the data as a single update message
+        doc.emit('afterTransactionCleanup', [transaction, doc])
+        if (doc._observers.has('update')) {
+          const updateMessage = computeUpdateMessageFromTransaction(transaction)
+          if (updateMessage !== null) {
+            doc.emit('update', [encoding.toUint8Array(updateMessage), transaction.origin, doc])
+          }
+        }
+      }
+      doc._transactionCleanups = []
+    }
+  }
+}
--- a/src/utils/UndoManager.js
+++ b/src/utils/UndoManager.js
@@ -0,0 +1,203 @@
+// @ts-nocheck
+
+import {
+  isParentOf,
+  createID,
+  transact
+} from '../internals.js'
+
+/**
+ * @private
+ */
+class ReverseOperation {
+  constructor (y, transaction, bindingInfos) {
+    this.created = new Date()
+    const beforeState = transaction.beforeState
+    if (beforeState.has(y.userID)) {
+      this.toState = createID(y.userID, y.ss.getState(y.userID) - 1)
+      this.fromState = createID(y.userID, beforeState.get(y.userID))
+    } else {
+      this.toState = null
+      this.fromState = null
+    }
+    this.deletedStructs = new Set()
+    transaction.deletedStructs.forEach(struct => {
+      this.deletedStructs.add({
+        from: struct._id,
+        len: struct._length
+      })
+    })
+    /**
+     * Maps from binding to binding information (e.g. cursor information)
+     */
+    this.bindingInfos = bindingInfos
+  }
+}
+
+/**
+ * @private
+ * @function
+ */
+function applyReverseOperation (y, scope, reverseBuffer) {
+  let performedUndo = false
+  let undoOp = null
+  transact(y, () => {
+    while (!performedUndo && reverseBuffer.length > 0) {
+      undoOp = reverseBuffer.pop()
+      // make sure that it is possible to iterate {from}-{to}
+      if (undoOp.fromState !== null) {
+        y.os.getItemCleanStart(undoOp.fromState)
+        y.os.getItemCleanEnd(undoOp.toState)
+        y.os.iterate(undoOp.fromState, undoOp.toState, op => {
+          while (op._deleted && op._redone !== null) {
+            op = op._redone
+          }
+          if (op._deleted === false && isParentOf(scope, op)) {
+            performedUndo = true
+            op._delete(y)
+          }
+        })
+      }
+      const redoitems = new Set()
+      for (let del of undoOp.deletedStructs) {
+        const fromState = del.from
+        const toState = createID(fromState.user, fromState.clock + del.len - 1)
+        y.os.getItemCleanStart(fromState)
+        y.os.getItemCleanEnd(toState)
+        y.os.iterate(fromState, toState, op => {
+          if (
+            isParentOf(scope, op) &&
+            op._parent !== y &&
+            (
+              op._id.user !== y.userID ||
+              undoOp.fromState === null ||
+              op._id.clock < undoOp.fromState.clock ||
+              op._id.clock > undoOp.toState.clock
+            )
+          ) {
+            redoitems.add(op)
+          }
+        })
+      }
+      redoitems.forEach(op => {
+        const opUndone = op._redo(y, redoitems)
+        performedUndo = performedUndo || opUndone
+      })
+    }
+  })
+  if (performedUndo && undoOp !== null) {
+    // should be performed after the undo transaction
+    undoOp.bindingInfos.forEach((info, binding) => {
+      binding._restoreUndoStackInfo(info)
+    })
+  }
+  return performedUndo
+}
+
+/**
+ * Saves a history of locally applied operations. The UndoManager handles the
+ * undoing and redoing of locally created changes.
+ *
+ * @private
+ * @function
+ */
+export class UndoManager {
+  /**
+   * @param {YType} scope The scope on which to listen for changes.
+   * @param {Object} options Optionally provided configuration.
+   */
+  constructor (scope, options = {}) {
+    this.options = options
+    this._bindings = new Set(options.bindings)
+    options.captureTimeout = options.captureTimeout == null ? 500 : options.captureTimeout
+    this._undoBuffer = []
+    this._redoBuffer = []
+    this._scope = scope
+    this._undoing = false
+    this._redoing = false
+    this._lastTransactionWasUndo = false
+    const doc = scope.doc
+    this.y = doc
+    let bindingInfos
+    doc.on('beforeTransaction', (y, transaction, remote) => {
+      if (!remote) {
+        // Store binding information before transaction is executed
+        // By restoring the binding information, we can make sure that the state
+        // before the transaction can be recovered
+        bindingInfos = new Map()
+        this._bindings.forEach(binding => {
+          bindingInfos.set(binding, binding._getUndoStackInfo())
+        })
+      }
+    })
+    doc.on('afterTransaction', (y, transaction, remote) => {
+      if (!remote && transaction.changedParentTypes.has(scope)) {
+        let reverseOperation = new ReverseOperation(y, transaction, bindingInfos)
+        if (!this._undoing) {
+          let lastUndoOp = this._undoBuffer.length > 0 ? this._undoBuffer[this._undoBuffer.length - 1] : null
+          if (
+            this._redoing === false &&
+            this._lastTransactionWasUndo === false &&
+            lastUndoOp !== null &&
+            ((options.captureTimeout < 0) || (reverseOperation.created.getTime() - lastUndoOp.created.getTime()) <= options.captureTimeout)
+          ) {
+            lastUndoOp.created = reverseOperation.created
+            if (reverseOperation.toState !== null) {
+              lastUndoOp.toState = reverseOperation.toState
+              if (lastUndoOp.fromState === null) {
+                lastUndoOp.fromState = reverseOperation.fromState
+              }
+            }
+            reverseOperation.deletedStructs.forEach(lastUndoOp.deletedStructs.add, lastUndoOp.deletedStructs)
+          } else {
+            this._lastTransactionWasUndo = false
+            this._undoBuffer.push(reverseOperation)
+          }
+          if (!this._redoing) {
+            this._redoBuffer = []
+          }
+        } else {
+          this._lastTransactionWasUndo = true
+          this._redoBuffer.push(reverseOperation)
+        }
+      }
+    })
+  }
+
+  /**
+   * Enforce that the next change is created as a separate item in the undo stack
+   *
+   * @private
+   * @function
+   */
+  flushChanges () {
+    this._lastTransactionWasUndo = true
+  }
+
+  /**
+   * Undo the last locally created change.
+   *
+   * @private
+   * @function
+   */
+  undo () {
+    this._undoing = true
+    const performedUndo = applyReverseOperation(this.y, this._scope, this._undoBuffer)
+    this._undoing = false
+    return performedUndo
+  }
+
+  /**
+   * Redo the last locally created change.
+   *
+   * @private
+   * @function
+   */
+  redo () {
+    this._redoing = true
+    const performedRedo = applyReverseOperation(this.y, this._scope, this._redoBuffer)
+    this._redoing = false
+    return performedRedo
+  }
+}
+}
--- a/src/utils/YEvent.js
+++ b/src/utils/YEvent.js
@@ -0,0 +1,108 @@
+
+import {
+  isDeleted,
+  AbstractType, Transaction, AbstractStruct // eslint-disable-line
+} from '../internals.js'
+
+/**
+ * YEvent describes the changes on a YType.
+ */
+export class YEvent {
+  /**
+   * @param {AbstractType<any>} target The changed type.
+   * @param {Transaction} transaction
+   */
+  constructor (target, transaction) {
+    /**
+     * The type on which this event was created on.
+     * @type {AbstractType<any>}
+     */
+    this.target = target
+    /**
+     * The current target on which the observe callback is called.
+     * @type {AbstractType<any>}
+     */
+    this.currentTarget = target
+    /**
+     * The transaction that triggered this event.
+     * @type {Transaction}
+     */
+    this.transaction = transaction
+  }
+
+  /**
+   * Computes the path from `y` to the changed type.
+   *
+   * The following property holds:
+   * @example
+   *   let type = y
+   *   event.path.forEach(dir => {
+   *     type = type.get(dir)
+   *   })
+   *   type === event.target // => true
+   */
+  get path () {
+    // @ts-ignore _item is defined because target is integrated
+    return getPathTo(this.currentTarget, this.target)
+  }
+
+  /**
+   * Check if a struct is deleted by this event.
+   *
+   * @param {AbstractStruct} struct
+   * @return {boolean}
+   */
+  deletes (struct) {
+    return isDeleted(this.transaction.deleteSet, struct.id)
+  }
+
+  /**
+   * Check if a struct is added by this event.
+   *
+   * @param {AbstractStruct} struct
+   * @return {boolean}
+   */
+  adds (struct) {
+    return struct.id.clock >= (this.transaction.beforeState.get(struct.id.client) || 0)
+  }
+}
+
+/**
+ * Compute the path from this type to the specified target.
+ *
+ * @example
+ *   // `child` should be accessible via `type.get(path[0]).get(path[1])..`
+ *   const path = type.getPathTo(child)
+ *   // assuming `type instanceof YArray`
+ *   console.log(path) // might look like => [2, 'key1']
+ *   child === type.get(path[0]).get(path[1])
+ *
+ * @param {AbstractType<any>} parent
+ * @param {AbstractType<any>} child target
+ * @return {Array<string|number>} Path to the target
+ *
+ * @private
+ * @function
+ */
+const getPathTo = (parent, child) => {
+  const path = []
+  while (child._item !== null && child !== parent) {
+    if (child._item.parentSub !== null) {
+      // parent is map-ish
+      path.unshift(child._item.parentSub)
+    } else {
+      // parent is array-ish
+      let i = 0
+      let c = child._item.parent._start
+      while (c !== child._item && c !== null) {
+        if (!c.deleted) {
+          i++
+        }
+        c = c.right
+      }
+      path.unshift(i)
+    }
+    child = child._item.parent
+  }
+  return path
+}
--- a/src/utils/encoding.js
+++ b/src/utils/encoding.js
@@ -0,0 +1,424 @@
+
+/**
+ * @module encoding
+ */
+
+import {
+  findIndexSS,
+  GCRef,
+  ItemBinaryRef,
+  ItemDeletedRef,
+  ItemEmbedRef,
+  ItemFormatRef,
+  ItemJSONRef,
+  ItemStringRef,
+  ItemTypeRef,
+  writeID,
+  createID,
+  readID,
+  getState,
+  getStateVector,
+  readDeleteSet,
+  writeDeleteSet,
+  createDeleteSetFromStructStore,
+  Doc, Transaction, AbstractStruct, AbstractStructRef, StructStore, ID // eslint-disable-line
+} from '../internals.js'
+
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+import * as binary from 'lib0/binary.js'
+
+/**
+ * @private
+ */
+export const structRefs = [
+  GCRef,
+  ItemBinaryRef,
+  ItemDeletedRef,
+  ItemEmbedRef,
+  ItemFormatRef,
+  ItemJSONRef,
+  ItemStringRef,
+  ItemTypeRef
+]
+
+/**
+ * @param {encoding.Encoder} encoder
+ * @param {Array<AbstractStruct>} structs All structs by `client`
+ * @param {number} client
+ * @param {number} clock write structs starting with `ID(client,clock)`
+ *
+ * @function
+ */
+const writeStructs = (encoder, structs, client, clock) => {
+  // write first id
+  const startNewStructs = findIndexSS(structs, clock)
+  // write # encoded structs
+  encoding.writeVarUint(encoder, structs.length - startNewStructs)
+  writeID(encoder, createID(client, clock))
+  const firstStruct = structs[startNewStructs]
+  // write first struct with an offset
+  firstStruct.write(encoder, clock - firstStruct.id.clock, 0)
+  for (let i = startNewStructs + 1; i < structs.length; i++) {
+    structs[i].write(encoder, 0, 0)
+  }
+}
+
+/**
+ * @param {decoding.Decoder} decoder
+ * @param {number} numOfStructs
+ * @param {ID} nextID
+ * @return {Array<AbstractStructRef>}
+ *
+ * @private
+ * @function
+ */
+const readStructRefs = (decoder, numOfStructs, nextID) => {
+  /**
+   * @type {Array<AbstractStructRef>}
+   */
+  const refs = []
+  for (let i = 0; i < numOfStructs; i++) {
+    const info = decoding.readUint8(decoder)
+    const ref = new structRefs[binary.BITS5 & info](decoder, nextID, info)
+    nextID = createID(nextID.client, nextID.clock + ref.length)
+    refs.push(ref)
+  }
+  return refs
+}
+
+/**
+ * @param {encoding.Encoder} encoder
+ * @param {StructStore} store
+ * @param {Map<number,number>} _sm
+ *
+ * @private
+ * @function
+ */
+export const writeClientsStructs = (encoder, store, _sm) => {
+  // we filter all valid _sm entries into sm
+  const sm = new Map()
+  _sm.forEach((clock, client) => {
+    // only write if new structs are available
+    if (getState(store, client) > clock) {
+      sm.set(client, clock)
+    }
+  })
+  getStateVector(store).forEach((clock, client) => {
+    if (!_sm.has(client)) {
+      sm.set(client, 0)
+    }
+  })
+  // write # states that were updated
+  encoding.writeVarUint(encoder, sm.size)
+  sm.forEach((clock, client) => {
+    // @ts-ignore
+    writeStructs(encoder, store.clients.get(client), client, clock)
+  })
+}
+
+/**
+ * @param {decoding.Decoder} decoder The decoder object to read data from.
+ * @return {Map<number,Array<AbstractStructRef>>}
+ *
+ * @private
+ * @function
+ */
+export const readClientsStructRefs = decoder => {
+  /**
+   * @type {Map<number,Array<AbstractStructRef>>}
+   */
+  const clientRefs = new Map()
+  const numOfStateUpdates = decoding.readVarUint(decoder)
+  for (let i = 0; i < numOfStateUpdates; i++) {
+    const numberOfStructs = decoding.readVarUint(decoder)
+    const nextID = readID(decoder)
+    const refs = readStructRefs(decoder, numberOfStructs, nextID)
+    clientRefs.set(nextID.client, refs)
+  }
+  return clientRefs
+}
+
+/**
+ * Resume computing structs generated by struct readers.
+ *
+ * While there is something to do, we integrate structs in this order
+ * 1. top element on stack, if stack is not empty
+ * 2. next element from current struct reader (if empty, use next struct reader)
+ *
+ * If struct causally depends on another struct (ref.missing), we put next reader of
+ * `ref.id.client` on top of stack.
+ *
+ * At some point we find a struct that has no causal dependencies,
+ * then we start emptying the stack.
+ *
+ * It is not possible to have circles: i.e. struct1 (from client1) depends on struct2 (from client2)
+ * depends on struct3 (from client1). Therefore the max stack size is eqaul to `structReaders.length`.
+ *
+ * This method is implemented in a way so that we can resume computation if this update
+ * causally depends on another update.
+ *
+ * @param {Transaction} transaction
+ * @param {StructStore} store
+ *
+ * @private
+ * @function
+ */
+const resumeStructIntegration = (transaction, store) => {
+  const stack = store.pendingStack
+  const clientsStructRefs = store.pendingClientsStructRefs
+  // iterate over all struct readers until we are done
+  while (stack.length !== 0 || clientsStructRefs.size !== 0) {
+    if (stack.length === 0) {
+      // take any first struct from clientsStructRefs and put it on the stack
+      const [client, structRefs] = clientsStructRefs.entries().next().value
+      stack.push(structRefs.refs[structRefs.i++])
+      if (structRefs.refs.length === structRefs.i) {
+        clientsStructRefs.delete(client)
+      }
+    }
+    const ref = stack[stack.length - 1]
+    const m = ref._missing
+    const client = ref.id.client
+    const localClock = getState(store, client)
+    const offset = ref.id.clock < localClock ? localClock - ref.id.clock : 0
+    if (ref.id.clock + offset !== localClock) {
+      // A previous message from this client is missing
+      // check if there is a pending structRef with a smaller clock and switch them
+      const structRefs = clientsStructRefs.get(client)
+      if (structRefs !== undefined) {
+        const r = structRefs.refs[structRefs.i]
+        if (r.id.clock < ref.id.clock) {
+          // put ref with smaller clock on stack instead and continue
+          structRefs.refs[structRefs.i] = ref
+          stack[stack.length - 1] = r
+          // sort the set because this approach might bring the list out of order
+          structRefs.refs = structRefs.refs.slice(structRefs.i).sort((r1, r2) => r1.id.clock - r2.id.clock)
+          structRefs.i = 0
+          continue
+        }
+      }
+      // wait until missing struct is available
+      return
+    }
+    while (m.length > 0) {
+      const missing = m[m.length - 1]
+      if (getState(store, missing.client) <= missing.clock) {
+        const client = missing.client
+        // get the struct reader that has the missing struct
+        const structRefs = clientsStructRefs.get(client)
+        if (structRefs === undefined) {
+          // This update message causally depends on another update message.
+          return
+        }
+        stack.push(structRefs.refs[structRefs.i++])
+        if (structRefs.i === structRefs.refs.length) {
+          clientsStructRefs.delete(client)
+        }
+        break
+      }
+      ref._missing.pop()
+    }
+    if (m.length === 0) {
+      if (offset < ref.length) {
+        ref.toStruct(transaction, store, offset).integrate(transaction)
+      }
+      stack.pop()
+    }
+  }
+}
+
+/**
+ * @param {Transaction} transaction
+ * @param {StructStore} store
+ *
+ * @private
+ * @function
+ */
+export const tryResumePendingDeleteReaders = (transaction, store) => {
+  const pendingReaders = store.pendingDeleteReaders
+  store.pendingDeleteReaders = []
+  for (let i = 0; i < pendingReaders.length; i++) {
+    readDeleteSet(pendingReaders[i], transaction, store)
+  }
+}
+
+/**
+ * @param {encoding.Encoder} encoder
+ * @param {Transaction} transaction
+ *
+ * @private
+ * @function
+ */
+export const writeStructsFromTransaction = (encoder, transaction) => writeClientsStructs(encoder, transaction.doc.store, transaction.beforeState)
+
+/**
+ * @param {StructStore} store
+ * @param {Map<number, Array<AbstractStructRef>>} clientsStructsRefs
+ *
+ * @private
+ * @function
+ */
+const mergeReadStructsIntoPendingReads = (store, clientsStructsRefs) => {
+  const pendingClientsStructRefs = store.pendingClientsStructRefs
+  for (const [client, structRefs] of clientsStructsRefs) {
+    const pendingStructRefs = pendingClientsStructRefs.get(client)
+    if (pendingStructRefs === undefined) {
+      pendingClientsStructRefs.set(client, { refs: structRefs, i: 0 })
+    } else {
+      // merge into existing structRefs
+      const merged = pendingStructRefs.i > 0 ? pendingStructRefs.refs.slice(pendingStructRefs.i) : pendingStructRefs.refs
+      for (let i = 0; i < structRefs.length; i++) {
+        merged.push(structRefs[i])
+      }
+      pendingStructRefs.i = 0
+      pendingStructRefs.refs = merged.sort((r1, r2) => r1.id.clock - r2.id.clock)
+    }
+  }
+}
+
+/**
+ * Read the next Item in a Decoder and fill this Item with the read data.
+ *
+ * This is called when data is received from a remote peer.
+ *
+ * @param {decoding.Decoder} decoder The decoder object to read data from.
+ * @param {Transaction} transaction
+ * @param {StructStore} store
+ *
+ * @private
+ * @function
+ */
+export const readStructs = (decoder, transaction, store) => {
+  const clientsStructRefs = readClientsStructRefs(decoder)
+  mergeReadStructsIntoPendingReads(store, clientsStructRefs)
+  resumeStructIntegration(transaction, store)
+  tryResumePendingDeleteReaders(transaction, store)
+}
+
+/**
+ * Read and apply a document update.
+ *
+ * This function has the same effect as `applyUpdate` but accepts an decoder.
+ *
+ * @param {decoding.Decoder} decoder
+ * @param {Doc} ydoc
+ * @param {any} [transactionOrigin] This will be stored on `transaction.origin` and `.on('update', (update, origin))`
+ *
+ * @function
+ */
+export const readUpdate = (decoder, ydoc, transactionOrigin) =>
+  ydoc.transact(transaction => {
+    readStructs(decoder, transaction, ydoc.store)
+    readDeleteSet(decoder, transaction, ydoc.store)
+  }, transactionOrigin)
+
+/**
+ * Apply a document update created by, for example, `y.on('update', update => ..)` or `update = encodeStateAsUpdate()`.
+ *
+ * This function has the same effect as `readUpdate` but accepts an Uint8Array instead of a Decoder.
+ *
+ * @param {Doc} ydoc
+ * @param {Uint8Array} update
+ * @param {any} [transactionOrigin] This will be stored on `transaction.origin` and `.on('update', (update, origin))`
+ *
+ * @function
+ */
+export const applyUpdate = (ydoc, update, transactionOrigin) =>
+  readUpdate(decoding.createDecoder(update), ydoc, transactionOrigin)
+
+/**
+ * Write all the document as a single update message. If you specify the state of the remote client (`targetStateVector`) it will
+ * only write the operations that are missing.
+ *
+ * @param {encoding.Encoder} encoder
+ * @param {Doc} doc
+ * @param {Map<number,number>} [targetStateVector] The state of the target that receives the update. Leave empty to write all known structs
+ *
+ * @function
+ */
+export const writeStateAsUpdate = (encoder, doc, targetStateVector = new Map()) => {
+  writeClientsStructs(encoder, doc.store, targetStateVector)
+  writeDeleteSet(encoder, createDeleteSetFromStructStore(doc.store))
+}
+
+/**
+ * Write all the document as a single update message that can be applied on the remote document. If you specify the state of the remote client (`targetState`) it will
+ * only write the operations that are missing.
+ *
+ * Use `writeStateAsUpdate` instead if you are working with lib0/encoding.js#Encoder
+ *
+ * @param {Doc} doc
+ * @param {Uint8Array} [encodedTargetStateVector] The state of the target that receives the update. Leave empty to write all known structs
+ * @return {Uint8Array}
+ *
+ * @function
+ */
+export const encodeStateAsUpdate = (doc, encodedTargetStateVector) => {
+  const encoder = encoding.createEncoder()
+  const targetStateVector = encodedTargetStateVector == null ? new Map() : decodeStateVector(encodedTargetStateVector)
+  writeStateAsUpdate(encoder, doc, targetStateVector)
+  return encoding.toUint8Array(encoder)
+}
+
+/**
+ * Read state vector from Decoder and return as Map
+ *
+ * @param {decoding.Decoder} decoder
+ * @return {Map<number,number>} Maps `client` to the number next expected `clock` from that client.
+ *
+ * @function
+ */
+export const readStateVector = decoder => {
+  const ss = new Map()
+  const ssLength = decoding.readVarUint(decoder)
+  for (let i = 0; i < ssLength; i++) {
+    const client = decoding.readVarUint(decoder)
+    const clock = decoding.readVarUint(decoder)
+    ss.set(client, clock)
+  }
+  return ss
+}
+
+/**
+ * Read decodedState and return State as Map.
+ *
+ * @param {Uint8Array} decodedState
+ * @return {Map<number,number>} Maps `client` to the number next expected `clock` from that client.
+ *
+ * @function
+ */
+export const decodeStateVector = decodedState => readStateVector(decoding.createDecoder(decodedState))
+
+/**
+ * Write State Vector to `lib0/encoding.js#Encoder`.
+ *
+ * @param {encoding.Encoder} encoder
+ * @param {Doc} doc
+ *
+ * @function
+ */
+export const writeDocumentStateVector = (encoder, doc) => {
+  encoding.writeVarUint(encoder, doc.store.clients.size)
+  doc.store.clients.forEach((structs, client) => {
+    const struct = structs[structs.length - 1]
+    const id = struct.id
+    encoding.writeVarUint(encoder, id.client)
+    encoding.writeVarUint(encoder, id.clock + struct.length)
+  })
+  return encoder
+}
+
+/**
+ * Encode State as Uint8Array.
+ *
+ * @param {Doc} doc
+ * @return {Uint8Array}
+ *
+ * @function
+ */
+export const encodeStateVector = doc => {
+  const encoder = encoding.createEncoder()
+  writeDocumentStateVector(encoder, doc)
+  return encoding.toUint8Array(encoder)
+}
--- a/src/utils/isParentOf.js
+++ b/src/utils/isParentOf.js
@@ -0,0 +1,22 @@
+
+import { AbstractType } from '../internals.js' // eslint-disable-line
+
+/**
+ * Check if `parent` is a parent of `child`.
+ *
+ * @param {AbstractType<any>} parent
+ * @param {AbstractType<any>} child
+ * @return {Boolean} Whether `parent` is a parent of `child`.
+ *
+ * @private
+ * @function
+ */
+export const isParentOf = (parent, child) => {
+  while (child._item !== null) {
+    if (child === parent) {
+      return true
+    }
+    child = child._item.parent
+  }
+  return false
+}
--- a/src/y.js
+++ b/src/y.js
@@ -1,53 +0,0 @@
-/* @flow */
-'use strict'
-
-function Y (opts) {
-  return new Promise(function (resolve) {
-    var yconfig = new YConfig(opts, function () {
-      yconfig.db.whenUserIdSet(function () {
-        resolve(yconfig)
-      })
-    })
-  })
-}
-
-class YConfig {
-  constructor (opts, callback) {
-    this.db = new Y[opts.db.name](this, opts.db)
-    this.connector = new Y[opts.connector.name](this, opts.connector)
-    this.db.requestTransaction(function * requestTransaction () {
-      // create initial Map type
-      var model = {
-        id: ['_', 0],
-        struct: 'Map',
-        type: 'Map',
-        map: {}
-      }
-      yield* this.store.tryExecute.call(this, model)
-      var root = yield* this.getType(model.id)
-      this.store.y.root = root
-      callback()
-    })
-  }
-  isConnected () {
-    return this.connector.isSynced
-  }
-  disconnect () {
-    return this.connector.disconnect()
-  }
-  reconnect () {
-    return this.connector.reconnect()
-  }
-  destroy () {
-    this.disconnect()
-    this.db.destroy()
-    this.connector = null
-    this.db = null
-  }
-}
-
-if (typeof YConcurrency_TestingMode !== 'undefined') {
-  g.Y = Y //eslint-disable-line
-  // debugger //eslint-disable-line
-}
-Y.utils = {}
--- a/test.html
+++ b/test.html
@@ -0,0 +1,9 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Testing Yjs</title>
+</head>
+<body>
+  <script type="module" src="./dist/tests.js"></script>
+</body>
+</html>
--- a/tests/encoding.tests.js
+++ b/tests/encoding.tests.js
@@ -0,0 +1,36 @@
+import * as t from 'lib0/testing.js'
+
+import {
+  structRefs,
+  structGCRefNumber,
+  structBinaryRefNumber,
+  structDeletedRefNumber,
+  structEmbedRefNumber,
+  structFormatRefNumber,
+  structJSONRefNumber,
+  structStringRefNumber,
+  structTypeRefNumber,
+  GCRef,
+  ItemBinaryRef,
+  ItemDeletedRef,
+  ItemEmbedRef,
+  ItemFormatRef,
+  ItemJSONRef,
+  ItemStringRef,
+  ItemTypeRef
+} from '../src/internals.js'
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testStructReferences = tc => {
+  t.assert(structRefs.length === 8)
+  t.assert(structRefs[structGCRefNumber] === GCRef)
+  t.assert(structRefs[structBinaryRefNumber] === ItemBinaryRef)
+  t.assert(structRefs[structDeletedRefNumber] === ItemDeletedRef)
+  t.assert(structRefs[structEmbedRefNumber] === ItemEmbedRef)
+  t.assert(structRefs[structFormatRefNumber] === ItemFormatRef)
+  t.assert(structRefs[structJSONRefNumber] === ItemJSONRef)
+  t.assert(structRefs[structStringRefNumber] === ItemStringRef)
+  t.assert(structRefs[structTypeRefNumber] === ItemTypeRef)
+}
--- a/tests/index.js
+++ b/tests/index.js
@@ -0,0 +1,22 @@
+
+import * as array from './y-array.tests.js'
+import * as map from './y-map.tests.js'
+import * as text from './y-text.tests.js'
+import * as xml from './y-xml.tests.js'
+import * as encoding from './encoding.tests.js'
+
+import { runTests } from 'lib0/testing.js'
+import { isBrowser, isNode } from 'lib0/environment.js'
+import * as log from 'lib0/logging.js'
+
+if (isBrowser) {
+  log.createVConsole(document.body)
+}
+runTests({
+  map, array, text, xml, encoding
+}).then(success => {
+  /* istanbul ignore next */
+  if (isNode) {
+    process.exit(success ? 0 : 1)
+  }
+})
--- a/tests/testHelper.js
+++ b/tests/testHelper.js
@@ -0,0 +1,392 @@
+import * as Y from '../src/index.js'
+
+import {
+  createDeleteSetFromStructStore,
+  getStateVector,
+  AbstractItem,
+  DeleteSet, StructStore, Doc // eslint-disable-line
+} from '../src/internals.js'
+
+import * as t from 'lib0/testing.js'
+import * as prng from 'lib0/prng.js'
+import * as encoding from 'lib0/encoding.js'
+import * as decoding from 'lib0/decoding.js'
+import * as syncProtocol from 'y-protocols/sync.js'
+
+/**
+ * @param {TestYInstance} y // publish message created by `y` to all other online clients
+ * @param {Uint8Array} m
+ */
+const broadcastMessage = (y, m) => {
+  if (y.tc.onlineConns.has(y)) {
+    y.tc.onlineConns.forEach(remoteYInstance => {
+      if (remoteYInstance !== y) {
+        remoteYInstance._receive(m, y)
+      }
+    })
+  }
+}
+
+export class TestYInstance extends Doc {
+  /**
+   * @param {TestConnector} testConnector
+   * @param {number} clientID
+   */
+  constructor (testConnector, clientID) {
+    super()
+    this.userID = clientID // overwriting clientID
+    /**
+     * @type {TestConnector}
+     */
+    this.tc = testConnector
+    /**
+     * @type {Map<TestYInstance, Array<Uint8Array>>}
+     */
+    this.receiving = new Map()
+    testConnector.allConns.add(this)
+    // set up observe on local model
+    this.on('update', /** @param {Uint8Array} update @param {any} origin */ (update, origin) => {
+      if (origin !== testConnector) {
+        const encoder = encoding.createEncoder()
+        syncProtocol.writeUpdate(encoder, update)
+        broadcastMessage(this, encoding.toUint8Array(encoder))
+      }
+    })
+    this.connect()
+  }
+  /**
+   * Disconnect from TestConnector.
+   */
+  disconnect () {
+    this.receiving = new Map()
+    this.tc.onlineConns.delete(this)
+  }
+  /**
+   * Append yourself to the list of known Y instances in testconnector.
+   * Also initiate sync with all clients.
+   */
+  connect () {
+    if (!this.tc.onlineConns.has(this)) {
+      this.tc.onlineConns.add(this)
+      const encoder = encoding.createEncoder()
+      syncProtocol.writeSyncStep1(encoder, this)
+      // publish SyncStep1
+      broadcastMessage(this, encoding.toUint8Array(encoder))
+      this.tc.onlineConns.forEach(remoteYInstance => {
+        if (remoteYInstance !== this) {
+          // remote instance sends instance to this instance
+          const encoder = encoding.createEncoder()
+          syncProtocol.writeSyncStep1(encoder, remoteYInstance)
+          this._receive(encoding.toUint8Array(encoder), remoteYInstance)
+        }
+      })
+    }
+  }
+  /**
+   * Receive a message from another client. This message is only appended to the list of receiving messages.
+   * TestConnector decides when this client actually reads this message.
+   *
+   * @param {Uint8Array} message
+   * @param {TestYInstance} remoteClient
+   */
+  _receive (message, remoteClient) {
+    let messages = this.receiving.get(remoteClient)
+    if (messages === undefined) {
+      messages = []
+      this.receiving.set(remoteClient, messages)
+    }
+    messages.push(message)
+  }
+}
+
+/**
+ * Keeps track of TestYInstances.
+ *
+ * The TestYInstances add/remove themselves from the list of connections maiained in this object.
+ * I think it makes sense. Deal with it.
+ */
+export class TestConnector {
+  /**
+   * @param {prng.PRNG} gen
+   */
+  constructor (gen) {
+    /**
+     * @type {Set<TestYInstance>}
+     */
+    this.allConns = new Set()
+    /**
+     * @type {Set<TestYInstance>}
+     */
+    this.onlineConns = new Set()
+    /**
+     * @type {prng.PRNG}
+     */
+    this.prng = gen
+  }
+  /**
+   * Create a new Y instance and add it to the list of connections
+   * @param {number} clientID
+   */
+  createY (clientID) {
+    return new TestYInstance(this, clientID)
+  }
+  /**
+   * Choose random connection and flush a random message from a random sender.
+   *
+   * If this function was unable to flush a message, because there are no more messages to flush, it returns false. true otherwise.
+   * @return {boolean}
+   */
+  flushRandomMessage () {
+    const gen = this.prng
+    const conns = Array.from(this.onlineConns).filter(conn => conn.receiving.size > 0)
+    if (conns.length > 0) {
+      const receiver = prng.oneOf(gen, conns)
+      const [sender, messages] = prng.oneOf(gen, Array.from(receiver.receiving))
+      const m = messages.shift()
+      if (messages.length === 0) {
+        receiver.receiving.delete(sender)
+      }
+      if (m === undefined) {
+        return this.flushRandomMessage()
+      }
+      const encoder = encoding.createEncoder()
+      // console.log('receive (' + sender.userID + '->' + receiver.userID + '):\n', syncProtocol.stringifySyncMessage(decoding.createDecoder(m), receiver))
+      // do not publish data created when this function is executed (could be ss2 or update message)
+      syncProtocol.readSyncMessage(decoding.createDecoder(m), encoder, receiver, receiver.tc)
+      if (encoding.length(encoder) > 0) {
+        // send reply message
+        sender._receive(encoding.toUint8Array(encoder), receiver)
+      }
+      return true
+    }
+    return false
+  }
+  /**
+   * @return {boolean} True iff this function actually flushed something
+   */
+  flushAllMessages () {
+    let didSomething = false
+    while (this.flushRandomMessage()) {
+      didSomething = true
+    }
+    return didSomething
+  }
+  reconnectAll () {
+    this.allConns.forEach(conn => conn.connect())
+  }
+  disconnectAll () {
+    this.allConns.forEach(conn => conn.disconnect())
+  }
+  syncAll () {
+    this.reconnectAll()
+    this.flushAllMessages()
+  }
+  /**
+   * @return {boolean} Whether it was possible to disconnect a randon connection.
+   */
+  disconnectRandom () {
+    if (this.onlineConns.size === 0) {
+      return false
+    }
+    prng.oneOf(this.prng, Array.from(this.onlineConns)).disconnect()
+    return true
+  }
+  /**
+   * @return {boolean} Whether it was possible to reconnect a random connection.
+   */
+  reconnectRandom () {
+    /**
+     * @type {Array<TestYInstance>}
+     */
+    const reconnectable = []
+    this.allConns.forEach(conn => {
+      if (!this.onlineConns.has(conn)) {
+        reconnectable.push(conn)
+      }
+    })
+    if (reconnectable.length === 0) {
+      return false
+    }
+    prng.oneOf(this.prng, reconnectable).connect()
+    return true
+  }
+}
+
+/**
+ * @template T
+ * @param {t.TestCase} tc
+ * @param {{users?:number}} conf
+ * @param {InitTestObjectCallback<T>} [initTestObject]
+ * @return {{testObjects:Array<any>,testConnector:TestConnector,users:Array<TestYInstance>,array0:Y.Array<any>,array1:Y.Array<any>,array2:Y.Array<any>,map0:Y.Map<any>,map1:Y.Map<any>,map2:Y.Map<any>,map3:Y.Map<any>,text0:Y.Text,text1:Y.Text,text2:Y.Text,xml0:Y.XmlElement,xml1:Y.XmlElement,xml2:Y.XmlElement}}
+ */
+export const init = (tc, { users = 5 } = {}, initTestObject) => {
+  /**
+   * @type {Object<string,any>}
+   */
+  const result = {
+    users: []
+  }
+  const gen = tc.prng
+  const testConnector = new TestConnector(gen)
+  result.testConnector = testConnector
+  for (let i = 0; i < users; i++) {
+    const y = testConnector.createY(i)
+    y.clientID = i
+    result.users.push(y)
+    result['array' + i] = y.get('array', Y.Array)
+    result['map' + i] = y.get('map', Y.Map)
+    result['xml' + i] = y.get('xml', Y.XmlElement)
+    result['text' + i] = y.get('text', Y.Text)
+  }
+  testConnector.syncAll()
+  result.testObjects = result.users.map(initTestObject || (() => null))
+  // @ts-ignore
+  return result
+}
+
+/**
+ * 1. reconnect and flush all
+ * 2. user 0 gc
+ * 3. get type content
+ * 4. disconnect & reconnect all (so gc is propagated)
+ * 5. compare os, ds, ss
+ *
+ * @param {Array<TestYInstance>} users
+ */
+export const compare = users => {
+  users.forEach(u => u.connect())
+  while (users[0].tc.flushAllMessages()) {}
+  const userArrayValues = users.map(u => u.getArray('array').toJSON().map(val => JSON.stringify(val)))
+  const userMapValues = users.map(u => u.getMap('map').toJSON())
+  const userXmlValues = users.map(u => u.get('xml', Y.XmlElement).toString())
+  const userTextValues = users.map(u => u.getText('text').toDelta())
+  for (const u of users) {
+    t.assert(u.store.pendingDeleteReaders.length === 0)
+    t.assert(u.store.pendingStack.length === 0)
+    t.assert(u.store.pendingClientsStructRefs.size === 0)
+  }
+  for (let i = 0; i < users.length - 1; i++) {
+    t.compare(userArrayValues[i].length, users[i].getArray('array').length)
+    t.compare(userArrayValues[i], userArrayValues[i + 1])
+    t.compare(userMapValues[i], userMapValues[i + 1])
+    t.compare(userXmlValues[i], userXmlValues[i + 1])
+    // @ts-ignore
+    t.compare(userTextValues[i].map(a => a.insert).join('').length, users[i].getText('text').length)
+    t.compare(userTextValues[i], userTextValues[i + 1])
+    t.compare(getStateVector(users[i].store), getStateVector(users[i + 1].store))
+    compareDS(createDeleteSetFromStructStore(users[i].store), createDeleteSetFromStructStore(users[i + 1].store))
+    compareStructStores(users[i].store, users[i + 1].store)
+  }
+  users.map(u => u.destroy())
+}
+
+/**
+ * @param {AbstractItem?} a
+ * @param {AbstractItem?} b
+ * @return {boolean}
+ */
+export const compareItemIDs = (a, b) => a === b || (a !== null && b != null && Y.compareIDs(a.id, b.id))
+
+/**
+ * @param {StructStore} ss1
+ * @param {StructStore} ss2
+ */
+export const compareStructStores = (ss1, ss2) => {
+  t.assert(ss1.clients.size === ss2.clients.size)
+  for (const [client, structs1] of ss1.clients) {
+    const structs2 = ss2.clients.get(client)
+    t.assert(structs2 !== undefined && structs1.length === structs2.length)
+    for (let i = 0; i < structs1.length; i++) {
+      const s1 = structs1[i]
+      // @ts-ignore
+      const s2 = structs2[i]
+      // checks for abstract struct
+      if (
+        s1.constructor !== s2.constructor ||
+        !Y.compareIDs(s1.id, s2.id) ||
+        s1.deleted !== s2.deleted ||
+        s1.length !== s2.length
+      ) {
+        t.fail('Structs dont match')
+      }
+      if (s1 instanceof AbstractItem) {
+        if (
+          !(s2 instanceof AbstractItem) ||
+          !((s1.left === null && s2.left === null) || (s1.left !== null && s2.left !== null && Y.compareIDs(s1.left.lastId, s2.left.lastId))) ||
+          !compareItemIDs(s1.right, s2.right) ||
+          !Y.compareIDs(s1.origin, s2.origin) ||
+          !Y.compareIDs(s1.rightOrigin, s2.rightOrigin) ||
+          s1.parentSub !== s2.parentSub
+        ) {
+          return t.fail('Items dont match')
+        }
+        // make sure that items are connected correctly
+        t.assert(s1.left === null || s1.left.right === s1)
+        t.assert(s1.right === null || s1.right.left === s1)
+        t.assert(s2.left === null || s2.left.right === s2)
+        t.assert(s2.right === null || s2.right.left === s2)
+      }
+    }
+  }
+}
+
+/**
+ * @param {DeleteSet} ds1
+ * @param {DeleteSet} ds2
+ */
+export const compareDS = (ds1, ds2) => {
+  t.assert(ds1.clients.size === ds2.clients.size)
+  for (const [client, deleteItems1] of ds1.clients) {
+    const deleteItems2 = ds2.clients.get(client)
+    t.assert(deleteItems2 !== undefined && deleteItems1.length === deleteItems2.length)
+    for (let i = 0; i < deleteItems1.length; i++) {
+      const di1 = deleteItems1[i]
+      // @ts-ignore
+      const di2 = deleteItems2[i]
+      if (di1.clock !== di2.clock || di1.len !== di2.len) {
+        t.fail('DeleteSets dont match')
+      }
+    }
+  }
+}
+
+/**
+ * @template T
+ * @callback InitTestObjectCallback
+ * @param {TestYInstance} y
+ * @return {T}
+ */
+
+/**
+ * @template T
+ * @param {t.TestCase} tc
+ * @param {Array<function(Y.Doc,prng.PRNG,T):void>} mods
+ * @param {number} iterations
+ * @param {InitTestObjectCallback<T>} [initTestObject]
+ */
+export const applyRandomTests = (tc, mods, iterations, initTestObject) => {
+  const gen = tc.prng
+  const result = init(tc, { users: 5 }, initTestObject || (() => null))
+  const { testConnector, users } = result
+  for (let i = 0; i < iterations; i++) {
+    if (prng.int31(gen, 0, 100) <= 2) {
+      // 2% chance to disconnect/reconnect a random user
+      if (prng.bool(gen)) {
+        testConnector.disconnectRandom()
+      } else {
+        testConnector.reconnectRandom()
+      }
+    } else if (prng.int31(gen, 0, 100) <= 1) {
+      // 1% chance to flush all
+      testConnector.flushAllMessages()
+    } else if (prng.int31(gen, 0, 100) <= 50) {
+      // 50% chance to flush a random message
+      testConnector.flushRandomMessage()
+    }
+    const user = prng.int31(gen, 0, users.length - 1)
+    const test = prng.oneOf(gen, mods)
+    test(users[user], gen, result.testObjects[user])
+  }
+  compare(users)
+  return result
+}
--- a/tests/y-array.tests.js
+++ b/tests/y-array.tests.js
@@ -0,0 +1,448 @@
+import { init, compare, applyRandomTests, TestYInstance } from './testHelper.js' // eslint-disable-line
+
+import * as Y from '../src/index.js'
+import * as t from 'lib0/testing.js'
+import * as prng from 'lib0/prng.js'
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testDeleteInsert = tc => {
+  const { users, array0 } = init(tc, { users: 2 })
+  array0.delete(0, 0)
+  t.describe('Does not throw when deleting zero elements with position 0')
+  t.fails(() => {
+    array0.delete(1, 1)
+  })
+  array0.insert(0, ['A'])
+  array0.delete(1, 0)
+  t.describe('Does not throw when deleting zero elements with valid position 1')
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testInsertThreeElementsTryRegetProperty = tc => {
+  const { testConnector, users, array0, array1 } = init(tc, { users: 2 })
+  array0.insert(0, [1, true, false])
+  t.compare(array0.toJSON(), [1, true, false], '.toJSON() works')
+  testConnector.flushAllMessages()
+  t.compare(array1.toJSON(), [1, true, false], '.toJSON() works after sync')
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testConcurrentInsertWithThreeConflicts = tc => {
+  var { users, array0, array1, array2 } = init(tc, { users: 3 })
+  array0.insert(0, [0])
+  array1.insert(0, [1])
+  array2.insert(0, [2])
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testConcurrentInsertDeleteWithThreeConflicts = tc => {
+  const { testConnector, users, array0, array1, array2 } = init(tc, { users: 3 })
+  array0.insert(0, ['x', 'y', 'z'])
+  testConnector.flushAllMessages()
+  array0.insert(1, [0])
+  array1.delete(0)
+  array1.delete(1, 1)
+  array2.insert(1, [2])
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testInsertionsInLateSync = tc => {
+  const { testConnector, users, array0, array1, array2 } = init(tc, { users: 3 })
+  array0.insert(0, ['x', 'y'])
+  testConnector.flushAllMessages()
+  users[1].disconnect()
+  users[2].disconnect()
+  array0.insert(1, ['user0'])
+  array1.insert(1, ['user1'])
+  array2.insert(1, ['user2'])
+  users[1].connect()
+  users[2].connect()
+  testConnector.flushAllMessages()
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testDisconnectReallyPreventsSendingMessages = tc => {
+  var { testConnector, users, array0, array1 } = init(tc, { users: 3 })
+  array0.insert(0, ['x', 'y'])
+  testConnector.flushAllMessages()
+  users[1].disconnect()
+  users[2].disconnect()
+  array0.insert(1, ['user0'])
+  array1.insert(1, ['user1'])
+  t.compare(array0.toJSON(), ['x', 'user0', 'y'])
+  t.compare(array1.toJSON(), ['x', 'user1', 'y'])
+  users[1].connect()
+  users[2].connect()
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testDeletionsInLateSync = tc => {
+  const { testConnector, users, array0, array1 } = init(tc, { users: 2 })
+  array0.insert(0, ['x', 'y'])
+  testConnector.flushAllMessages()
+  users[1].disconnect()
+  array1.delete(1, 1)
+  array0.delete(0, 2)
+  users[1].connect()
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testInsertThenMergeDeleteOnSync = tc => {
+  const { testConnector, users, array0, array1 } = init(tc, { users: 2 })
+  array0.insert(0, ['x', 'y', 'z'])
+  testConnector.flushAllMessages()
+  users[0].disconnect()
+  array1.delete(0, 3)
+  users[0].connect()
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testInsertAndDeleteEvents = tc => {
+  const { array0, users } = init(tc, { users: 2 })
+  /**
+   * @type {Object<string,any>?}
+   */
+  let event = null
+  array0.observe(e => {
+    event = e
+  })
+  array0.insert(0, [0, 1, 2])
+  t.assert(event !== null)
+  event = null
+  array0.delete(0)
+  t.assert(event !== null)
+  event = null
+  array0.delete(0, 2)
+  t.assert(event !== null)
+  event = null
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testNestedObserverEvents = tc => {
+  const { array0, users } = init(tc, { users: 2 })
+  /**
+   * @type {Array<number>}
+   */
+  const vals = []
+  array0.observe(e => {
+    if (array0.length === 1) {
+      // inserting, will call this observer again
+      // we expect that this observer is called after this event handler finishedn
+      array0.insert(1, [1])
+      vals.push(0)
+    } else {
+      // this should be called the second time an element is inserted (above case)
+      vals.push(1)
+    }
+  })
+  array0.insert(0, [0])
+  t.compareArrays(vals, [0, 1])
+  t.compareArrays(array0.toArray(), [0, 1])
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testInsertAndDeleteEventsForTypes = tc => {
+  const { array0, users } = init(tc, { users: 2 })
+  /**
+   * @type {Object<string,any>|null}
+   */
+  let event = null
+  array0.observe(e => {
+    event = e
+  })
+  array0.insert(0, [new Y.Array()])
+  t.assert(event !== null)
+  event = null
+  array0.delete(0)
+  t.assert(event !== null)
+  event = null
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testInsertAndDeleteEventsForTypes2 = tc => {
+  const { array0, users } = init(tc, { users: 2 })
+  /**
+   * @type {Array<Object<string,any>>}
+   */
+  let events = []
+  array0.observe(e => {
+    events.push(e)
+  })
+  array0.insert(0, ['hi', new Y.Map()])
+  t.assert(events.length === 1, 'Event is triggered exactly once for insertion of two elements')
+  array0.delete(1)
+  t.assert(events.length === 2, 'Event is triggered exactly once for deletion')
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testGarbageCollector = tc => {
+  const { testConnector, users, array0 } = init(tc, { users: 3 })
+  array0.insert(0, ['x', 'y', 'z'])
+  testConnector.flushAllMessages()
+  users[0].disconnect()
+  array0.delete(0, 3)
+  users[0].connect()
+  testConnector.flushAllMessages()
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testEventTargetIsSetCorrectlyOnLocal = tc => {
+  const { array0, users } = init(tc, { users: 3 })
+  /**
+   * @type {any}
+   */
+  let event
+  array0.observe(e => {
+    event = e
+  })
+  array0.insert(0, ['stuff'])
+  t.assert(event.target === array0, '"target" property is set correctly')
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testEventTargetIsSetCorrectlyOnRemote = tc => {
+  const { testConnector, array0, array1, users } = init(tc, { users: 3 })
+  /**
+   * @type {any}
+   */
+  let event
+  array0.observe(e => {
+    event = e
+  })
+  array1.insert(0, ['stuff'])
+  testConnector.flushAllMessages()
+  t.assert(event.target === array0, '"target" property is set correctly')
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testIteratingArrayContainingTypes = tc => {
+  const y = new Y.Doc()
+  const arr = y.getArray('arr')
+  const numItems = 10
+  for (let i = 0; i < numItems; i++) {
+    const map = new Y.Map()
+    map.set('value', i)
+    arr.push([map])
+  }
+  let cnt = 0
+  for (let item of arr) {
+    t.assert(item.get('value') === cnt++, 'value is correct')
+  }
+  y.destroy()
+}
+
+let _uniqueNumber = 0
+const getUniqueNumber = () => _uniqueNumber++
+
+/**
+ * @type {Array<function(TestYInstance,prng.PRNG):void>}
+ */
+const arrayTransactions = [
+  function insert (user, gen) {
+    const yarray = user.getArray('array')
+    var uniqueNumber = getUniqueNumber()
+    var content = []
+    var len = prng.int31(gen, 1, 4)
+    for (var i = 0; i < len; i++) {
+      content.push(uniqueNumber)
+    }
+    var pos = prng.int31(gen, 0, yarray.length)
+    yarray.insert(pos, content)
+  },
+  function insertTypeArray (user, gen) {
+    const yarray = user.getArray('array')
+    var pos = prng.int31(gen, 0, yarray.length)
+    yarray.insert(pos, [new Y.Array()])
+    var array2 = yarray.get(pos)
+    array2.insert(0, [1, 2, 3, 4])
+  },
+  function insertTypeMap (user, gen) {
+    const yarray = user.getArray('array')
+    var pos = prng.int31(gen, 0, yarray.length)
+    yarray.insert(pos, [new Y.Map()])
+    var map = yarray.get(pos)
+    map.set('someprop', 42)
+    map.set('someprop', 43)
+    map.set('someprop', 44)
+  },
+  function _delete (user, gen) {
+    const yarray = user.getArray('array')
+    var length = yarray.length
+    if (length > 0) {
+      var somePos = prng.int31(gen, 0, length - 1)
+      var delLength = prng.int31(gen, 1, Math.min(2, length - somePos))
+      if (prng.bool(gen)) {
+        var type = yarray.get(somePos)
+        if (type.length > 0) {
+          somePos = prng.int31(gen, 0, type.length - 1)
+          delLength = prng.int31(gen, 0, Math.min(2, type.length - somePos))
+          type.delete(somePos, delLength)
+        }
+      } else {
+        yarray.delete(somePos, delLength)
+      }
+    }
+  }
+]
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests4 = tc => {
+  applyRandomTests(tc, arrayTransactions, 4)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests40 = tc => {
+  applyRandomTests(tc, arrayTransactions, 40)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests42 = tc => {
+  applyRandomTests(tc, arrayTransactions, 42)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests43 = tc => {
+  applyRandomTests(tc, arrayTransactions, 43)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests44 = tc => {
+  applyRandomTests(tc, arrayTransactions, 44)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests45 = tc => {
+  applyRandomTests(tc, arrayTransactions, 45)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests46 = tc => {
+  applyRandomTests(tc, arrayTransactions, 46)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests300 = tc => {
+  applyRandomTests(tc, arrayTransactions, 300)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests400 = tc => {
+  applyRandomTests(tc, arrayTransactions, 400)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests500 = tc => {
+  applyRandomTests(tc, arrayTransactions, 500)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests600 = tc => {
+  applyRandomTests(tc, arrayTransactions, 600)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests1000 = tc => {
+  applyRandomTests(tc, arrayTransactions, 1000)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests1800 = tc => {
+  applyRandomTests(tc, arrayTransactions, 1800)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests3000 = tc => {
+  t.skip(!t.production)
+  applyRandomTests(tc, arrayTransactions, 3000)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests5000 = tc => {
+  t.skip(!t.production)
+  applyRandomTests(tc, arrayTransactions, 5000)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYarrayTests30000 = tc => {
+  t.skip(!t.production)
+  applyRandomTests(tc, arrayTransactions, 30000)
+}
--- a/tests/y-map.tests.js
+++ b/tests/y-map.tests.js
@@ -0,0 +1,468 @@
+import { init, compare, applyRandomTests, TestYInstance } from './testHelper.js' // eslint-disable-line
+
+import {
+  compareIDs
+} from '../src/internals.js'
+
+import * as Y from '../src/index.js'
+import * as t from 'lib0/testing.js'
+import * as prng from 'lib0/prng.js'
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testBasicMapTests = tc => {
+  const { testConnector, users, map0, map1, map2 } = init(tc, { users: 3 })
+  users[2].disconnect()
+
+  map0.set('number', 1)
+  map0.set('string', 'hello Y')
+  map0.set('object', { key: { key2: 'value' } })
+  map0.set('y-map', new Y.Map())
+  map0.set('boolean1', true)
+  map0.set('boolean0', false)
+  const map = map0.get('y-map')
+  map.set('y-array', new Y.Array())
+  const array = map.get('y-array')
+  array.insert(0, [0])
+  array.insert(0, [-1])
+
+  t.assert(map0.get('number') === 1, 'client 0 computed the change (number)')
+  t.assert(map0.get('string') === 'hello Y', 'client 0 computed the change (string)')
+  t.assert(map0.get('boolean0') === false, 'client 0 computed the change (boolean)')
+  t.assert(map0.get('boolean1') === true, 'client 0 computed the change (boolean)')
+  t.compare(map0.get('object'), { key: { key2: 'value' } }, 'client 0 computed the change (object)')
+  t.assert(map0.get('y-map').get('y-array').get(0) === -1, 'client 0 computed the change (type)')
+
+  users[2].connect()
+  testConnector.flushAllMessages()
+
+  t.assert(map1.get('number') === 1, 'client 1 received the update (number)')
+  t.assert(map1.get('string') === 'hello Y', 'client 1 received the update (string)')
+  t.assert(map1.get('boolean0') === false, 'client 1 computed the change (boolean)')
+  t.assert(map1.get('boolean1') === true, 'client 1 computed the change (boolean)')
+  t.compare(map1.get('object'), { key: { key2: 'value' } }, 'client 1 received the update (object)')
+  t.assert(map1.get('y-map').get('y-array').get(0) === -1, 'client 1 received the update (type)')
+
+  // compare disconnected user
+  t.assert(map2.get('number') === 1, 'client 2 received the update (number) - was disconnected')
+  t.assert(map2.get('string') === 'hello Y', 'client 2 received the update (string) - was disconnected')
+  t.assert(map2.get('boolean0') === false, 'client 2 computed the change (boolean)')
+  t.assert(map2.get('boolean1') === true, 'client 2 computed the change (boolean)')
+  t.compare(map2.get('object'), { key: { key2: 'value' } }, 'client 2 received the update (object) - was disconnected')
+  t.assert(map2.get('y-map').get('y-array').get(0) === -1, 'client 2 received the update (type) - was disconnected')
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testGetAndSetOfMapProperty = tc => {
+  const { testConnector, users, map0 } = init(tc, { users: 2 })
+  map0.set('stuff', 'stuffy')
+  map0.set('undefined', undefined)
+  map0.set('null', null)
+  t.compare(map0.get('stuff'), 'stuffy')
+
+  testConnector.flushAllMessages()
+
+  for (let user of users) {
+    const u = user.getMap('map')
+    t.compare(u.get('stuff'), 'stuffy')
+    t.assert(u.get('undefined') === undefined, 'undefined')
+    t.compare(u.get('null'), null, 'null')
+  }
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testYmapSetsYmap = tc => {
+  const { users, map0 } = init(tc, { users: 2 })
+  const map = map0.set('Map', new Y.Map())
+  t.assert(map0.get('Map') === map)
+  map.set('one', 1)
+  t.compare(map.get('one'), 1)
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testYmapSetsYarray = tc => {
+  const { users, map0 } = init(tc, { users: 2 })
+  const array = map0.set('Array', new Y.Array())
+  t.assert(array === map0.get('Array'))
+  array.insert(0, [1, 2, 3])
+  // @ts-ignore
+  t.compare(map0.toJSON(), { Array: [1, 2, 3] })
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testGetAndSetOfMapPropertySyncs = tc => {
+  const { testConnector, users, map0 } = init(tc, { users: 2 })
+  map0.set('stuff', 'stuffy')
+  t.compare(map0.get('stuff'), 'stuffy')
+  testConnector.flushAllMessages()
+  for (let user of users) {
+    var u = user.getMap('map')
+    t.compare(u.get('stuff'), 'stuffy')
+  }
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testGetAndSetOfMapPropertyWithConflict = tc => {
+  const { testConnector, users, map0, map1 } = init(tc, { users: 3 })
+  map0.set('stuff', 'c0')
+  map1.set('stuff', 'c1')
+  testConnector.flushAllMessages()
+  for (let user of users) {
+    var u = user.getMap('map')
+    t.compare(u.get('stuff'), 'c1')
+  }
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testGetAndSetAndDeleteOfMapProperty = tc => {
+  const { testConnector, users, map0, map1 } = init(tc, { users: 3 })
+  map0.set('stuff', 'c0')
+  map1.set('stuff', 'c1')
+  map1.delete('stuff')
+  testConnector.flushAllMessages()
+  for (let user of users) {
+    var u = user.getMap('map')
+    t.assert(u.get('stuff') === undefined)
+  }
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testGetAndSetOfMapPropertyWithThreeConflicts = tc => {
+  const { testConnector, users, map0, map1, map2 } = init(tc, { users: 3 })
+  map0.set('stuff', 'c0')
+  map1.set('stuff', 'c1')
+  map1.set('stuff', 'c2')
+  map2.set('stuff', 'c3')
+  testConnector.flushAllMessages()
+  for (let user of users) {
+    var u = user.getMap('map')
+    t.compare(u.get('stuff'), 'c3')
+  }
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testGetAndSetAndDeleteOfMapPropertyWithThreeConflicts = tc => {
+  const { testConnector, users, map0, map1, map2, map3 } = init(tc, { users: 4 })
+  map0.set('stuff', 'c0')
+  map1.set('stuff', 'c1')
+  map1.set('stuff', 'c2')
+  map2.set('stuff', 'c3')
+  testConnector.flushAllMessages()
+  map0.set('stuff', 'deleteme')
+  map1.set('stuff', 'c1')
+  map2.set('stuff', 'c2')
+  map3.set('stuff', 'c3')
+  map3.delete('stuff')
+  testConnector.flushAllMessages()
+  for (let user of users) {
+    var u = user.getMap('map')
+    t.assert(u.get('stuff') === undefined)
+  }
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testObserveDeepProperties = tc => {
+  const { testConnector, users, map1, map2, map3 } = init(tc, { users: 4 })
+  const _map1 = map1.set('map', new Y.Map())
+  let calls = 0
+  let dmapid
+  map1.observeDeep(events => {
+    events.forEach(event => {
+      calls++
+      // @ts-ignore
+      t.assert(event.keysChanged.has('deepmap'))
+      t.assert(event.path.length === 1)
+      t.assert(event.path[0] === 'map')
+      // @ts-ignore
+      dmapid = event.target.get('deepmap')._item.id
+    })
+  })
+  testConnector.flushAllMessages()
+  const _map3 = map3.get('map')
+  _map3.set('deepmap', new Y.Map())
+  testConnector.flushAllMessages()
+  const _map2 = map2.get('map')
+  _map2.set('deepmap', new Y.Map())
+  testConnector.flushAllMessages()
+  const dmap1 = _map1.get('deepmap')
+  const dmap2 = _map2.get('deepmap')
+  const dmap3 = _map3.get('deepmap')
+  t.assert(calls > 0)
+  t.assert(compareIDs(dmap1._item.id, dmap2._item.id))
+  t.assert(compareIDs(dmap1._item.id, dmap3._item.id))
+  // @ts-ignore we want the possibility of dmapid being undefined
+  t.assert(compareIDs(dmap1._item.id, dmapid))
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testObserversUsingObservedeep = tc => {
+  const { users, map0 } = init(tc, { users: 2 })
+  /**
+   * @type {Array<Array<string|number>>}
+   */
+  const pathes = []
+  let calls = 0
+  map0.observeDeep(events => {
+    events.forEach(event => {
+      pathes.push(event.path)
+    })
+    calls++
+  })
+  map0.set('map', new Y.Map())
+  map0.get('map').set('array', new Y.Array())
+  map0.get('map').get('array').insert(0, ['content'])
+  t.assert(calls === 3)
+  t.compare(pathes, [[], ['map'], ['map', 'array']])
+  compare(users)
+}
+
+// TODO: Test events in Y.Map
+/**
+ * @param {Object<string,any>} is
+ * @param {Object<string,any>} should
+ */
+const compareEvent = (is, should) => {
+  for (var key in should) {
+    t.compare(should[key], is[key])
+  }
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testThrowsAddAndUpdateAndDeleteEvents = tc => {
+  const { users, map0 } = init(tc, { users: 2 })
+  /**
+   * @type {Object<string,any>}
+   */
+  let event = {}
+  map0.observe(e => {
+    event = e // just put it on event, should be thrown synchronously anyway
+  })
+  map0.set('stuff', 4)
+  compareEvent(event, {
+    target: map0,
+    keysChanged: new Set(['stuff'])
+  })
+  // update, oldValue is in contents
+  map0.set('stuff', new Y.Array())
+  compareEvent(event, {
+    target: map0,
+    keysChanged: new Set(['stuff'])
+  })
+  // update, oldValue is in opContents
+  map0.set('stuff', 5)
+  // delete
+  map0.delete('stuff')
+  compareEvent(event, {
+    keysChanged: new Set(['stuff']),
+    target: map0
+  })
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testYmapEventHasCorrectValueWhenSettingAPrimitive = tc => {
+  const { users, map0 } = init(tc, { users: 3 })
+  /**
+   * @type {Object<string,any>}
+   */
+  let event = {}
+  map0.observe(e => {
+    event = e
+  })
+  map0.set('stuff', 2)
+  t.compare(event.value, event.target.get(event.name))
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testYmapEventHasCorrectValueWhenSettingAPrimitiveFromOtherUser = tc => {
+  const { users, map0, map1, testConnector } = init(tc, { users: 3 })
+  /**
+   * @type {Object<string,any>}
+   */
+  let event = {}
+  map0.observe(e => {
+    event = e
+  })
+  map1.set('stuff', 2)
+  testConnector.flushAllMessages()
+  t.compare(event.value, event.target.get(event.name))
+  compare(users)
+}
+
+/**
+ * @type {Array<function(TestYInstance,prng.PRNG):void>}
+ */
+const mapTransactions = [
+  function set (user, gen) {
+    let key = prng.oneOf(gen, ['one', 'two'])
+    var value = prng.utf16String(gen)
+    user.getMap('map').set(key, value)
+  },
+  function setType (user, gen) {
+    let key = prng.oneOf(gen, ['one', 'two'])
+    var type = prng.oneOf(gen, [new Y.Array(), new Y.Map()])
+    user.getMap('map').set(key, type)
+    if (type instanceof Y.Array) {
+      type.insert(0, [1, 2, 3, 4])
+    } else {
+      type.set('deepkey', 'deepvalue')
+    }
+  },
+  function _delete (user, gen) {
+    let key = prng.oneOf(gen, ['one', 'two'])
+    user.getMap('map').delete(key)
+  }
+]
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests10 = tc => {
+  applyRandomTests(tc, mapTransactions, 10)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests40 = tc => {
+  applyRandomTests(tc, mapTransactions, 40)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests42 = tc => {
+  applyRandomTests(tc, mapTransactions, 42)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests43 = tc => {
+  applyRandomTests(tc, mapTransactions, 43)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests44 = tc => {
+  applyRandomTests(tc, mapTransactions, 44)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests45 = tc => {
+  applyRandomTests(tc, mapTransactions, 45)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests46 = tc => {
+  applyRandomTests(tc, mapTransactions, 46)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests300 = tc => {
+  applyRandomTests(tc, mapTransactions, 300)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests400 = tc => {
+  applyRandomTests(tc, mapTransactions, 400)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests500 = tc => {
+  applyRandomTests(tc, mapTransactions, 500)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests600 = tc => {
+  applyRandomTests(tc, mapTransactions, 600)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests1000 = tc => {
+  applyRandomTests(tc, mapTransactions, 1000)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests1800 = tc => {
+  applyRandomTests(tc, mapTransactions, 1800)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests5000 = tc => {
+  t.skip(!t.production)
+  applyRandomTests(tc, mapTransactions, 5000)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests10000 = tc => {
+  t.skip(!t.production)
+  applyRandomTests(tc, mapTransactions, 10000)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testRepeatGeneratingYmapTests100000 = tc => {
+  t.skip(!t.production)
+  applyRandomTests(tc, mapTransactions, 100000)
+}
--- a/tests/y-text.tests.js
+++ b/tests/y-text.tests.js
@@ -0,0 +1,76 @@
+import { init, compare } from './testHelper.js'
+
+import * as t from 'lib0/testing.js'
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testBasicInsertAndDelete = tc => {
+  const { users, text0 } = init(tc, { users: 2 })
+  let delta
+
+  text0.observe(event => {
+    delta = event.delta
+  })
+
+  text0.delete(0, 0)
+  t.assert(true, 'Does not throw when deleting zero elements with position 0')
+
+  text0.insert(0, 'abc')
+  t.assert(text0.toString() === 'abc', 'Basic insert works')
+  t.compare(delta, [{ insert: 'abc' }])
+
+  text0.delete(0, 1)
+  t.assert(text0.toString() === 'bc', 'Basic delete works (position 0)')
+  t.compare(delta, [{ delete: 1 }])
+
+  text0.delete(1, 1)
+  t.assert(text0.toString() === 'b', 'Basic delete works (position 1)')
+  t.compare(delta, [{ retain: 1 }, { delete: 1 }])
+
+  users[0].transact(() => {
+    text0.insert(0, '1')
+    text0.delete(0, 1)
+  })
+  t.compare(delta, [])
+
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testBasicFormat = tc => {
+  const { users, text0 } = init(tc, { users: 2 })
+  let delta
+  text0.observe(event => {
+    delta = event.delta
+  })
+  text0.insert(0, 'abc', { bold: true })
+  t.assert(text0.toString() === 'abc', 'Basic insert with attributes works')
+  t.compare(text0.toDelta(), [{ insert: 'abc', attributes: { bold: true } }])
+  t.compare(delta, [{ insert: 'abc', attributes: { bold: true } }])
+  text0.delete(0, 1)
+  t.assert(text0.toString() === 'bc', 'Basic delete on formatted works (position 0)')
+  t.compare(text0.toDelta(), [{ insert: 'bc', attributes: { bold: true } }])
+  t.compare(delta, [{ delete: 1 }])
+  text0.delete(1, 1)
+  t.assert(text0.toString() === 'b', 'Basic delete works (position 1)')
+  t.compare(text0.toDelta(), [{ insert: 'b', attributes: { bold: true } }])
+  t.compare(delta, [{ retain: 1 }, { delete: 1 }])
+  text0.insert(0, 'z', { bold: true })
+  t.assert(text0.toString() === 'zb')
+  t.compare(text0.toDelta(), [{ insert: 'zb', attributes: { bold: true } }])
+  t.compare(delta, [{ insert: 'z', attributes: { bold: true } }])
+  // @ts-ignore
+  t.assert(text0._start.right.right.right.string === 'b', 'Does not insert duplicate attribute marker')
+  text0.insert(0, 'y')
+  t.assert(text0.toString() === 'yzb')
+  t.compare(text0.toDelta(), [{ insert: 'y' }, { insert: 'zb', attributes: { bold: true } }])
+  t.compare(delta, [{ insert: 'y' }])
+  text0.format(0, 2, { bold: null })
+  t.assert(text0.toString() === 'yzb')
+  t.compare(text0.toDelta(), [{ insert: 'yz' }, { insert: 'b', attributes: { bold: true } }])
+  t.compare(delta, [{ retain: 1 }, { retain: 1, attributes: { bold: null } }])
+  compare(users)
+}
--- a/tests/y-xml.tests.js
+++ b/tests/y-xml.tests.js
@@ -0,0 +1,75 @@
+import { init, compare } from './testHelper.js'
+import * as Y from '../src/index.js'
+
+import * as t from 'lib0/testing.js'
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testSetProperty = tc => {
+  const { testConnector, users, xml0, xml1 } = init(tc, { users: 2 })
+  xml0.setAttribute('height', '10')
+  t.assert(xml0.getAttribute('height') === '10', 'Simple set+get works')
+  testConnector.flushAllMessages()
+  t.assert(xml1.getAttribute('height') === '10', 'Simple set+get works (remote)')
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testEvents = tc => {
+  const { testConnector, users, xml0, xml1 } = init(tc, { users: 2 })
+  /**
+   * @type {any}
+   */
+  let event
+  /**
+   * @type {any}
+   */
+  let remoteEvent
+  xml0.observe(e => {
+    event = e
+  })
+  xml1.observe(e => {
+    remoteEvent = e
+  })
+  xml0.setAttribute('key', 'value')
+  t.assert(event.attributesChanged.has('key'), 'YXmlEvent.attributesChanged on updated key')
+  testConnector.flushAllMessages()
+  t.assert(remoteEvent.attributesChanged.has('key'), 'YXmlEvent.attributesChanged on updated key (remote)')
+  // check attributeRemoved
+  xml0.removeAttribute('key')
+  t.assert(event.attributesChanged.has('key'), 'YXmlEvent.attributesChanged on removed attribute')
+  testConnector.flushAllMessages()
+  t.assert(remoteEvent.attributesChanged.has('key'), 'YXmlEvent.attributesChanged on removed attribute (remote)')
+  xml0.insert(0, [new Y.XmlText('some text')])
+  t.assert(event.childListChanged, 'YXmlEvent.childListChanged on inserted element')
+  testConnector.flushAllMessages()
+  t.assert(remoteEvent.childListChanged, 'YXmlEvent.childListChanged on inserted element (remote)')
+  // test childRemoved
+  xml0.delete(0)
+  t.assert(event.childListChanged, 'YXmlEvent.childListChanged on deleted element')
+  testConnector.flushAllMessages()
+  t.assert(remoteEvent.childListChanged, 'YXmlEvent.childListChanged on deleted element (remote)')
+  compare(users)
+}
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testTreewalker = tc => {
+  const { users, xml0 } = init(tc, { users: 3 })
+  let paragraph1 = new Y.XmlElement('p')
+  let paragraph2 = new Y.XmlElement('p')
+  let text1 = new Y.XmlText('init')
+  let text2 = new Y.XmlText('text')
+  paragraph1.insert(0, [text1, text2])
+  xml0.insert(0, [paragraph1, paragraph2, new Y.XmlElement('img')])
+  let allParagraphs = xml0.querySelectorAll('p')
+  t.assert(allParagraphs.length === 2, 'found exactly two paragraphs')
+  t.assert(allParagraphs[0] === paragraph1, 'querySelectorAll found paragraph1')
+  t.assert(allParagraphs[1] === paragraph2, 'querySelectorAll found paragraph2')
+  t.assert(xml0.querySelector('p') === paragraph1, 'querySelector found paragraph1')
+  compare(users)
+}
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -0,0 +1,62 @@
+{
+  "compilerOptions": {
+    /* Basic Options */
+    "target": "es2018",
+    "lib": ["es2018", "dom"],                             /* Specify library files to be included in the compilation. */
+    "allowJs": true,                       /* Allow javascript files to be compiled. */
+    "checkJs": true,                       /* Report errors in .js files. */
+    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
+    // "declaration": true,                   /* Generates corresponding '.d.ts' file. */
+    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    // "sourceMap": true,                     /* Generates corresponding '.map' file. */
+    // "outFile": "./",                       /* Concatenate and emit output to single file. */
+    // "outDir": "./build",                        /* Redirect output structure to the directory. */
+    // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                     /* Enable project compilation */
+    // "removeComments": true,                /* Do not emit comments to output. */
+    "noEmit": true,                        /* Do not emit outputs. */
+    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true,                           /* Enable all strict type-checking options. */
+    "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
+    // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                /* Report errors on unused locals. */
+    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+
+    /* Module Resolution Options */
+    "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                       /* List of folders to include type definitions from. */
+    // "types": [],                           /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true,                   /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+
+    /* Source Map Options */
+    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
+    "maxNodeModuleJsDepth": 5,
+    // "types": ["./src/utils/typedefs.js"]
+  },
+  "include": ["./src/**/*", "./tests/**/*"],
+  "exclude": ["../lib0/**/*", "node_modules/**/*", "dist", "dist/**/*.js"]
+}